常用的排序算法——基本思想，稳定性，时间复杂度

最新推荐文章于 2022-05-08 23:44:46 发布

雪人奥特曼Q

最新推荐文章于 2022-05-08 23:44:46 发布

阅读量378

点赞数

分类专栏：算法文章标签：排序算法算法 java

本文链接：https://blog.csdn.net/u013025748/article/details/106753249

版权

算法专栏收录该内容

13 篇文章 1 订阅

订阅专栏

排序算法的稳定性：

稳定性指的是在排序之前元素A和元素B的相对顺序，在排序后是否改变其相对位置，不改变则称之为稳定排序。

排序算法稳定性的意义：当需要对一个对象的多个属性进行排序的时候，算法的稳定性就很重要了。比如：我想在有一个商品，需要根据商品的单价，销售量来进行排序。那么当我已经对单价从高到低进行排序后，进而对单价进行排序。排序算法的稳定性可以实现，我相同销量的产品保持着单价又高到低的顺序。

一、冒泡排序

基本思想：比较相邻的连个数，如果前面的比后面的大，就交换两数的位置，如果两个元素相等是不交换位置的。一共需要遍历n-1次。

稳定性：稳定

时间复杂度：O(n2)

public class demo_sort {
    public static void main(String[] args) {
        //冒泡排序算法
        int[] numbers=new int[]{1,5,8,2,3,9,4};
        int i,j;
        for(i=0;i<numbers.length-1;i++)
        {
            for(j=0;j<numbers.length-1-i;j++)
            {
                if(numbers[j]>numbers[j+1])
                {
                    int temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(i=0;i<numbers.length;i++)
            System.out.print(numbers[i]+" ");
    }
}

二、选择排序

基本思想：遍历一趟数据，选出最小的数字放在第一位，然后遍历剩余数字再选择出最小的放在第二位……直至剩余非有序元素个数为零。

稳定性：不稳定。例如 5，8，5，9，2数列，第一次选取最小值后，就将2和第一个5交换位置，将最小值放在第一位，这样第一个5和第二个5的相对位置就改变了。

时间复杂度：O(n2)

选择排序的元素交换次数比冒泡排序少的多，有因为数据交换占用的CPU时间比数据比较所占用的CPU时间多，因而选择排序的效率高于冒泡排序。
//选择排序：每次从待排序的元素中选出最小值  
    public static void selectionSort(int[] a){
        int N = a.length;

        for(int i = 0; i < N - 1; i++){
            int min = i;
            for(int j = i + 1; j < N; j++){
                //将a[i]和a[i+1...N-1]中的最小元素交换
                if(a[j] < a[min]){//升序排列
                    min = j;
                }
            }
            if(min != i){
                int temp = a[i];
                a[i] = a[min];
                a[min] = temp;
            }
        }
    }

三、插入排序

基本思想：将待排序数列分为有序区和无序区，最初无序区只有一个元素，在无序区选择一个元素和插入它在有序区正确的位置。

稳定性：稳定排序

时间复杂度：O(n2)

插入排序适用于数列较小的情况。
public void insertSort() {
	int i,j,temp;
	for(i=1;i<array.length;i++) {
		temp=array[i];
		for(j=i-1;j>=0;j--) {
			if(temp>array[j]) {
				break;
			}else {
				array[j+1]=array[j];
			}
		}
		array[j+1]=temp;
	}
	System.out.println(Arrays.toString(array));
}

四、快速排序

基本思想：选取一个基准元素（通常是第一个），然后通过比较，将小于基准的元素放在它的左边，将大于基准的元素放在它的右边，然后对其左边和右边的子数列递归执行快速排序。

基本步骤：基于数列 23，46，0，8，11，18 进行快速排序

首先选取第一个元素
并且分别指向数列的第二个 array[low] 和最后一个元素 array[high]；
先比较 array[high] 是否比基准元素大
如果大于基准元素则 high-- ，继续比较 array[high] 是否比基准元素大；
如果小于基准元素，则将 array[high] 和基准元素进行交换；
进行了与基准元素的交换后，开始比较 array[low] 是否比基准元素小；
如果小于基准元素则 low++，继续比较 array[low]是否比基准元素小；
如果大于基准元素则将 array[low] 和基准元素的位置进行交换；
进行了与基准元素的交换后，开始比较 array[high] 是否比基准元素大；
循环 3,4,5步骤，直至 low == high
对小于基准的左部分，大于基准的右部分进行 递归快速排序。

稳定性：不稳定

时间复杂度：O(nlogn)