Java常见4种排序

排序

看到数据排序这节所以把排序的常见方法都整理下。

（一）冒泡排序：从最左边开始对两个数进行比较，如果第ｉ个数大于第ｉ＋１个数，两个数就交换，不断重复。

最好时间复杂度O(n)

最坏时间复杂度O(n²)

平均时间复杂度O(n²)

public class ArrayDemo06{

public static void main (String [] args){

int score[]={67,89,87,69,90,100,75,90};

for(int i =1;i<score.length;i++){

for(int j=0;j<score.length;j++){

if(score[i]<score[j]){

int temp=score[i];

score[i]=score[j];

score[j]=temp;

}

}

}

for(int i =0;i<score.length;i++){

System.out.println(score[i]+"\t");

}

}

}

（二）快速排序:（招银在线笔试考到）

最好时间复杂度O(nlogn)

最糟糕时复杂度为O(n^2)

平均时间复杂度为O(nlogn)

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为 止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

public void sort(int arr[],int low,int high){

int L=low;

int H=high;

int povit=arr[low];

while(L<H){

while(L<H&&arr[H]>=povit){

H--;

}

if(L<H){

int temp=arr[H];

arr[H]=arr[L];

arr[L]=temp;

L++;

}

while(L<H&&arr[L]<=povit){

L++;

}

if(L<H){

int temp=arr[H];

arr[H]=arr[L];

arr[L]=temp;

H--;

}

}

if(L>low)sort(arr,low,L-1);//对低字段表进行递归排序

if(H<high)sort(arr,L+1,high);//对高字段表进行递归排序

}

（三）归并排序：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

最坏、最佳、平均情况下时间复杂度均为o(nlogn).从合并过程中可以看出合并排序稳定。

算法：

/**

* 归并排序

* 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列

* 时间复杂度为O(nlogn)

* 稳定排序方式

* @param nums 待排序数组

* @return 输出有序数组

*/

public static int[] sort(int[] nums, int low, int high) {

int mid = (low + high) / 2;

if (low < high) {

// 左边

sort(nums, low, mid);

// 右边

sort(nums, mid + 1, high);

// 左右归并

merge(nums, low, mid, high);

}

return nums;

}

/**

* 将数组中low到high位置的数进行排序

* @param nums 待排序数组

* @param low 待排的开始位置

* @param mid 待排中间位置

* @param high 待排结束位置

*/

public static void merge(int[] nums, int low, int mid, int high) {

int[] temp = new int[high - low + 1];

int i = low;// 左指针

int j = mid + 1;// 右指针

int k = 0;

// 把较小的数先移到新数组中

while (i <= mid && j <= high) {

if (nums[i] < nums[j]) {

temp[k++] = nums[i++];

} else {

temp[k++] = nums[j++];

}

}

// 把左边剩余的数移入数组

while (i <= mid) {

temp[k++] = nums[i++];

}

// 把右边边剩余的数移入数组

while (j <= high) {

temp[k++] = nums[j++];

}

// 把新数组中的数覆盖nums数组

for (int k2 = 0; k2 < temp.length; k2++) {

nums[k2 + low] = temp[k2];

}

}

例：

如　设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8，1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

总的比较次数为：3+4+4=11,；

逆序数为14；

（四）堆排序：初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个 堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对 它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

平均时间复杂度O(N*logN)

public class HeapSort {

public static void main(String[] args) {

int[] a={49,38,65,97,76,13,27,49,78,34,12,64};

int arrayLength=a.length;

//循环建堆

for(int i=0;i<arrayLength-1;i++){

//建堆

buildMaxHeap(a,arrayLength-1-i);

//交换堆顶和最后一个元素

swap(a,0,arrayLength-1-i);

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

}

}

//对data数组从0到lastIndex建大顶堆

public static void buildMaxHeap(int[] data, int lastIndex){

//从lastIndex处节点（最后一个节点）的父节点开始

for(int i=(lastIndex-1)/2;i>=0;i--){

//k保存正在判断的节点

int k=i;

//如果当前k节点的子节点存在

while(k*2+1<=lastIndex){

//k节点的左子节点的索引

int biggerIndex=2*k+1;

//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在

if(biggerIndex<lastIndex){

//若果右子节点的值较大

if(data[biggerIndex]<data[biggerIndex+1]){

//biggerIndex总是记录较大子节点的索引

biggerIndex++;

}

}

//如果k节点的值小于其较大的子节点的值

if(data[k]<data[biggerIndex]){

//交换他们

swap(data,k,biggerIndex);

//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值

k=biggerIndex;

}else{

break;

}

}

}

}

//交换

private static void swap(int[] data, int i, int j) {

int tmp=data[i];

data[i]=data[j];

data[j]=tmp;

}

}

最后找到一个常用排序算法的时间复杂度和空间复杂度表格。