java的七种经典排序

此文中的七种排序算法为个人总结，程序均在eclipse中验证成功，可供参考package sort;/** 各种排序方法总结*/public class Sort {public static void main(String[] args) {int[] array={4,9,6,7,2,3,1,5,8,0};Sort.heapSort(array);for(int i=0;i<array.length;i++){System.out.print(array[i]);}}/** 1.冒泡法排序：那么就依次相邻两个数比较大小，然后把大（小）的数放在后面，依次类推。

冒泡排序时间复杂度O(n2)*/public static int[] bubbleSort(int[] array){int temp=0;for(int i=0;i<array.length;i++){for(int j=0;j<array.length-1;j++){if(array[i]<array[j]){temp=array[i];array[i]=array[j];array[j]=temp;}}}return array;}/** 2.直接选择法排序：从当前数中选出一个最大或者最小的值排在最前面，* 然后从剩下的数中选出剩下数的最值排在已经排序的数的后面，算法时间复杂度O(n2) */public static int[] selectSort(int[] array) {for (int i = 0; i < array.length; i++) {int index = 0;for (int j = 0; j < array.length - i; j++) {if (array[j] > array[index]) {index = j;}}int temp = array[array.length - i - 1];array[array.length - i - 1] = array[index];array[index] = temp;}return array;}public static int[] selectSort1(int[] array) {for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i + 1; j < array.length; j++) {if (array[minIndex] > array[j]) {minIndex = j;}}int temp = array[i];array[i] = array[minIndex];array[minIndex] = temp;}return array;}/** 3.反转排序:反转数组*/public static int[] reverseSort(int[] array){int temp = 0;for(int i=0;i<array.length/2;i++){temp=array[i];array[i]=array[array.length-i-1];array[array.length-i-1]=temp;}return array;}/** 4.插入排序：依次遍历数组，假设前面已经有一部分排过序的，* 当前待排数字跟前面的数字依次比较大小，将其插在对应顺序位置，算法时间复杂度O(n2)*/public static int[] insertSort(int[] array){int temp;for(int i=1;i<array.length;i++){temp=array[i];int j=i;while(--j>=0&&array[j]>temp){array[j+1]=array[j];}array[j+1]=temp;}return array;}/** 5.希尔排序：希尔排序是对插入排序的改进，可以把当前数据分组，每个分组都有一定间隔* 它们两两比较大小。

然后再减小间隔范围，或者说增多分组个数，算法时间复杂度O(n2) */public static int[] shellSort(int[] array){for(int i=array.length/2;i>0;i/=2){int temp;int k;for(int j=i;j<array.length;j++){temp = array[j];for(k=j-i;(k>=0)&&array[k]>temp;k-=i){array[k+i] = array[k];}array[k+i] = temp;}}return array;}/** 6.快速排序:分治的思想，在数组中设置一个游标，从数组的两端来遍历数组，* 将元素和游标相比，意图达到两组数据一边游标小，一边比游标大。

那么此时的游标就处于两组数组的中间。

* 然后依次对前后两组数据排序，此时当然可以利用递归了。

时间平均复杂度是O(n*logn)， * 排序算法貌似是公认最实用最好的排序算法，在大多数情况下都能解决问题，提高效率， * 当然也有糟糕的时候，此时的算法时间复杂度达到O(n2)。

*///以最左边的元素为游标public static int[] quickSort1(int[] array,int left,int right){int i,j,middle,temp;middle = array[left];i = left + 1;j = right - 1;do{while( i<right && array[i]<middle){i++;}while( j>left && array[j]>middle){j--;}if(i >= j){break;}temp = array[i];array[i] = array[j];array[j] = temp;i++;j--;}while(i<=j);array[left] = array[j];array[j] = middle;if(left<j-1){quickSort1(array,left,j);}if(right>j+1){quickSort1(array,j+1,right);}return array;}//以中间元素为游标public static int[] quickSort2(int[] array, int left, int right) { int i, j, middle, temp;i = left;j = right - 1;middle = array[(i + j) / 2];do {while (i < right && array[i] < middle){i++;}while (j > left && array[j] > middle){j--;}if (i >= j){break;}temp = array[i];array[i] = array[j];array[j] = temp;i++;j--;} while (i < j);if (left < i - 1){quickSort2(array, left, i);}if (right > i + 2){quickSort2(array, i, right);}return array;}/** 7.堆排序：堆其实就一个二叉树，其中要满足父节点大于或者小于子节点。

* 把数组中元素按照堆来遍历，修正堆后，那么最大或者最小的元素就在根节点上了。

* 我们把根节点移除，按照相同的方法再次得到最值，依次类推，直到剩下一个元素位置。

* 算法时间复杂度是O(n*logn)。

*/public static int[] heapSort(int[] array) {int j, temp;for (int i = array.length; i > 0; i--) {j = i / 2 - 1;HeapAdjust(array, j, i);temp = array[0];array[0] = array[i-1];array[i-1] = temp;}return array;}public static void HeapAdjust(int array[], int i, int nLength) { int nchild;int ntemp;while (i >= 0) {nchild = 2 * i + 1;ntemp = array[i];if (array[nchild] < ntemp) {ntemp = array[nchild];array[nchild] = array[i];array[i] = ntemp;}if (nchild < nLength - 1) {nchild++;if (array[nchild] < ntemp) {ntemp = array[nchild];array[nchild] = array[i];array[i] = ntemp;}}i--;}}}。