java十大排序法_Java 十大排序算法

目录：

1、冒泡排序(Bubble Sort)

2、选择排序(Selection Sort)

3、插入排序(Insertion Sort)

4、希尔排序(Shell Sort)

5、归并排序(Merge Sort)

6、快速排序(Quick Sort)

7、堆排序(Heap Sort)

8、计数排序(Counting Sort)

9、桶排序(Bucket Sort)

10、基数排序(Radix Sort)

1、冒泡排序(Bubble Sort)

1、基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。

2、算法描述：

比较相邻的元素。如果第一个比第二个大，就交换它们两个；

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

针对所有的元素重复以上的步骤，除了最后一个；

重复步骤1~3，直到排序完成。

3、实现列子：

public static void main(String[] args) {

int [] array={1,20,11,90,50,2000,39};

int steam;

boolean flase;

for(int i=0;i

flase=false;

for (int j=array.length-1; j>i; j--) {

if(array[j]

steam=array[j];

array[j]=array[j-1];

array[j-1]=steam;

flase=true;

}

}

if(!flase) break;

}

System.out.println(Arrays.toString(array));

}

2、选择排序(Selection Sort)

1、动态图

2、

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；

第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

n-1趟结束，数组有序化了。

3、实现列子：

public static void main(String[] args) {

int[] array = { 11, 1, 22, 33, 55, 44, 3 };

for (int i = 0; i < array.length; i++) { //加入获取的第一个数字就是最小的开始与第二个数字进行比较

int min = i;

for (int j = i + 1; j < array.length; j++) {//从第二个数字开始往后循环比较

if (array[j] < array[min]) {

min = j;

}

}

SelectionSort.swap(array, i,min);

}

System.out.println(Arrays.toString(array));

}

private static void swap(int[] arr, int i, int j) {//比较值根据下表去相互替换

int temp = arr[i];//这是需要变更的下标值

arr[i] = arr[j];

arr[j] = temp;

}

3、插入排序(Insertion Sort)

1、动态图：

2、算法思想：

在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

3：列子：

Integer[] number = NumberUtil.getNumber(100000,1,100000);

long start=System.currentTimeMillis();

for (int i = 0; i < number.length - 1; i++) {

int current = number[i + 1];

int preIndex = i;

while (preIndex >= 0 && current < number[preIndex]) {

number[preIndex + 1] = number[preIndex];

preIndex--;

}

number[preIndex + 1] = current;

}

long end=System.currentTimeMillis();

System.out.println("用时："+(end-start));

System.out.println(Arrays.toString(number));

4工具方法：

public static Integer[] getNumber(int n,int startNum,int endNum){

Integer [] val=new Integer[n];

for(int i=0;i

val[i]=new Integer((int)(Math.random()*(endNum-startNum))+startNum);

}

return val;

}

4、希尔排序(Shell Sort)

1、动态图

2、算法思想：

希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2)的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。

3、实现列子：

public static void main(String[] args) {

int[] array = { 11, 1, 22, 33, 55, 44, 3 };

int arr1=array.length;

int index1,index2=arr1/2;

while (index2>0) {

for (int i = index2; i < arr1; i++) {

index1=array[i];

int preIndex =i-index2;

while (preIndex>=0&&array[preIndex]>index1) {

array[preIndex + index2] = array[preIndex];

preIndex -= index2;

}

array[preIndex + index2] = index1;

}

index2 /= 2;

}

System.out.println(Arrays.toString(array));

}

5、归并排序(Merge Sort)

1、动态图：

2、基本思想：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

把长度为n的输入序列分成两个长度为n/2的子序列；

对这两个子序列分别采用归并排序；

将两个排序好的子序列合并成一个最终的排序序列

3、实现列子：

Arrays.copyOfRange(array, 0, mid);

第一个参数表示源数组

第二个参数表示开始位置(取得到)

第三个参数表示结束位置(取不到)

public static void main(String[] args) {

int[] array = { 11, 1, 22, 33, 55, 44, 3 };

int[] sort2 = sort(array);

System.out.println(Arrays.toString(sort2));

}

private static int[] sort(int [] array) {

// TODO Auto-generated method stub

if(array.length<2){

return array;

}

int mid = array.length / 2;

int[] left = Arrays.copyOfRange(array, 0, mid);

int[] right = Arrays.copyOfRange(array, mid, array.length);

return merge(sort(left), sort(right));

}

public static int[] merge(int[] left, int[] right) {

int[] result = new int[left.length + right.length];

for (int index = 0, i = 0, j = 0; index < result.length; index++) {

if (i >= left.length)

result[index] = right[j++];

else if (j >= right.length)

result[index] = left[i++];

else if (left[i] > right[j])

result[index] = right[j++];

else

result[index] = left[i++];

}

return result;

}