几种常见的排序

已于 2023-07-27 22:52:34 修改
阅读量375 收藏 1
点赞数
文章标签： 数据结构
于 2023-07-27 22:51:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67793092/article/details/129824088
版权

目录

一.插入排序

1.直接插入排序

​编辑2.希尔排序

二.选择排序

1.直接选择排序

（1）一次确定一个小最值

（2）一次确定一个最大值，一个最小值

2.堆排序

三.交换排序

1.冒泡排序

2.快速排序

3.快速排序优化

（1）三数取中法：将其尽可能划分成一个均匀的二叉树

（2）小区间使用插入排序

四.归并排序 

总结

一.插入排序

将待排序的数据按照其大小逐个插入到一个已经排好序的有序序列中，直到所有记录插入完成为止。

1.直接插入排序

效率： 在数据为逆序排列时，时间复杂度最大，O（n^2）,当数据接近有序时，时间复杂度最小O(n),所以当数据不多，且基本趋于有序的时候，直接插入非常快。

稳定性：稳定

一个本身是稳定的排序，可以把它变为不稳定的。

  //直接插入排序
    //时间复杂度：
    //最坏情况 逆序  O(n^2)
    //最好情况：有序 O(n)
    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--) {
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
                    array[j + 1] =tmp ;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

测算耗时：

2.希尔排序

也叫做缩小增量排序：直接插入排序的优化

指定gap分组（缩小增量）5/4/3

每次分组排序后会把大的数往后排，小的数往前排。

希尔排序相比于直接插入排序的区别是：

1.将数根据步长进行了分组（希尔排序步长为一时就是直接插入排序）

2.不同的分组中依次进行了直接插入排序

因此希尔排序就是有步长的循环直接插入排序

代码只需要将直接插入排序的步长进行修改并且加上循环操作即可：

    public 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=j-gap) {
                if (array[j] > tmp) {
                    array[j + gap] = array[j];
                }else {
                    array[j+gap]=tmp;
                    break;
                }
            }
            array[j + gap] = tmp;
        }
    }

    public static void shellSort(int[]array){
        int gap=array.length;
        while(gap>1){
            gap=gap/2;
            shell(array,gap);
        }
    }
  public static void main(String[] args) {
        int[] array = {1, 2, 19, 34, 29, 15,37,8};
        shellSort(array);
        System.out.println(Arrays.toString(array));
    }

希尔排序步长的确定方法目前没有准确的规定，怎样取值使其的时间复杂度最小未知。

目前得到的较为准确的时间复杂度为：O（n^1.3)

二.选择排序

1.直接选择排序

每一次从待排序的数据元素中选出最小（或者最大）的一个元素，存放在序列的起始位置，直到全部待排序元素排完。

特点：好理解但是效率低，实际很少用。

（1）一次确定一个小最值

时间复杂度：看每次j要移动的次数

（N-1）+(N-2)+.......+1=[(N-1+1)*(N-1)]/2

时间复杂度：O(N^2)

空间复杂度：O（N)

稳定性：不稳定

思路：

1.用i下标遍历数组，用minIndex储存最小值的下标，minIndex初始为i

2.j从i后面一个开始遍历 ,遇到比minIndex储存的值更小的值，更新minIndex

3.等到j遍历完，交换i与minIndex存储的值

//选择排序
    //一次只确定一个最小的
    public static void selectSort(int[]array) {
        for (int i = 0; i < array.length; i++) {
            int j = i + 1;
            int minIndex = i;
            for (; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (i != minIndex) {
                swap(array, minIndex, i);

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

（2）一次确定一个最大值，一个最小值

思路：

1.用left和right分别代表数组的最左边和最右边下标，初始默认最小值为left,最大值为right

2.用j从left+1的位置开始遍历，当array[j]<array[minIdex],更新minIndex的值为j,当array[j]>array[minIndex],更新maxIndex的值为j

3.当j遍历完，交换array[left]与array[minIdex]，交换array[right]与array[maxIndex]

4.left++,right--,直到相遇，全部排序完成

  

 需要特别注意的点，当一组数据最的大值在最前面时

 代码如下：

public static void selectSort2(int[]array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = right;
            int j=left+1;
            for (; j <= right; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex= j;
                }
                if (array[j] > array[maxIndex]) {
                    maxIndex = j;
                }
            }
                swap(array,left,minIndex);
                if(maxIndex==left){
                    maxIndex=minIndex;
                }
                swap(array,right,maxIndex);
                left++;
                right--;
            }
        }

2.堆排序

思路：

 1.建立大根堆

1）从下往上找每课子树的父亲节点；parent--；

2）找到该父亲节点后，向下调整，确定每一棵树的所有子树也都是大根堆；

3）向下调整每棵树：孩子节点与父亲节点的比较和交换；

整体代码如下：

       //堆排序
        //时间复杂度O（n*log2(n))
        //空间复杂度O(1)
        //不稳定的算法
    public static void heapSort(int[]array){
        createBigHeap(array);//O(n)
        int end= array.length-1;
        while(end>0){
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }
    public static void createBigHeap(int[] array){
       int parent=(array.length-1-1)/2;
        for (; parent>=0 ; parent--) {
            shiftDown(array,parent,array.length);
        }
    }
    public static void shiftDown(int[] array,int parent,int len){
        int child=2*parent+1;
        while(child<len){
            if(child+1<len && array[child]<array[child+1]){
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array,child,parent);
                parent=child;
                child=2*parent+1;
            }else{
                break;
            }
        }
    }

    
    public static void main(String[] args) {
        int[] array={9,2,5,1,7,3};
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }

三.交换排序

1.冒泡排序

思路：

1.每趟排序都从0开始；

2.一趟排序完成可以确定一个最大的数在最后面

3.外层循环是一共比较的趟数（趟数=数据个数-1），内层循环是比较两个数的大小（内层循环的次数=数据个数-1-外层循环的趟数，因为一趟下来确定一个数，一趟下来，第二趟就少比一次，以此类推）

  //冒泡排序法
    //不考虑优化的时间复杂度O（n^2);优化后最好的情况可以达到0(n)
    //空间复杂度O(1)
    //稳定性：稳定
    public static void bubbleSort(int[]array){
        //最外层控制趟数
        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]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flg=true;
                }
                if(flg==false){
                    break;
                }
            }
        }
    }

2.快速排序

思路：

1）一次排序确定一个基准，基准左边的数都比它小，基准右边的数都比它大。

2）依次对基准左部分和右部分 进行相同的操作，最后得到的可以类比成为一个有序的二叉树

 //快速排序

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

    private static void quick(int[] array, int start, int end) {
        int pivot = partitionHoare(array, start, end);
        //必须加上大于号，不然1、2、3、4、5、6这种情况时直接没有左树，或者没有右树
        if (start >= end) {
            return;
        }
        quick(array, start, pivot- 1);
        quick(array, pivot + 1, end);
    }

    private static int partitionHoare(int[] array, int left, int right) {
        int i=left;
        int pivot = array[left];
        while (left < right) {
            while (left < right && array[right] >= pivot) {
                //这里的left<right是为了防止所有值都比pivot大
                right--;
            }
            while(left < right && array[left] <= pivot){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,left,i);//这里left和right是相等的，写left或者right都可以
        return left;
    }

空间复杂度：树的高度 log2(N)

稳定性：不稳定

缺陷：当数据是有序时，变成一个右子树，排序类似于冒泡排序，时间复杂度达到O（N^2)

3.快速排序优化

当数据趋于有序的情况下会出现一棵树没有左子树，划分不均匀，增加了时间和空间复杂度。对数据划分均匀是快速排序优化的目的。

（1）三数取中法：将其尽可能划分成一个均匀的二叉树

找到start midIndex end 三个下标，然后找到三个数值的中间值然后将其作为基准。

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

    private static void quick(int[] array, int start, int end) {
        //必须加上大于号，不然1、2、3、4、5、6这种情况时直接没有左树，或者没有右树
        if (start >= end) {
            return;
        }
        //在执行找找基准之前，先解决划分不均匀的问题
        int index=findMidValueOfIndex(array, start, end);
        swap(array,start,index);

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


        //优化
    private static int findMidValueOfIndex(int[]array,int start,int end) {
        //三位取中法
        int midIndex = (start + end) / 2;
        if (array[start] < array[end]) {
            if (array[midIndex] < array[start]) {
                return start;
            } else if (array[midIndex] > array[end]) {
                return end;
            } else {
                return midIndex;
            }
        }else {
            if(array[midIndex]>array[start]){
                return start;
            }else if(array[midIndex]<array[end]){
                return end;
            }else {
                return midIndex;
            }
        }
    }
    
    private static int partitionHoare(int[] array, int left, int right) {
        int i=left;
        int pivot = array[left];
        while (left < right) {
            while (left < right && array[right] >= pivot) {
                //这里的left<right是为了防止所有值都比pivot大
                right--;
            }
            while(left < right && array[left] <= pivot){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,left,i);//这里left和right是相等的，写left或者right都可以
        return left;
    }

（2）小区间使用插入排序

当一组数据排序往后时二叉树分支越来越多，递归的应用次数也开始变多，这个时候数据已经逐渐趋于有序了，所以这时小区间使用插入排序。

完整代码 

 private static void insertSort1(int[] array,int left,int right ) {
        for (int i =left+1; i <=right; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >=left; j--) {
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
                    array[j + 1] =tmp ;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

    //快速排序
    //时间复杂度：N*log2(N)
    //空间复杂度：log2(N)

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

    private static void quick(int[] array, int start, int end) {
        //必须加上大于号，不然1、2、3、4、5、6这种情况时直接没有左树，或者没有右树
        if (start >= end) {
            return;
        }

        //对start和end区间范围内使用插入排序
        if(end-start+1<=15){
            insertSort1(array,start,end);
            return;
        }
        //在执行找找基准之前，先解决划分不均匀的问题
        int index=findMidValueOfIndex(array, start, end);
        swap(array,start,index);

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

    private static int findMidValueOfIndex(int[]array,int start,int end) {
        //三位取中法
        int midIndex = (start + end) / 2;
        if (array[start] < array[end]) {
            if (array[midIndex] < array[start]) {
                return start;
            } else if (array[midIndex] > array[end]) {
                return end;
            } else {
                return midIndex;
            }
        }else {
            if(array[midIndex]>array[start]){
                return start;
            }else if(array[midIndex]<array[end]){
                return end;
            }else {
                return midIndex;
            }
        }
    }

    private static int partitionHoare(int[] array, int left, int right) {
        int i=left;
        int pivot = array[left];
        while (left < right) {
            while (left < right && array[right] >= pivot) {
                //这里的left<right是为了防止所有值都比pivot大
                right--;
            }
            while(left < right && array[left] <= pivot){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,left,i);//这里left和right是相等的，写left或者right都可以
        return left;
    }

（3）快速排序非递归

非递归，用到栈

  public static void quickSort1(int[] array){
        Stack<Integer> stack=new Stack<>();
        int start=0;
        int end=array.length-1;
        int pivot=partitionHoare(array,start,end);
        //这里用hoare法演示，不用挖坑法
        //判断基准左边部分是不是至少有两个元素
        if(pivot>start+1){
            //把边界放入栈中
            stack.push(start);
            stack.push(pivot-1);
        }
        //判断基准右边部分是不是至少有两个元素
        if(pivot<end-1){
            stack.push(pivot+1);
            stack.push(end);
        }
        while(!stack.isEmpty()){
            end=stack.pop();
            start=stack.pop();

            //再对该部分找基准，重复上面代码操作
            pivot=partitionHoare(array,start,end);

            //判断基准左边部分是不是至少有两个元素
            if(pivot>start+1){
                //把边界放入栈中
                stack.push(start);
                stack.push(pivot-1);
            }
            //判断基准右边部分是不是至少有两个元素
            if(pivot<end-1){
                stack.push(pivot+1);
                stack.push(end);
            }
        }
    }

四.归并排序 

//归并排序
    public static void mergeSort(int[]array){
      mergeSortChild(array,0,array.length-1);
    }

    public  static void mergeSortChild(int[]array,int left,int right){
        if(left>=right){
            return;
        }
        //分解
        int mid=(left+right)/2;
        mergeSortChild(array,left,mid);
        mergeSortChild(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;
         while (s1 <= e1 && s2 <= e2) {
             if (array[s1] < array[s2]) {
                 tmpArr[k] = array[s1];
                 k++;
                 s1++;
             } else {
                 tmpArr[k] = array[s2];
                 k++;
                 s2++;
             }
         }
         while(s1<=e1){
             tmpArr[k] =array[s2];
             k++;
             s1++;
         }
         while(s2<=e2){
             k++;
             s2++;
         }
         for (int i = 0; i < k; i++) {
             array[i+left]=tmpArr[i];
         }
     }

总结

Roylelele
关注
数据结构之排序算法
qq_35220389的博客
03-23 614
一、冒泡排序 思想：从第一个元素开始，比较相邻元素大小，若顺序有误则交换相邻元素。每一次扫描可以确保最后一个元素位于正确的位置。接着进行第二趟扫描，直到完成所有元素的排序关系为止。 冒泡排序的时间和空间复杂度分析： 时间复杂度（平均）： 时间复杂度（最坏）： 时间复杂度（最好）： 空间复杂度： 稳定性：稳定 def bubleSort(array): if not ...
mysql 表大小 排序,excel按数据大小进行排序的方法步骤图
weixin_39818727的博客
03-17 456
目前人们对办公自动化软件excel的功能只用了它的一小部分功能 ,大部分功能因不会用或不能直接用而没有用到;面对工作表中复杂繁多的数据，对它进行大小的排序，其实这很简单，下面小编来告诉你怎么按数据的大小进行排序吧。excel按数据的大小进行排序的方法1、我们现在Excel中打开一篇工作表，点击功能区的”开始“选项卡，在”编辑”区域选择“排序和筛选”的图标。然后点击它的倒三角按钮，在弹出的下拉菜单中...
排序算法之选择排序法
weiwei152433的博客
02-12 1329
选择排序法(Selection Sort)也算是枚举法的应用，就是反复从末排序的数列中取出最小的元素，加入另一个数列中，最后的结果即为已排序的数列。选择排序法可使用两种方式排序，即在所有的数据中，若从小到大排序，则将最大值放入第一个位置；若是从大到小排序，则将最大值放入最后一个位置，例如，一开始在所有的数据中挑选一个最小项放在第一个位置（假设是从小到大排序），在从第二项开始挑选一个最小项放在第2个位置，以此重复，直到完成排序为止。
最大值，最小值，选择排序，冒泡排序，杨辉三角
lqqwonderful的博客
05-31 812
1.找出最大值、最小值 int[] nums = { 23, 12, 15, 99 }; int a = nums[0]; int index = 0; for (int i = 1; i ) { // if(a>nums[i]){ //最小值 if (a nums[i]
【数据结构】排序
张吱吱的Bolg
09-07 944
1.直接插入排序 基本思想：将序列分为有序部分和无序部分，从无序部分依次选择元素与有序部分比较，找到适合的位置，将原来的元素往后移，将元素插入到相应的位置上。将数组的第一个位置（索引为0）设置为哨兵，然后将第一个元素（索引为1）看为有序部分，从第二个元素开始作为无序部分。无序部分的第一个元素，与有序部分的最后一个元素开始比较，且从后往前比较查找正确的位置，同时将数组元素比哨兵位置元素大的元素，依次向后移动。 时间复杂度： 空间复杂度： 是否稳定：是 代码实现 void insert...
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
asp下几种常用排序算法
10-30
在本篇中，将介绍ASP中常用的几种排序算法，包括选择排序、快速排序、冒泡排序和插入排序，并通过实际代码例子对每种算法进行说明。 首先介绍选择排序算法，选择排序是一种简单直观的排序方法。它的基本思想是在未...
几种常见排序算法的实现
07-29
本文将深入探讨六种常见的排序算法：选择排序、插入排序、冒泡排序、希尔排序、快速排序以及归并排序，它们都是编程实践中不可或缺的基础知识。 1. **选择排序（Selection Sort）**： 选择排序的工作原理是每一次...
JavaScript中几种常见排序算法小结
01-19
不要用太大数据去测试冒泡排序(浏览器崩溃了我不管) 如果有兴趣可以 下载测试页面 个人理解 冒泡排序：最简单，也最慢，貌似长度小于7最优 插入排序： 比冒泡快，比快速排序和希尔排序慢，较小数据有优势 快速排序...
最好的八大排序算法Java
zxc456733的博客
12-25 1778
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，
（篇七）输入任意个数字，输出最大值最小值，且进行排序排序
Viewinfinitely的博客
04-02 2021
1、题： 本篇是关于C语言的小实例，目的是让用户输入任意个数字，然后我们哟啊找出最大值，最小值，并且将用户输入的任意个数字进行排序 2、分析： （1）最简单的求最大值最小值方法就是用两个宏定义，然后遍历用户输入的所有数字，将其用宏定义转换一下，得出最大值和最小值 C语言宏定义： #define MAX(x,y) x>y ? x:y #define MIN(a,b) a>b ? b:a ...
常见的排序算法之选择排序、冒泡排序、快速排序
lxyy0530的博客
08-09 1409
一、选择排序 第一次从下标为0的开始下标为0的这个数与后面的n-1个进行比较；找出最小或者最大的放在下标为0的这个位置；第二次从下标为1的开始比较；查询剩下的最大或者最小值；放在 下标为1的位置；以此类推；直到排序完成。 package suanfa; import java.util.Random; /** * 选择排序 * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，...
数据结构与算法---排序---选择排序、堆排序
IOSSHAN的博客
09-28 229
选择排序（Selection Sort） 选择排序大致就是，每次循环找出最大值，然后与最后一个元素进行交换。然后再在除最后一个元素的数组里面，再找出最大值，与倒数第二个元素进行交换，以此类推。 执行流程： 1 从序列中找出最大的那个元素，然后与最末尾的元素交换位置。 执行完一轮后，最末尾的那个元素就是最大的元素 2 忽略1中曾经找到的最大元素，重复执行步骤1 不难写出代码： public class test { public static void main(String[] args) {
比较最大值最小值排序（冒泡排序）及折半查找法
chuanduo1947的博客
11-01 2029
一、比较最大值/最小值： int[] arr1=new int[]{23,57,6,87,34,22};//定义一个数组 int max=0;//定义一个中间数并福初始值 for(int i=0;i<arr1.length;i++){ if(max1&l...
js算法--判断最大值，排序，倒序输出。
xingguanghui_1134的专栏
09-02 2255
输入三个数，判断它们大小：用三元运算。 js代码： function on1() { var a = document.getElementById("input1").value; var b = document.getElementById("input2").value; var c = document.get
字典的最小值、最大值、排序
小龙在线
06-07 6345
如果想给字典求得最大值/最小值/排序后，能同时得到键值对，就需要使用zip()把键值反转过来，然后再求最大值/最小值/排序。 zip()的返回值是一个只能访问一次的迭代器。 prices = { 'ACME': 45.23, 'AAPL': 612.78, 'IBM': 205.55, 'HPQ': 37.20, 'FB': 10.75 } min_pr...
几种常见排序时间复杂度
最新发布
07-08
常见的排序算法的时间复杂度如下： 1. 冒泡排序（Bubble Sort）：最好情况下的时间复杂度为O(n)，最坏情况下的时间复杂度为O(n^2)。 2. 选择排序（Selection Sort）：无论最好情况还是最坏情况，时间复杂度都为O(n^...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Roylelele

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值