【数据结构】常见的排序算法

已于 2022-05-29 22:43:27 修改
阅读量560 收藏 4
点赞数 1
分类专栏： 数据结构 排序 文章标签： 排序算法 数据结构 算法
于 2022-05-24 11:14:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40839718/article/details/124940330
版权

常见的排序算法

1、 排序算法的介绍

排序也称排序算法(Sort Algorithm)，排序是将一组数据，按照指定的顺序进行排列的过程。

2、排序分类

2.1 内部排序

将需要处理的所有数据加载到内部存储器（内存）中进行排序。

2.2 外部排序

数据量大，无法加载到内存中，需要借助外部存储（文件等）进行排序。

2.3 常见的排序算法分类

在这里插入图片描述

3、算法的时间复杂度

3.1 时间频度

一个算法中的语句执行次数称为时间频度，记为T(n)。

3.2 时间复杂度

3.2.1 定义

一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数，记作O(f(n))=T(n)，称O(f(n))为算法的时间复杂度。

3.2.2 计算时间复杂度的方法

(1) 用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1；
(2) 修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²；
(3) 去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)。

3.2.3 常见的时间复杂度

(1) 常数阶O(1)
(2) 对数阶O(log2n)
(3) 线性阶O(n)
(4) 线性对数阶O(nlog2n)
(5) 平方阶O(n^2)
(6) 立方阶O(n^3)
(7) k次方阶O(n^k)
(8) 指数阶O(2^n)
常见的算法时间复杂度由小到大依次为：
O(1)＜O(log2n)＜O(n)＜O(nlog2n)＜O(n2)＜O(n3)＜O(nk)＜O(2n)，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
(1) 常数阶O(1)
无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)。
在这里插入图片描述
上述代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度。
(2) 对数阶O(log2n)
在while循环里面，每次都i乘以2，乘完之后，i距离n就越来越近了。假设循环x次之后，i就大于2了，此时这个循环就退出了，也就是说2的x次方等于n，那么x=log2n也就是说当循环log2n次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(log2n)。O(log2n)的这个2时间上是根据代码变化的，i=i*3，则是O(log3n)。
在这里插入图片描述
(3) 线性阶O(n)
这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度。在这里插入图片描述
(4) 线性对数阶O(nlog2n)

将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就n*O(logN)，也就是了O(nlogN)
在这里插入图片描述
(5) 平方阶O(n^2)

O(n)的代码再嵌套循环一遍，它的时间复杂度就是O(n²)，这段代码其实就是嵌套了2层n循环，它的时间复杂度就是 O(nn)，即O(n²如果将其中一层循环的n改成m，那它的时间复杂度就变成了 O(mn)。
在这里插入图片描述
(6) 立方阶O(n^3)
O(n³)相当于三层n循环。
(7) k次方阶O(n^k)
O(nk)相当于k层n循环。

5、冒泡排序

5.1 定义

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
在这里插入图片描述
在这里插入图片描述

5.2 特点

(1) 总共进行arr.length次大的循环；
(2) 每一趟排序的次数在逐渐减少。

5.2 代码实现

5.2.1 程序编写

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3, 44, 38, 5, 47, 15, 36, 26,27,2,46,4,19,50,48};
        System.out.println("====冒泡排序前遍历数组====");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        bubbleSort(arr);
        System.out.println("====冒泡排序后遍历数组====");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void bubbleSort(int[] arr) {
        int temp = 0;//暂存变量
        boolean flag = false;//标识变量，标识是否进行过交换
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

5.2.2 运行结果

在这里插入图片描述

5.2.3 容易出错的地方

在这里插入图片描述

5.3 优化

若发现在某趟排序中没有发生一次交换，可以设置一个标志flag判断元素是否进行过交换，提前结束冒泡排序，从而减少不必要的比较，如第二趟排序后元素次序就不改变。

public static void bubbleSort(int[] arr) {
        int temp = 0;//暂存变量
        boolean flag = false;//标识变量，标识是否进行过交换
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
            if (!flag) {//在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false;//重置flag，进行下次判断
            }
        }
    }

5.4 测试冒泡排序的速度O(n^2)

5.4.1 代码编写

测试一下冒泡排序的速度O(n^2), 给80000个数据测试

public class BubbleSort {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int arr[] = {3, 9, -1, 10, 20, -2, 45, 458};
        //测试一下冒泡排序的速度O(n^2), 给80000个数据测试
        创建要给80000个的随机的数组
        int[] array = new int[80000];
        for (int i = 0; i < 80000; i++) {
            array[i] = (int) (Math.random() * 100000);//随机生成1个[0,100000)的数
        }
        System.out.println("====排序前遍历前20个元素====");
        for (int i = 0; i < 20; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        bubbleSort(array);
        System.out.println("====排序后遍历前20个元素====");
        for (int i = 0; i < 20; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        long end = System.currentTimeMillis();
        System.out.println("当前程序运行多少毫秒:" + "=" + (end - start));
    }

    public static void bubbleSort(int[] arr) {
        int temp = 0;//暂存变量
        boolean flag = false;//标识变量，标识是否进行过交换
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
            if (!flag) {//在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false;//重置flag，进行下次判断
            }
        }
    }
}

5.4.2 运行结果

在这里插入图片描述

6、选择算法(select sorting)

6.1 基本思想

(1) 第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换；
(2) 第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换；
(3) 第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换；
(4) 第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换；
(5) 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换；
(6) 总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
在这里插入图片描述

6.2 代码编写

public class SelectSort {
    public static void main(String[] args) {
        int array[] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("====选择排序前遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        selectSort(array);
        System.out.println("====选择排序后遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int min = array[i];//假设array[i]为最小值
            int minindex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (min > array[j]) {//min不是真正的最小值
                    min = array[j];//重置min
                    minindex = j;//重置minindex
                }
            }
            /*判断是否需要交换*/
            if (minindex != i) {
                array[minindex] = array[i];
                array[i] = min;
            }
        }
    }
}

6.3 运行结果

在这里插入图片描述

7、插入排序

7.1 基本思想

把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
在这里插入图片描述

7.2 代码编写

public class InsertSort {
    public static void main(String[] args) {
        int array[] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("====选择排序前遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        insertSort(array);
        System.out.println("====选择排序后遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void insertSort(int array[]) {
        for (int i = 1; i < array.length; i++) {//默认有序列表只包含array数组的第一个元素
            int insertValue = array[i];
            int insertIndex = i-1;//表示有序列表最后一个元素的下标
            while (insertIndex >= 0 && insertValue < array[insertIndex]) {//直到找到位置
                array[insertIndex + 1] = array[insertIndex];
                insertIndex--;
            }
            //退出while循环说明插入的位置找到了
            array[insertIndex + 1] = insertValue;
        }
    }
}

7.3 运行结果

在这里插入图片描述

8、希尔排序

8.1 基本思想

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
在这里插入图片描述

8.2 代码编写

public class ShellSort {
    public static void main(String[] args) {
        int array[] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2};
        System.out.println("====希尔排序前遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        shellSort(array);
        System.out.println("====希尔排序后遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void shellSort(int array[]) {
        //增量gap，并逐步缩小增量
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            //从第gap个元素，逐个对其所在的组进行插入排序
            for (int i = gap; i < array.length; i++) {
                int insertValue = array[i];
                int insertIndex = i;
                if (array[insertIndex - gap] > array[insertIndex]) {
                    while (insertIndex - gap >= 0 && insertValue < array[insertIndex - gap]) {
                        //移动
                        array[insertIndex] = array[insertIndex - gap];
                        insertIndex -= gap;
                    }
                    //当退出while后，就给insertValue找到了插入的位置
                    array[insertIndex] = insertValue;
                }
            }
        }
    }
}

8.3 运行结果

在这里插入图片描述

9、快速排序

9.1 基本思想

快速排序是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
在这里插入图片描述
在这里插入图片描述

9.2 代码编写

public class QuickSort {
    public static void main(String[] args) {
        int array[] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2};
        System.out.println("====快速排序前遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        quickSort(array, 0, array.length - 1);
        System.out.println("====快速排序后遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
        public static void quickSort(int array[],int left,int right){
        int l = left;
        int r = right;
        int povit = array[(left+right)/2];
        int temp = 0;
        while (l<r){
            while (array[l] < povit){
                l++;
            }
            while (array[r] > povit){
                r--;
            }
            temp = array[r];
            array[r] = array[l];
            array[l] = temp;
            if(l >= r){//如果l>=r,说明pivot两边已经按左边≤pivot、右边≥pivot排列
               break;
            }

        }
        if(l == r){
            l++;
            r--;
        }
        if(left <r){
            quickSort(array,left,r);
        }
        if(right > l){
            quickSort(array,l,right);
        }
    }
}

9.3 运行结果

在这里插入图片描述

10、归并排序

10.1 基本思想

归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治（策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
在这里插入图片描述
将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]。
在这里插入图片描述

10.2 代码编写

public class MergeSort {
    public static void main(String[] args) {
        int array[] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2};
        int temp[] = new int[array.length];
        System.out.println("====归并排序前遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        mergeSort(array, 0, array.length - 1,temp);
        System.out.println("====归并排序后遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void mergeSort(int array[], int left, int right, int temp[]) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(array, left, mid, temp);//向左递归进行分解
            mergeSort(array, mid + 1, right, temp);//向右递归进行分解
            merge(array, left, mid, right, temp);
        }
    }

    public static void merge(int array[], int left, int mid, int right, int temp[]) {
        int l = left;//左边有序序列的初始索引
        int r = mid + 1;//右边有序序列的初始索引
        int t = 0;
        //先把左右两边有序序列的元素按照规则填充到temp数组，直到有一边处理完毕为止
        while (l <= mid && r <= right) {
            if (array[l] <= array[r]) {
                temp[t++] = array[l++];
            } else {
                temp[t++] = array[r++];
            }
        }
        //把有剩余数据的序列的剩余元素依次填充到temp
        while (l <= mid) {
            temp[t++] = array[l++];
        }
        while (r <= right) {
            temp[t++] = array[r++];
        }
        //将temp数组元素拷贝到array
        t = 0;
        int templeft = left;
        while (templeft <= right) {
            array[templeft++] = temp[t++];
        }
    }
}

10.3 运行结果

在这里插入图片描述

10、堆排序

10.1 基本思想

堆排序是一种树形选择排序，是对直接选择排序的有效改进。利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。需要注意的是排升序要建大堆，排降序建小堆。
在这里插入图片描述

10.2 代码编写

public class HeapSort {
    public static void main(String[] args) {
        int array[] = {3, 4444, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("====堆排序前遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        heapSort(array, array.length);
        System.out.println("====堆排序后遍历元素====");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void heapSort(int arr[], int n) {
        //建堆
        for (int j = (n - 1) / 2; j >= 0; j--) {
            holdHeap(arr, n, j);
        }
        //排序
        for (int i = n - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            holdHeap(arr, i, 0);
        }
    }

    public static void holdHeap(int arr[], int n, int i) {
        int largest = i;
        int lson = 2 * i + 1;
        int rson = 2 * i + 2;
        int temp = 0;
        if (lson < n && arr[largest] < arr[lson]) {
            largest = lson;
        }
        if (rson < n && arr[largest] < arr[rson]) {
            largest = rson;
        }
        if (largest != i) {
            temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;
            holdHeap(arr, n, largest);
        }
    }
}

10.3 运行结果

在这里插入图片描述

dengmsjava
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值