七大排序算法

排序的概念

所谓排序,就是使一串数据,按照某种比较规则,递增或递减地排列的操作。

稳定性:假定在待排序的数据中,存在多个相同数据,若经过排序,这些数据的相对次序保持不变,则称这种排序算法是稳定的;否则称为不稳定的。

  • 一个本身就不稳定的排序,是不可能变成一个稳定的排序的
  • 但是一个本身就稳定的排序,是可以实现为不稳定的排序的

在这里插入图片描述

内部排序:数据元素全部放在内存中的排序。
外部排序:数据元素太多不能同时放在内存中,外存中的数据读入内存→在内存中排序→数据写入外存。

常见的排序算法

在这里插入图片描述

插入排序

直接插入排序的基本思想是:把数据逐个插入到一个已经有序的序列中,直到所有的记录插入完得到一个新的有序序列 。

在这里插入图片描述

    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= 0 ; j--) {
                //加不加等号能决定这个排序的稳定性,也就是array[j] >= tmp是不稳定的
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

直接插入排序的特性总结:

  1. 数据越趋于有序,直接插入排序算法的时间效率越高
  2. 时间复杂度:
    • 最好情况:数据有序的情况下:O(N)
    • 最坏情况:数据逆序的情况下:O( N 2 N^2 N2)
  3. 空间复杂度:O(1)
  4. 稳定性:稳定

希尔排序( 缩小增量排序 )

希尔排序的基本思想是:先选定一个整数gap,把待排序的元素分成gap组,所有距离为gap的元素分在同一组,并对每一组的元素进行插入排序。然后,取新的gap,重复上述分组和排序的工作。当gap ==1时,所有元素排好序。

  • 跳跃式分组尽可能把大的元素放到后边,小的元素放到前边
  • 除了gap == 1以外的排序都是预排序,每次预排序后都接近有序,最后gap == 1的时候,整体插入排序效率就高了
    在这里插入图片描述
    时间复杂度我们暂时就按照O( N 1.25 N^{1.25} N1.25)到O(1.6 N 1.25 N^{1.25} N1.25)来算。

以gap = gap/2为例

在这里插入图片描述

public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            gap = gap / 2;
            shell(array,gap);
        }
    }

    private static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0 ; j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

希尔排序的特性总结:

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序,目的是让数据更接近于有序。当gap == 1时,数据已经接近有序了,这样插入排序效率会高,可以达到优化的效果。
  3. 希尔排序的时间复杂度不好计算,因为gap的取值方法很多
  4. 稳定性:不稳定

选择排序

每一次从待排序的数据中选出最小(或最大)的一个元素,存放在相应位置,直到全部数据排完 。

在这里插入图片描述

 public static void selectSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            int minIndex = i;
            for (int j = i+1; j < array.length; j++) {
                if(array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            swap(array,i,minIndex);
        }
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }

还有一种:

    public static void selectSort2(int[] array) {
        int left = 0;
        int right = array.length-1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            for (int i = left+1; i <= right ; i++) {
                if(array[i] < array[minIndex]) {
                    minIndex = i;
                }
                if(array[i] > array[maxIndex]) {
                    maxIndex = i;
                }
            }
            swap(array,minIndex,left);
            //第一次交换 最大值可能是left,然后被换到了minIndex的位置
            if(maxIndex == left) {
                maxIndex = minIndex;
            }
            swap(array,maxIndex,right);
            left++;
            right--;
        }
    }
	private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }

【直接选择排序的特性总结】

  1. 直接选择排序效率不是很好。实际中很少使用
  2. 时间复杂度:O( N 2 N^2 N2)
  3. 空间复杂度:O(1)
  4. 稳定性:不稳定

堆排序

堆排序即利用堆的思想来进行排序,总共分为两个步骤:

  1. 建堆
    升序:建大堆
    降序:建小堆
  2. 利用堆删除思想来进行排序
    用到向下调整
	public static void heapSort(int[] array){
        //创建大根堆
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            siftDown(array,0,end--);
        }
    }

    private static void createHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            siftDown(array,parent,array.length);
        }
    }
    private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }
    private static void siftDown(int[] array,int parent,int len) {
        int child = (2*parent)+1;
        while (child < len) {
            if(child + 1 < len && array[child] < array[child+1]) {
                child = child+1;
            }
            //child一定是 左右孩子最大值的下标
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

常见习题:

1.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为()
A: (11 5 7 2 3 17) B: (11 5 7 2 17 3) C: (17 11 7 2 3 5)
D: (17 11 7 5 3 2) E: (17 7 11 3 5 2) F: (17 7 11 3 2 5)
答案:C

【堆排序的特性总结】

  1. 堆排序使用堆来选数,效率就高了很多。
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(1)
  4. 稳定性:不稳定

冒泡排序

在这里插入图片描述

    public static void bubbleSort(int[] array) {
        //i代表趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for(int j = 0;j < array.length-1-i;j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            //没有交换证明有序了
            if(flg == false) {
                return;
            }
        }
    }

【冒泡排序的特性总结】

  1. 时间复杂度:O ( N 2 ) (N^2) (N2)
  2. 空间复杂度:O(1)
  3. 稳定性:稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法,其基本思想为:任取待排序元素序列中的某元素作为基准值,以该元素为基准将待排序序列分割成两子列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后左右子序列重复该过程,直到所有元素都排列在相应位置上为止。

主框架如下:

    public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }

 	void quick(int[] array, int start, int end) {
        if(start >= end) {
            return;
        }
        // 按照基准值对array数组的 [left, right)区间中的元素进行划分
        int pivot = partition(array, start, end);
        quick(array, start, pivot-1);
        quick(array, pivot+1, end);
    }

    int partition(int[] array, int left, int right) {

    }

只需分析如何按照基准值来对区间中数据进行划分即可。将区间按照基准值划分为左右两部分的常见方式有:

Hoare法

  • 时间复杂度:

    • 最好情况下:O(N*logN)
    • 最坏情况下(有序 / 逆序): O ( N 2 ) O(N^2) O(N2)
  • 空间复杂度:

    • 最好情况下:O(logN)
    • 最坏情况下(有序 / 逆序):O(N)
  • 稳定性: 不稳定的排序

	public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }
	
	void quick(int[] array, int start, int end) {
        if(start >= end) {
            return;
        }
        int pivot = partition(array, start, end);
        quick(array, start, pivot-1);
        quick(array, pivot+1, end);
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }
    
    private static int partition (int[] array,int left,int right) {
        int tmp = array[left];//基准
        int i = left;
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            while (left < right && array[left] <= tmp) {
                left++;
            }
            swap(array,left,right);
        }
        swap(array,i,left);
        return left;
    }

挖坑法

	private static int partition(int[] array,int left,int right) {
        int tmp = array[left];
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            if(left == right) {
                break;
            }
            array[left] = array[right];
            while (left < right && array[left] <= tmp) {
                left++;
            }
            if(left == right) {
                break;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

前后指针(只需了解)

写法一:

 private static int partition(int[] array, int left, int right) {
        int prev = left ;
        int cur = left+1;
        while (cur <= right) {
            if(array[cur] < array[left] && array[++prev] != array[cur]) {
                swap(array,cur,prev);
            }
            cur++;
        }
        swap(array,prev,left);
        return prev;
    }

写法二:

private static int partition(int[] array, int left, int right) {
        int end = left + 1;
        int pivot = array[left];
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < pivot) {
                swap(array, i, end);
                end++;
            }
        }
        swap(array, end - 1, left);
        return end - 1;
    }

快速排序优化

  1. 三数取中法选key
  2. 递归到小的子区间时,因为已经趋于有序,可以考虑使用插入排序
private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        //小的子区间进行插入排序
        if(end-start+1 <= 15) {
            insertSort(array, start, end);
            return;
        }

        //1. 三数取中  index是中间大的数字 的 下标
        int index = middleNum(array,start,end);
        swap(array,index,start);

        int pivot = partition(array,start,end);

        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }


    public static void insertSort(int[] array,int start,int end) {
        for (int i = start+1; i <= end; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= start ; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

    private static int middleNum(int[] array,int left,int right) {
        int mid = left+((right-left) >> 1);
        //相当于int mid = (left+right)/2;
        if(array[left] < array[right]) {
            if(array[mid] < array[left]) {
                return left;
            }else if(array[mid] > array[right]) {
                return right;
            }else {
                return mid;
            }
        }else {
            if(array[mid] < array[right]) {
                return right;
            }else if(array[mid] > array[left]) {
                return left;
            }else {
                return mid;
            }
        }
    }

快速排序非递归

	public static void quickSortNor(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length-1;
        int pivot = partition(array,left,right);

        if(pivot-1 > left) {
            stack.push(left);
            stack.push(pivot-1);
        }
        if(pivot + 1 < right) {
            stack.push(pivot+1);
            stack.push(right);
        }
        while (!stack.isEmpty()) {
            right = stack.pop();
            left = stack.pop();
            pivot = partition(array,left,right);

            if(pivot-1 > left) {
                stack.push(left);
                stack.push(pivot-1);
            }
            if(pivot + 1 < right) {
                stack.push(pivot+1);
                stack.push(right);
            }
        }
    }

快速排序总结

  1. 快速排序整体的综合性能和使用场景都是比较好的,所以才叫快速排序
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(logN)
  4. 稳定性:不稳定

归并排序

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将有序的子序列合并,得到完全有序的序列.

在这里插入图片描述

    public static void mergeSort(int[] array) {
        mergeFunc(array,0,array.length-1);
    }

    private static void mergeFunc(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        int mid = left + ((right-left) >> 1);
        mergeFunc(array,left,mid);
        mergeFunc(array,mid+1,right);
        //左边分解完,右边分解完,开始合并
        merge(array,left,mid,right);
    }

    private static void merge(int[] array,int left,int mid,int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        int[] tmpArr = new int[right-left+1];
        int k = 0;
        //1.保证两个表 都有数据
        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        //2. 看哪个数组 还有数据 拷贝回去
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }
        //3.拷贝到源数组
        for (int i = 0; i < k; i++) {
            array[i+left] = tmpArr[i];
        }
    }

非递归实现归并排序:

	public static void mergeSortNor(int[] array) {
        int  gap = 1;
        //gap是待排序的个子组的元素个数
        while (gap < array.length) {
            //对子组两两进行排序
            for (int i = 0; i < array.length; i = i+2*gap) {
                int left = i;
                int mid = left + gap-1;
                if(mid >= array.length) {
                    mid = array.length-1;
                }
                int right = mid+gap;
                if(right >= array.length) {
                    right = array.length-1;
                }
                merge(array,left,mid,right);
            }
            gap *= 2;
        }
    }
	private static void merge(int[] array,int left,int mid,int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        int[] tmpArr = new int[right-left+1];
        int k = 0;
        //1.保证两个表 都有数据
        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        //2. 看哪个数组 还有数据 拷贝回去
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }
        //3.拷贝到源数组
        for (int i = 0; i < k; i++) {
            array[i+left] = tmpArr[i];
        }
    }

归并排序总结

  1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(N)
  4. 稳定性:稳定

海量数据的排序问题

外部排序:排序过程对在磁盘等外部存储进行的排序
前提:内存只有 1G,需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下,所以需要外部排序,而归并排序是最常用的外部排序

  1. 先把文件切分成 200 份,每个 512 M
  2. 分别对 512 M 排序,因为内存已经可以放的下,所以任意排序方式都可以
  3. 进行 2路归并,同时对 200 份有序文件做归并过程,最终结果就有序了

排序算法复杂度及稳定性分析

在这里插入图片描述
数据敏感的意思是数据越有序,排序速度越快(冒泡,插入,希尔),数据越有序,排序速度越慢(快排).对于其余排序,数据是否有序对其效率影响不大

排序方法最好时间平均时间最坏时间空间复杂度稳定性
冒泡排序优化后O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)稳定
插入排序O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)稳定
选择排序O( n 2 n^2 n2)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)不稳定
希尔排序O(n)O( n 1.3 n^{1.3} n1.3)O( n 2 n^2 n2)O(1)不稳定
堆排序O(n*logn)O(n*logn)O(n*logn)O(1)不稳定
快速排序O(n*logn)O(n*logn)O( n 2 n^2 n2)O(logn) ~ O(n)不稳定
归并排序O(n*logn)O(n*logn)O(n*logn)O(n)稳定

其他排序(只需了解)

计数排序

思想:计数排序又称为鸽巢原理,是对哈希直接定址法的变形应用。 操作步骤:

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中

在这里插入图片描述

    public static void countSort(int[] array) {
        //1.求最值 
        int min = array[0];
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(min > array[i]) {
                min = array[i];
            }
            if(max < array[i]) {
                max = array[i];
            }
        }
        //2、定义计数数组 进行初始化 
        int[] count = new int[max-min+1];
        for (int i = 0; i < array.length; i++) {
            int index = array[i]-min;
            count[index]++;
        }

        //3、遍历计数数组 
        int k = 0;//表示array数组的下标
        for (int i = 0; i < count.length; i++) {
            while (count[i] != 0) {
                array[k++] = i + min;
                count[i]--;
            }
        }
    }
}

【计数排序的特性总结】

  1. 计数排序在数据范围集中时,效率很高,但是适用范围及场景有限。
  2. 时间复杂度:O(范围+n)
  3. 空间复杂度:O(范围)
  4. 稳定性:稳定

基数排序

最大值的位数,就是进出的次数

在这里插入图片描述

桶排序

在这里插入图片描述

选择题

  1. 快速排序算法是基于()的一个排序算法。
    A:分治法 B:贪心法 C:递归法 D:动态规划法

选A

2.对记录(54,38,96,23,15,72,60,45,83)进行从小到大的直接插入排序时,当把第8个记录45插入到有序表时,为找到插入位置需比较()次?(采用从后往前比较)
A: 3 B: 4 C: 5 D: 6

在这里插入图片描述
5次,选C

3.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序

没有简单排序,选D

4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序

选B

5.关于排序,下面说法不正确的是()
A: 快排时间复杂度为O(N*logN),空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时,快排退化成 “冒泡排序”,直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)

选D,堆排序空间复杂度的为O(1)

6.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66),则以第一个关键字65为基准而得到的一趟快速排序结果是()
A: 34,56,25,65,86,99,72,66 B: 25,34,56,65,99,86,72,66
C: 34,56,25,65,66,99,86,72 D: 34,56,25,65,99,86,72,66

首先试挖坑法,再是Hoare法,最后是前后指针法
选A

  • 24
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值