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] + ",");
		}
		sop("\n");
	}
	
	//打印字符串
	public static void sop(String s){
		System.out.print(s);
	}
}