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

System.out.print(array[i]);

}

}

/*

* 1.冒泡法排序：那么就依次相邻两个数比较大小，然后把大（小）的数放在后面，依次类推。冒泡排序时间复杂度O(n2)

*/

public static int[] bubbleSort(int[] array){

int temp=0;

for(int i=0;i

for(int j=0;j

if(array[i]

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

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

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

temp = array[j];

for(k=j-i;(k>=0)&&array[k]>temp;k-=i)

{

array[k+i] = array[k];