Lesson_for_java_day07--java中数组的定义及常见排序方法--冒泡法、简单选择法、直接插入法和调用方法排序

一、数组的定义

在java中数组被看成是一个对象.在定义数组时，有两种定义方法：int[] a 和int a[]；
第二种是C/C++对数组定义方式，对于JAVA建议采用第一种定义方式。
总的原则：任何对象在被调用之前必须先被初始化！

1、一维数组的定义
定义包含三个元素的一维数组
方法1：先new对象，然后再初始化每个元素。int[] a = new int[3];
用new int[3]这种方式创建对象，对象已经被初始化并赋初值为0。
方法2：直接赋初值来创建对象。int[] b = {1,2,3};
方法3：new完对象直接初始化。int[] c = new int[]{1,2,3};
如果指定了数组初始化操作，则不能定义维表达式。

注意：如果用new定义数组时，必须指定其维度，这样定义是错误的: int[] d = new int[];
如果无法确定其元素个数，可以这样定义:int[] e = {};

2、二维数组的定义。基本与一维数组类似
定义一个3行5列的二维数组

方法1：先new对象，然后再初始化每个元素。int[][] a = new int[3][5];

方法：直接赋初值来创建对象。int[][] b = {{1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };
方法3，new完对象直接初始化。int[][] a = new int[][] {{1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };

注意：定义二维数组必须指定其行数，列数可以指定，可以不指定。
这样定义是正确的：int[][] d = new int[3][];
这样定义是错误的：int[][] d = new int[][4]; int[][] d = new int[][];

也可以定义不规则数组：
arr = new int[2][];
arr[0] = new int[3];
arr[1] = new int[5];

3、数组的长度
length是数组的一个属性(不是方法!)，对于一维数组int[] b = {1,2,3}; b.length的值是3，

4、数组的初始值



二、数组的排序方法

java中常见的四种数组排序方法：

1、调用方法排序法：
直接调用Array.sort(int[] arr),对数组进行排序

2、冒泡法：
基本思想：依次比较相邻的两个数，将小数放在前面，大数放在后面（或者大在前，小在后）
优点：稳定
缺点：比较的数多，速度慢，每次只能移动相邻两个数据，时间长，效率低
示意图：



3、简单选择排序法：
基本思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
顺序放在已排好序的数列的最后（最前），直到全部待排序的数据元素排完。
优点：移动数据的次数已知（n-1次）。
缺点：不是稳定的排序方法，比较次数多。
示意图：



4、直接插入排序法：
基本思想：将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
优点：是稳定的排序方法，速度较快。
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，
可链表可以解决这个问题。此算法适用于少量数据的排序。
示意图：



代码：

/*
java数组中最常见的几种排序方式：
1、调用方法排序法：
直接调用Array.sort(int[] arr),对数组进行排序

2、冒泡法：
基本思想：依次比较相邻的两个数，将小数放在前面，大数放在后面（或者大在前，小在后）
优点：稳定
缺点：比较的数多，速度慢，每次只能移动相邻两个数据，时间长，效率低

3、简单选择排序法：
基本思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
顺序放在已排好序的数列的最后（最前），直到全部待排序的数据元素排完。
优点：移动数据的次数已知（n-1次）。
缺点：不是稳定的排序方法，比较次数多。

4、直接插入排序法：
基本思想：将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
优点：是稳定的排序方法，速度较快。
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，
可链表可以解决这个问题。此算法适用于少量数据的排序。
*/

import java.util.Arrays;
public class sortDemo{
public static void main(String[] args){
//打印排序前的数组
sopArray(creatArray());

//打印排序后的数组
//fastSort(creatArray());//快速排序
//bubbleSort(creatArray());//冒泡排序
//selectSort(creatArray());//选择排序法
insertSort(creatArray());//插入排序法
}

//创建一个数组
public static int[] creatArray(){
int[] arr = new int[]{49,38,65,97,76,13,27,17,18,23,25,53,51};
return arr;
}

//快速排序法
public static void fastSort(int[] arr){
Arrays.sort(arr);  //进行排序
sopArray(arr);//打印数组
}

//冒泡排序法
public static void bubbleSort(int[] arr){
int temp = 0;
for(int i = 0; i < arr.length-1; i++){//遍历arr.length-1次
for(int j = 0; j < arr.length-1-i; j++){
if(arr[j] > arr[j + 1]){//比较相邻两个数，并做调整
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
sopArray(arr);//打印数组
}

//选择排序法
public static void selectSort(int[] arr){
for(int i = 0; i < arr.length-1; i++){//遍历arr.length-1次
int min = i;
for(int j = i+1; j < arr.length; j++){
if(arr[min] > arr[j]) min = j;//比较两数的值，并调整下标
}
if(min != i){//判断是否需要调整元素
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
sopArray(arr);//打印数组
}

//插入排序法
public static void insertSort(int[] arr){
for(int i =1; i < arr.length; i++){
for(int j =i; j > 0; j--){
if(arr[j] < arr[j-1]){
int temp = arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
else break;
}
}
sopArray(arr);
}

//打印数组
public static void sopArray(int[] arr){
sop("[");
for(int i = 0; i < arr.length; i++){
if(i == arr.length - 1)
sop(arr[i] + "]");
else
sop(arr[i]
4000
+ ",");
}
sop("\n");
}

//打印字符串
public static void sop(String s){
System.out.print(s);
}
}