算法排序

【直接插入排序法】

直接插入排序属于稳定的排序，最坏时间复杂性为O(n^2)，空间复杂度为O(1)。

从数组的第二位开始与已排序的数列比较，插入到已排序列中.

 46 58 15 45 90 18 10 62  从第二位开始58比46大，数列不变

 46 58 15 45 90 18 10 62  第三位是15，比58，46都小，插入到46之前

 15 46 58 45 90 18 10 62  第四位是45，比46小，比15大，插入到46之前

 15 45 46 58 90 18 10 62  第五位是90，不变

 15 45 46 58 90 18 10 62  第六位是18，比45小，比15大，放在45之前

 15 18 45 46 58 90 10 62  第七位是10，最小，放在15之前

 10 15 18 45 46 58 90 62  第八为是62 ，放在90前

 10 15 18 45 46 58 62 90 

public class InsertSort{

	public static void main(String[] args) {
		int[] array = { 46, 58, 15, 45, 90, 18, 10, 62 };
		insertSort(array);
	}

	static void insertSort(int[] array) {
		int j, temp;
		// i=1,从数组的第二个数开始插入，与第一个数比较
		for (int i = 1; i < array.length; i++) {
			temp = array[i];
			for (j = i - 1; j >= 0; j--) {
				if (array[j] > temp) {
					// 将大数往右移
					array[j + 1] = array[j];
				} else {
					break;// 必须跳出，不然j的值变动，就无法确定要插入数字的位置
				}
			}
			// 执行完for循环后j--，此处j+1补上j--减去的1；比较完后，确定要插入数字的位置
			array[j + 1] = temp;
			for (int p = 0; p < array.length; p++) {
				System.out.print(array[p] + " ");
			}
			System.out.println("");
		}
	}
}
结果：

46 58 15 45 90 18 10 62 
15 46 58 45 90 18 10 62 
15 45 46 58 90 18 10 62 
15 45 46 58 90 18 10 62 
15 18 45 46 58 90 10 62 
10 15 18 45 46 58 90 62 
10 15 18 45 46 58 62 90 

【选择排序】

       每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 

选择排序属于不稳定排序。最坏时间复杂性为O(n^2)，空间复杂度为O(1)。。

public class SelectionSort {
	public static void main(String[] args) {
		int[] array = { 46, 58, 15, 45, 90, 18, 10, 62 };
		sort(array);
	}
	public static void sort(int[] array) {
		int k = 0;
		for (int i = 0; i < array.length - 1; i++) {
			k=i;//k指向每次循环的第i位置
			int temp=0;
			for(int j=i+1;j<array.length;j++){
				if(array[j]<array[k]){
					k=j;//每轮循环选出第i个数以后的最小的数的位置
				}
			}
			temp=array[i];
			array[i]=array[k];
			array[k]= temp;
			for (int p = 0; p < array.length; p++) {
				System.out.print(array[p] + " ");
			}	
			System.out.println();
		}
	}
}

结果：
10 58 15 45 90 18 46 62 
10 15 58 45 90 18 46 62 
10 15 18 45 90 58 46 62 
10 15 18 45 90 58 46 62 
10 15 18 45 46 58 90 62 
10 15 18 45 46 58 90 62 

10 15 18 45 46 58 62 90 

【冒泡排序法】

冒泡排序属于稳定排序。最坏时间复杂性为O(n^2)，空间复杂度为O(1)。

public class BubbleSort {
	public static void main(String[] args) {
		int[] array = { 46, 58, 15, 45, 90, 18, 10, 62 };
		bubbleSort(array);
	}
	public static void bubbleSort(int[] array) {
		int temp = 0;
		for (int i = 0; i < array.length - 1; i++) {
			for (int j = array.length - 1; j > i; j--) {
				if (array[j] < array[j - 1]) {
					temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
				}
			}
			for (int p = 0; p < array.length; p++) {
				System.out.print(array[p] + " ");
			}	
			System.out.println();
		}
	}
}

【希尔排序】

希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。直接插入的缺点：加入有一个很小的数据靠在数列的右端位置上，那么要将该数据排序到正确的位置上，所有的中间数据都需要向右移动一位。

希尔排序的优点：通过加大插入排序中元素之间的间隔，并对这些间隔的元素进行插入排序，从而使数据可以大幅度移动。当完成该间隔的排序后，希尔排序会减少数据的间隔再进行排序，依次进行下去。

public class ShellSort {
	public static void main(String[] args) {
		int[] array = { 46, 58, 15, 45, 90, 18, 10, 62 };
		Sort(array);
	}

	static void Sort(int[] array) {
		// 初始化一个间隔
		int h = 1;
		// 计算最大间隔
		while (h < array.length / 3) {
			h = h * 3 + 1;
		}
		while (h > 0) {
			int temp = 0;
			for (int i = h; i < array.length; i++) {
				temp = array[i];
				int j = i;
				while (j > h - 1 && array[j - h] >= temp) {
					array[j] = array[j - h];
					j -= h;
				}
				array[j] = temp;
			}
			// 减小间隔
			h = (h - 1) / 3;
			for (int p = 0; p < array.length; p++) {
				System.out.print(array[p] + " ");
			}
			System.out.println("");
		}
	}
}

结果：

46 18 10 45 90 58 15 62 
10 15 18 45 46 58 62 90 

【堆排序】

堆排序（Heap Sort），是对简单选择排序进行的一种改进，这种改进的效果是非常明显的。简单选择排序的缺点：它在待排序的n个记录中选择一个最小的记录需要比较n-1次。这样的操作并没有把每一趟的比较结果保存下来，在后一趟的比较中，有许多比较在前一趟已经做过了，但由于前一趟排序时未保存这些比较结果，所以后一趟排序时又重复执行了这些比较操作，因而记录的比较次数较多。

堆排序的优点：