排序算法总结

 

是否稳定说明：

选择排序、希尔排序、堆排序，快速排序不是稳定的排序算法，

冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

 

十大排序算法的时间复杂度：

• n: 数据规模
• k: “桶”的个数
• In-place: 占用常数内存，不占用额外内存
• Out-place: 占用额外内存

比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。
在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。
比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。
非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

一、冒泡排序   时间复杂度o(n平方）

基本思想：两两比较相邻记录的关键字，若反序，则交换，直到没有反序的记录为止。

public void bubbleSort3(int[] arr){
	boolean flag=true;
	for (int i = 0; i < arr.length&&flag; i++) {//如果flag为false，则退出判断
		//将flag初始化为false
		flag=false;
		for(int j=arr.length-2;j>=i;j--){
			if(arr[j]>arr[j+1]){
				swap(arr,j,j+1);
				flag=true;
			}
		}
			
	}
		
}
	
private void swap(int[] arr, int i, int j) {
	int t=arr[i];
	arr[i]=arr[j];
	arr[j]=t;	
}

 

二、简单选择排序（时间复杂度，o(n平方））

基本思想：每一趟在n-i+1(i=1,2,...n-1)个记录中选取关键字最小的记录作为有序序列的第i个记录。

即通过n-i次关键字之间的比较，从n-i+1个记录中选择关键字最小的记录比，并和第i个记录交换。

public void selectSort(int[] arr){
	for (int i = 0; i < arr.length; i++) {    //第i次遍历之后可以找到第i小的值
		int min=i;//定义最小值的下标
		for (int j = i+1; j < arr.length; j++) {
			if(arr[j]<arr[min]){
				min=j;//经过依次和后面的元素比较后，找到了真正的最小值的下标
			}
			
		}
		if(i!=min){
			//从后面的元素中找到了最小值
			swap(arr,i,min);
		}
		
	}
}
private void swap(int[] arr, int i, int j) {
	int t=arr[i];
	arr[i]=arr[j];
	arr[j]=t;	
}

 

三、直接插入排序（时间复杂度 o(n平方））

将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表。

直接插入排序：将一个数插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表
空间复杂度：需要一个额外的空间，时间复杂度：o(n平方)*/
public void InsertSort(int[] arr){
	int[] temp=new int[1];
	for (int i = 1; i < arr.length; i++) {
		if(arr[i]<arr[i-1]){
			temp[0]=arr[i];
			int j;
			for(j=i-1;j>=0&&arr[j]>temp[0];--j){
				arr[j+1]=arr[j];//记录右移	
			}
			//在执行完上面的操作后，j进行过一次自减，所以要回到j的位置，就要将temp赋值给j+1
			arr[j+1]=temp[0];
		}
		
	}
	
}

四、希尔排序（时间复杂度 o(n的3/2次方）    不稳定  ）

希尔排序是对直接插入排序的一种改进，采取跳跃分割的策略：将相距某个“增量”的记录组合成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果基本有序而不是局部有序。

增量序列的最后一个值必须等于1才行。因为记录是跳跃式移动，所以希尔排序并不是一种稳定的排序算法。

public void ShellSort(int[] arr){
	int i,j;
	int[] temp=new int[1];
	int increment=arr.length;
	do{
		increment=increment/3+1;//增量序列
		for (i =increment; i< arr.length; i++) {
			if(arr[i]<arr[i-increment]){
				//将arr[i]插入有序增量子表
				temp[0]=arr[i];//将arr[i]的值暂存于临时空间中
				for(j=i-increment;j>=0&&temp[0]<arr[j];j-=increment){
					arr[j+increment]=arr[j];/*记录后移，查找插入位置*/
				}
				arr[j+increment]=temp[0];
				
				
			}
		}
		
	}while(increment>1);//在增量大于1之前一直进行跳跃的增量排序
}

 

五、堆排序  时间复杂度：o(nlogn)   不稳定

对简单选择排序的一种改进。
堆：完全二叉树，

大顶堆中，每个结点的值都大于或等于其左右孩子结点的值；
小顶堆中，每个结点的值都小于或等于其左右结点的值。
方法中：第一个for循环要完成的是将待排序的序列构建成一个大顶堆。
第二个循环要完成的是逐步将每个最大值的根节点和末尾元素交换，并且再调整其为大顶堆。
 

小顶堆的构造和大顶堆一样，只不过改一下符号

堆排序图解：

https://blog.csdn.net/Peter_Changyb/article/details/82557862

public void HeapSort(int[] arr){
	int i;
	/*将当前数组中的元素构造成一个大顶堆
	 * 从arr.length/2开始是因为这个节点到根节点变化的时候，所有的结点都是有叶子结点的*/
	for (i =arr.length/2-1; i>=0; i--) {
		HeapAdjust(arr,i,arr.length-1);
	}
	for (i =arr.length-1; i>0; i--) {
		swap(arr,0,i);//将堆顶记录和当前未经排序的子序列的最后一个记录交换。  交换一次可获得整个序列的最大值，再次调整再交换，获得次大值……
		HeapAdjust(arr, 0, i-1);//将arr[0~i-1]重新调整为大顶堆
	}
	
}

private void swap(int[] arr, int i, int j) {
	int t=arr[i];
	arr[i]=arr[j];
	arr[j]=t;	
}

private void HeapAdjust(int[] arr, int i, int high) {
	int temp,j;
	temp=arr[i];
	for (j =2*i+1;j<=high; j=j*2+1) {//沿关键字较大的孩子节点向下筛选（将父节点依次和孩子节点，孩子节点的孩子节点比较）
		if(j<high&&arr[j]<arr[j+1]){//j<high说明j不是最后一个节点
			++j;   //j为关键字中较大记录的下标
		}
		if(temp>=arr[j]){
			break;
		}
		arr[i]=arr[j];
		i=j;	
	}
	arr[i]=temp;
}

 

六、归并排序   时间复杂度o(nlogn)

归并：将2个或2个以上的有序表组合成一个新的有序表。

归并排序就是利用归并的思想，原理是：假设初始序列含有n条记录，可以看成是n个有序的子序列，，每个子序列的长度为1，然后两两归并，得到n/2个长度为2，或含1的子序列，再进行两两归并，如此重复，直到得到一个长度为n的有序序列为止，这种排序方法叫做2路归并排序。

实现：

import java.util.Arrays;
public class MergeSortDemo2 {
    // 归并排序
    private void mergeSort(int[] numbers, int start, int end) {
        if (start >= end) {
            return;
        }
        int mid = (end + start) / 2;
        mergeSort(numbers, start, mid);
        mergeSort(numbers, mid + 1, end);
        merge(numbers, start, mid, end);
    }

    private void merge(int[] numbers, int start, int mid, int end) {
        int[] tmp = new int[end - start + 1];
        int left = start,right=mid+1;
        int k = 0;
        while (left <= mid && right <= end) {
            if (numbers[left] <= numbers[right]) {
                tmp[k++] = numbers[left++];
            }else{
                tmp[k++] = numbers[right++];
            }
        }
       
        while (left <= mid) {
            tmp[k++] = numbers[left++];
        }            
        while (right <= end) {
            tmp[k++] = numbers[right++];
        }
        
        System.arraycopy(tmp, 0, numbers, start, end-start+1);
    }
    public static void main(String[] args) {
        MergeSortDemo2 mg2 = new MergeSortDemo2();
        int[] array = {1, 4, 10, 101, 2, 5, 9};
        mg2.mergeSort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));
    }
}

 

以下是归并排序递归实现的代码：

import java.util.Arrays;
public class MergeSortDemo {
	public void MergeSort(int[] arr){
		Msort(arr,arr,0,arr.length-1);
	}
	private void Msort(int[] arr, int[] ret, int start, int end) {
		int[] temp=new int[arr.length];
		if(start==end){
			ret[start]=arr[start];
		}
		else{
			int mid=(start+end)/2;//将arr数组分为arr[start-mid],arr[mid+1,end]
			Msort(arr,temp,start,mid);//递归将arr[start,mid]归并排为有序的temp[start,mid]
			Msort(arr,temp,mid+1,end);//递归将arr[mid+1,end]归并排为有序的temp[mid+1,end]
			Merge(temp,ret,start,mid,end);//将temp[s,m],temp[m+1,t]归并到ret[s,t]
		}
	}
	//将有序的temp[i,m]和temp[m+1,n]归并为有序的ret[i,n]
	private void Merge(int[] temp, int[] ret, int i, int m, int n) {
		int j,k;
		//将SR中的记录从小到大归并入TR
		for (j=m+1,k=i;i<=m&&j<=n;k++) {
			if(temp[i]<temp[j]){
				ret[k]=temp[i++];
			}else{
				ret[k]=temp[j++];
			}
		}
		//循环结束
		//如果前半截数组更长，则将剩余的部分直接粘到TR后
		while(i<=m){
			ret[k++]=temp[i++];
		}
		while(j<=n){
			ret[k++]=temp[j++];
		}
		
	}
	public static void main(String[] args) {
		MergeSortDemo msd=new MergeSortDemo();
//		int[] arr={1,2,3,4,5,6,7,0};
		int[] arr={9,2,1,3,7,6,5,0};
		msd.MergeSort(arr);
		System.out.println(Arrays.toString(arr));
		
	}

}

 归并排序的非递归实现方法：

非递归的迭代做法直截了当，从最小的序列开始归并直至完成，不需要像归并的递归算法一样，需要先拆分递归，再归并退出递归。避免了递归时深度为log2N的栈空间，空间只是用到申请归并临时用的temp数组，因此空间复杂度为o(n),且避免递归也在时间性能上有一定的提升。

/*************************归并排序非递归方法实现*************************************************/
public void MergeSort3(int[] arr){
	int k=1;
	int len=arr.length;
	while(k<len){
		MergePass(arr,k,len);
		k*=2;
	}
	
}
//将数组中相邻的有k个元素的子序列进行归并
private void MergePass(int[] arr, int k, int n) {
	/**
	 * arr:待排序的数组
	 * k:子序列的长度
	 * n:arr数组的长度
	 */
	int i=0;
	//从前往后将2个长度为k的子序列合并为1个
	while(i<n-2*k+1){
		Merge3(arr,i,i+k-1,i+2*k-1);
		i=i+2*k;
	}
	//如果有落单的
	if(i<n-k){
		Merge3(arr,i,i+k-1,n-1);
	}
	
	
}
private void Merge3(int[] arr, int low, int mid, int high) {
	/**
	 * arr:待排序的数组
	 * low:起始位置
	 * mid:中间位置
	 * high:数组的末尾
	 */
	int[] temp=new int[high-low+1];
	int index1=low,index2=mid+1,index=0;
	while(index1<=mid&&index2<=high){
		if(arr[index1]>arr[index2]){
			temp[index++]=arr[index2++];
		}else{
			temp[index++]=arr[index1++];
		}
	}
	while(index1<=mid){
		temp[index++]=arr[index1++];
	}
	while(index2<=high){
		temp[index++]=arr[index2++];
	}
	for (int k = 0; k < temp.length; k++) {
		arr[low+k]=temp[k];
		
	}
	
}

七、快速排序  时间复杂度o（nlogn）  不稳定

希尔排序是直接插入排序的升级，它们同属于插入排序类；

堆排序属于简单选择排序的升级，它们同属于选择排序类；

而快速排序是冒泡排序的升级，它们同属于交换排序类；

快速排序的基本思想：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

public class QuickSortDemo {
	public void quickSort(int[] arr){
		qSort(arr,0,arr.length-1);
	}
	//对arr[low-high]做快速排序
	private void qSort(int[] arr, int low, int high) {
		int pivot;
		if(low<high){
			pivot=partition(arr,low,high);//将arr一分为二，算出枢轴值pivot
			qSort(arr, low, pivot-1);//对左半边进行递归排序
			qSort(arr,pivot+1,high);//对右半边进行递归排序
		}	
	}
	/*
	 * partition函数要做的是优先选取一个关键字，然后想尽办法将它放到一个位置，
	 * 使得它的左边的值都比它小，右边的值都比它大，这个值叫枢轴（pivot）*/
	private int partition(int[] arr, int low, int high) {
		int pivotKey;
		pivotKey=arr[low];//用第一个元素做枢轴记录
		while(low<high){
			while(low<high&&arr[high]>=pivotKey){
				high--;
			}
			//高位遇到比pivotkey小的值
			arr[low]=arr[high];
			while(low<high&&arr[low]<=pivotKey){
				low++;
			}
			//高位遇到比pivotkey大的值
			arr[high]=arr[low];
		}
		arr[low]=pivotKey;
		return low;
	}
	public static void main(String[] args) {
		QuickSortDemo qsd=new QuickSortDemo();
		int[] arr={50,10,90,30,70,40,80,60,20};
		qsd.quickSort(arr);
		System.out.println(Arrays.toString(arr));
	}
}

 

 

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。
在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。
比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。
非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

 

八、计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

计数排序的基本思想：

• 找出待排序的数组中最大和最小的元素；
• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

下面根据一个示例来讲解，比如现在有个待排序的整数序列A={-1, 2, 0, 4, 3, 6, 5, 8, -2, 1, 3, 0, 3,6, 5, 2}。首先我们花O(n)的时间扫描一下整个序列，可以得到max=8，min=-2。然后我们建立一个新的数组C，长度为(max-min+1)=11。

数组C如下所示：

                                            
    数组index为0的元素记录的值是-2出现的次数，依次index为1的元素记录的是-1出现的次数。

    此时我们再扫描一下数组A，比如对于-1，我们的操作是：-1-min=-1-(-2)=1;C[1]++。对于2，我们的操作是：2-(-2)=4;C[4]++。这样我们又花了O(n)的时间。操作结果是：

                                             

    最后我们便可以输出目标整数序列了，具体的逻辑是遍历数组C，比如C[0]=1，则输出一次min+index即(-2+0)=-2；C[1]=1，则输出一次-1；C[2]=2，则输出两次0，以此类推。目标序列为：

-2, -1, 0, 0, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 6, 8

       分析可得，我们扫描了两次数组A，一次数组C，所以计数排序的时间复杂度为2(n)+n+k（扫描数组C的时间复杂度是n+k）。空间复杂度是：n+k（n是数组A的空间，最后输出目标整数序列时可以直接存储在A中；k是数组C的空间）。故其空间复杂度和时间复杂度均为O(n+k)。

实现：

 private int[] countSort(int[] array){
        if(array.length==0) return array;
        int bias,min=array[0],max=array[0];
        //统计数组元素的最大值和最小值
        for (int i = 1; i <array.length ; i++) {
           max=Math.max(max,array[i]);
           min=Math.min(min,array[i]);
        }
        //最小值和0的偏差
        int[] bucket=new int[max-min+1];
        //统计数组中每个元素出现的次数，相当于一个哈希表
        for (int i = 0; i <array.length ; i++) {
            int mapPos=array[i]-min;
            bucket[mapPos]++;
        }
        int k = 0;
        //按bucket统计的个数逐个输出元素
        for (int i = 0; i <bucket.length ; i++) {
            while(bucket[i]-->0){
                array[k++]=i+min;
            }
            
        }
        return array;
    }

 

九、桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序。

适用于最大最小值相差较大的数据情况，比如[9012,19702,39867,68957,83556,102456]。
但桶排序要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中。比如[104,150,123,132,20000], 这种数据会导致前4个数都集中到同一个桶中。导致桶排序失效。

思路：

把数组 arr 划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并。

1.找出待排序数组中的最大值max、最小值min
2.我们使用 动态数组ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(max-min)/arr.length+1
3.遍历数组 arr，计算每个元素 arr[i] 放的桶
4.每个桶各自排序
5.遍历桶数组，把排序好的元素放进输出数组
计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。

                                                         

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。 

最佳情况：T(n) = O(n+k)   最差情况：T(n) = O(n+k)   平均情况：T(n) = O(n2)　　

实现：

  private int[] countSort(int[] array){
        if(array.length==0) return array;
        int bias,min=array[0],max=array[0];
        //统计数组元素的最大值和最小值
        for (int i = 1; i <array.length ; i++) {
           max=Math.max(max,array[i]);
           min=Math.min(min,array[i]);
        }
        //最小值和0的偏差
        int[] bucket=new int[max-min+1];
        //统计数组中每个元素出现的次数，相当于一个哈希表
        for (int i = 0; i <array.length ; i++) {
            int mapPos=array[i]-min;
            bucket[mapPos]++;
        }
        int k = 0;
        //按bucket统计的个数逐个输出元素
        for (int i = 0; i <bucket.length ; i++) {
            while(bucket[i]-->0){
                array[k++]=i+min;
            }
        }
        return array;
    }

 

十、基数排序

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

基本思想：

1、根据待排序整数序列的进制d（十进制为10，十六进制为16...）设置d个桶，编号分别为0，1，...，d-1；
2、各个记录按照其关键字最低位的值的大小放入到相应的桶中；
3、按照桶编号从小到大的顺序收集各个桶中的数据，对于同一桶中的数据按照先后次序收集，先进桶先收集；
4、按照关键字的次低位，重复上述步骤...（没有高位的数据则高位补0 ）按增量序列个数k，对序列进行k 趟排序； 
3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
 

参考文献：

《大话数据结构》

https://www.cnblogs.com/mmzs/p/8653018.html

https://blog.csdn.net/liyuming0000/article/details/46913357