排序算法总结

最新推荐文章于 2023-05-20 11:42:06 发布
最新推荐文章于 2023-05-20 11:42:06 发布
阅读量146 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36744540/article/details/118764598
版权

排序算法总结

  • 问题一：冒泡排序的优化

在这里插入图片描述

1 分类

  • 内部排序：整个排序工作能够在主存中完成
    • 冒泡排序、快速排序、直接插入排序、希尔排序、简单选择排序、堆排序、归并排序
  • 外部排序：在磁盘上或者磁带上完成的排序
    • 计数排序、桶排序、基数排序

区别：(引自十大经典排序算法)

在这里插入图片描述

  • n：数据规模
  • k："桶"的个数
  • In-place：占用常数内存，不占用额外内存
  • Out-place：占用额外内存
  • 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

2 内部排序

2.1 冒泡排序

  • 思想：重复比较数组中相邻两个元素，如果二者顺序错误就进行交换，依次比较一次遍历后会将最大的元素放到最后面；每次遍历缩小区间，让大的元素一步一步冒到最后面，因此叫冒泡排序。

  • 步骤：

    1. 比较相邻的元素，如果前一个比后一个大，进行交换，第一遍结束后最大的元素刚好在最后一个位置
    2. 缩小遍历范围，重复上述操作

  • 代码：

    public static void bubbleSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int n = nums.length;
    for (int i = n - 1; i > 0; i--) {  // 维护每轮遍历的终点
        for (int j = 1; j <= i; j++) {  // 趟
            if (nums[j] < nums[j - 1]) swap(nums, j, j - 1);
        }
    }
}

public static void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

  • 问题：首先一种极端情况，数组刚开始就有序，此时其实不用继续比较了，然而上面的代码还会继续进行下一轮比较，直到n-1次，显然这种操作是不合理的。

  • 优化：设定一个标记位flag，初始化为false表示没有交换，发生了交换改为true，如果一次遍历后flag仍为true，则说明已经排好序啦结束循环即可。

    public static void bubbleSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int n = nums.length;
    boolean flag = false;  // 设置标记位，初始为false
    for (int i = n - 1; i > 0; i--) {  // 维护每轮遍历的终点
        for (int j = 1; j <= i; j++) {  // 趟
            if (nums[j] < nums[j - 1]) {
                swap(nums, j, j - 1);
                flag = true;
            }
        }
        if (!flag) break;
    }
}

public static void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

  • 进一步优化：对于这样的数组[4, 3, 2, 1, 6, 7, 8, 9]来说后面的四个元素已经有序了，再去进行比较显得多此一举。优化的方法可以记录最后一次的交换位置，然后下次遍历时只需要比较到这个位置即可。

    public static void bubbleSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int n = nums.length;
    int lastSwap = 0;  // 设置一个指针指向最后一次的比较位置
    for (int i = n - 1; i > 0; i--) {  // 维护每轮遍历的终点
        for (int j = 1; j <= i; j++) {  // 趟
            if (nums[j] < nums[j - 1]) {
                swap(nums, j, j - 1);
                lastSwap = j;
            }
        }
        i = lastSwap;
    }
}

public static void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

  • 继续优化：双管齐下式加标记位，即从左到右将最大值冒到最右边，从右往左将最小值冒到最左边。

    public static void bubbleSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int n = nums.length;
    int left = 1, right = n - 1;
    int lastSwap = 0;  // 设置一个指针指向最后一次的比较位置
    while (left < right) {
        // 向右冒泡
        for (int i = left; i <= right; i++) {
            if (nums[i] < nums[i - 1]) {
                swap(nums, i, i - 1);
                lastSwap = i;
            }
        }
        right = lastSwap;
        
        // 向左冒泡
        for (int j = right; j > left; j--) {
            if (nums[j] < nums[j - 1]) {
                swap(nums, j, j - 1);
                lastSwap = j - 1;
            }
        }
        left = lastSwap;
    }
}

public static void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

2.2 选择排序

  • 思想：将数组分成有序区和无序区，在无序区里找一个最小的元素跟在有序区的后面。注意选择排序算法由于什么数据进去都是O(n²)的时间复杂度，因此用到它的时候，数据规模越小越好。

  • 步骤：

    1. 首先在未排序序列中找到最小（最大）值，存放在排序序列的起始位置
    2. 再从剩余未排序元素中继续寻找最小（大）值，放到已排序序列的末尾
    3. 重复第二步，知道所有元素均排序完毕

  • 代码：

    public static void selectSort(int[] nums) {
    if (nums == null || nums.length <= 1) return;
    int n = nums.length;
    
    // int minNum = nums[0], min = 0;
    for (int i = 0; i < n - 1; i++) {
        int min = i;
        for (int j = i + 1; j < n; j++) {
            if (nums[j] < nums[min]) {
                min = j;
            }
        }
        // 将min位置和i位置进行交换
        swap(nums, i, min);
    }
}

public static void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

2.3 直接插入排序

  • 思想：类似于扑克牌整理，通过构建有序序列，对于未排序的数据，在已排序中从后往前扫描找到相应位置并插入。

  • 步骤：

    1. 将序列中第一个元素看做一个有序序列，把第二个元素到最后一个元素看成未排序序列
    2. 从头到尾扫描未排序序列，将扫描的每个元素插入有序序列的适当位置。

  • 代码：

    public static void insertSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int n = nums.length;
    
    // 遍历待排序列
    int preIndex, current;
    for (int i = 1; i < n; i++) {
        preIndex = i - 1;
        current = nums[i];
        // 从后往前扫描寻找插入位置
        while (preIndex >= 0 && nums[preIndex] > current) {
            nums[preIndex + 1] = nums[preIndex];
            preIndex--;
        }
        nums[preIndex + 1] = current;
    }
}

  • 优化：拆半插入

    在上面的排序中，我们都会和遍历整个已排序列表去寻找，由于前半部分已是有序的，因此可以改用二分查找来找到待插入位置，然后进行插入。

    public static void insertSort(int[] nums) {
    if (nums == null || nums.length == 0) {
        return;
    }
    int n = nums.length;
    int current;
    for (int i = 1; i < n; i++) {
        int left = 0;
        int right = i - 1;
        current = nums[i];
        // 二分查找已排序序列
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (current > nums[mid]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
            // 插入到left+1处
            for (int j = right; j > left; j--) {
                nums[j + 1] = nums[j];
            }
            nums[left + 1] = current;
        }
    }
}

2.4 希尔排序

  • 思想：希尔排序也称递减增量排序，是插入排序的更高效的改进版本，但它是非稳定排序算法。基本思想是先将整个待排序列的记录序列分割成若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序时”再对全体记录进行直接插入排序。

    它是基于直接插入排序的以下两种特性提出的：

    1. 插入排序在堆几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
    2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

  • 步骤：

    1. 选择增量gap = length/2，缩小增量以gap = gap/2的方式，用序列{n/2,(n/2)/2…1}来表示。
    2. 对每个子序列进行直接插入排序，直到增量为1即最后一趟直接插入排序后记录有序。

    图源：https://www.runoob.com/data-structures/shell-sort.html

    1. 初始增量第一趟gap = length/2 = 4

在这里插入图片描述

  1. 第二趟，增量缩小为2

在这里插入图片描述

  1. 第三趟，增量缩小为1，得到最终排序结果

在这里插入图片描述

  • 代码：

    public static void shellSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int len = nums.length;
    int temp;
    for (int gap = len / 2; gap >= 1; gap /= 2) {
        for (int i = gap; i < len; i++) {
            temp = nums[i];
            int j = i - gap;  // 当前位置的上一个位置，差一个增量
            // 直接插入排序
            while (j >= 0 && nums[j] > temp) {
                nums[j + gap] = nums[j];
                j -= gap;
            }
            nums[j + gap] = temp;
        }
    }
}

2.5 归并排序

  • 思想：该算法采用分治法思想，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

  • 步骤：

    1. 把长度为n的序列分成两个长度相等的n/2的子序列
    2. 对这两个子序列分别采用归并排序
    3. 将两个排序好的子序列合并成一个最终的排序序列

在这里插入图片描述

  • 代码：

    public static void mergeSort(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int n = nums.length;
    int[] temp = new int[n];  // 避免递归时频繁开辟空间，先建好一个长度等于原数组长度的临时数组
    
    mergeSortRecursive(nums, 0, n - 1, temp);
}

private static void mergeSortRecursive(int[] nums, int left, int right, int[] temp) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSortRecursive(nums, left, mid, temp);  // 左边归并排序
        mergeSortRecursive(nums, mid + 1, right, temp);  // 右边归并排序
        merge(nums, left, mid, right, temp);  // 将两个有序数组合并
    }
}

private static void merge(int[] nums, int left, int mid, int right, int[] temp) {
    int i = left;  // 左序列指针
    int j = mid + 1;  // 右序列指针
    int t = 0;  // 临时数组指针
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j]) {
            temp[t++] = nums[i++];
        } else {
            temp[t++] = nums[j++];
        }
    }
    // 将左边剩余元素放到temp中
    while (i <= mid) {
        temp[t++] = nums[i++];
    }
    // 将右边剩余元素放入temp中
    while (j <= right) {
        temp[t++] = nums[j++];
    }
    t = 0;
    // 将temp中元素拷贝到原数组中
    while (left <= right) {
        nums[left++] = temp[t++];
    }
}

2.6 快速排序

  • 思想：通过一趟排序将待排序列分隔成独立的两部分，其中一部分记录关键字小于基准，另一部分大于等于基准，分别对这两部分继续排序，以达到整个序列有序。

  • 步骤：

    1. 从数列中挑选出一个元素，作为基准(privot);
    2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
    3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

  • 代码：

    public static void quickSort(int[] nums, int left, int right) {
    if (nums == null || nums.length <= 1) return;
    // 1. 以第一个位置元素为基准进行一次排序，并返回基准的索引
    if (left < right) {
        int part = partical(nums, left, right);
        quickSort(nums, left, part - 1);
        quickSort(nums, part + 1, right);
    }
}
public static int partical(int[] nums, int left, int right) {
    // 1. 基准初始left,从left加1开始遍历
    int index = left + 1;
    // 遍历从1到right，进行判断交换
    for (int i = index; i <= right; i++) {
        if (nums[i] < nums[left]) {
            // 交换,将小于part的值放在左边，大于的放右边，然后将part的值根index-1的值交换
            swap(nums, i, index);
            index++;
        }
    }
    swap(nums, left, index - 1);
    return index - 1;
}

public static void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

2.7 堆排序

  • 相关概念

    1. 介绍：堆是一类数据结构，通常是一个可以被看做一棵完全二叉树的数组对象。满足如下性质：

      • 堆中某个节点的值总是不大于或不小于其父节点的值。
      • 堆总是一棵完全二叉树。

    2. 堆的shift up：把向一个最大堆添加元素的操作，称为shift up。如下例子：

在这里插入图片描述

 * 首先交换索引5和11数组中数值的位置，即交换52和16。

在这里插入图片描述

 * 此时52依然比父节点大，继续交换。

在这里插入图片描述

 * 这时52比其父节点小了满足最大堆的定义。我们称这个过程为最大堆的shift up。
  1. 堆的shift down：从一个最大堆中取出一个元素称为shift down，只能取出根节点。

  • 思想：堆排序是指利用堆的数据结构设计的一种排序算法。堆积一个近似完全二叉树的结构，并满足堆积的性质：子结点的键值总小于（大于）它的父结点。堆有两种形态：

    1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列,arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
    2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列,arr[i] <= arr[2i+1] && arr[i]<= arr[2i+2]

  • 步骤：

    1. 构造初始堆，即将给定无序序列构造成一个大顶堆;

      1. 给定无序序列如下图：

        在这里插入图片描述

      2. 从最后一个非叶子节点开始（arr.length/2 - 1），也就是6开始，从左到右，从下至上进行调整。

在这里插入图片描述

 3. 找到第二个非叶子节点4，由于[4, 9, 8]中9最大，4和9交换。

在这里插入图片描述

  1. 这时，字根[4,5,6]结构混乱，继续调整，交换4和6。至此就构建成一个大顶堆了。（注：构建代码方法如下bulidMaxHeap）

  2. 把堆首和堆尾互换；

  3. 把堆的尺寸缩小1，并调用shift_down(0)；

  4. 重复步骤2，直到堆的尺寸为1.

  • 代码：

    public static void heapSort(int[] nums) {
    // 1. 构建大顶堆
    buildMaxHeap(nums);
    // 2. 交换堆首和堆尾,重新调整堆结构
    for (int i = nums.length - 1; i >= 0; i--) {
        swap(nums, 0, i);
        adjustHeap(nums, 0, i);
    }
}

/*
	构建大顶堆
*/
private static void buildMaxHeap(int[] nums) {
    if (nums == null || nums.length == 0) return;
    int len = nums.length;
    // 从最后一个非叶子节点开始依次往上调整
    for (int i = len / 2 - 1; i >= 0; i--) {
        // 调整堆
        adjustHeap(nums, i, len);
    }
}

/**
* 调整大顶堆:注意从传入参数节点往下都要判断调整，因为上面的变化有可能会改变大顶堆的结构
*/
private static void adjustHeap(int[] nums, int i, int len) {
    // 初始最大值为i位置的元素
    int largest = i;
    int left = 2 * i + 1, right = 2 * i + 2;
    // 更新largest为三个元素的最大值位置
    if (left < len && nums[left] > nums[largest]) largest = left;
    if (right < len && nums[right] > nums[largest]) largest = right;
    
    // 如果largest改变，则需要交换
    if (largest != i) {
        // 交换
        swap(nums, i, largest);
        // 递归判断下一层
        adjustHeap(nums, largest, len);
    }
}

public static void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

    // 调整堆的迭代版本
private static void adjustHeap(int[] nums, int i, int len) {
    // 取出i位置的元素
    int temp = nums[i];
    // 开始往下判断左右节点
    for (int k = i * 2 + 1, k < len; k = k * 2 + 1) {
        // 将k指向左右边的较大者
        if (k + 1 < len && nums[k] < nums[k + 1]) {
            k++;
        }
        // 判断k位置元素和temp的大小
        if (nums[k] > temp) {
            nums[i] = nums[k];
            i = k;
        } else {   // 已经符合大顶堆结构，结束
            break;
        }
    }
    // 把temp放入到最终位置
    nums[i] = temp;  
}
我的Coder小屋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#排序算法总结
09-18
C#排序算法总结涵盖了交换排序和插入排序两大类排序算法，其中交换排序包括了冒泡排序、选择排序和快速排序，而插入排序则涉及直接插入排序和折半插入排序。下面将详细介绍每种排序算法的实现原理、特点以及在C#中的...
排序问题
ZhbTy的博客
04-21 701
C语言里的排序问题： 一、冒泡排序 二、简单选择排序 三、快速排序 逻辑思想： 1、先选择一个数为基准数； 2、将比这个数小的数都放到它的左边，比它大的都放到右边，从而找到这个数在整个数列中的位置； 3、以这个数为分隔，将整个数列分成两部分，运用递归的思想将这两部分重复第二步骤； 实例分析： 1、假设数列为：5，8，1，3，4，7（红字为low和high分别指向的数字） 假设这
【排序算法】
mmy_669的博客
01-06 133
一.计数排序。
基本的排序算法
V_zjs的博客
05-20 767
算法思想：将相隔为d(d=n/2)的元素进行插入排序，然后d=d/2在进行插入排序，直到d=1。这样咋一看好像和之前的排序没啥区别，甚至更加繁琐，但本质是为了让原本无序的数组在一定范围内变得相对有序，这样移动元素时会减少移动的次数，从而减少时间复杂度，所以它的时间复杂度其实和数组的无序程度有关，数组越无序，时间复杂度越低，数组越有序，时间复杂度越高，在n^1.3~n^2之间代码如下d >= 1;d /= 2)//这里的排序要好好琢磨一下，是按照顺序每次将tmp和与它相隔d的倍数的元素进行排序。
五种排序算法
qq_34376587的博客
09-27 214
冒泡排序（BubbleSort） 比较相邻两个数据，如果第一个数大，就交换位置 从前向后两两比较，直到最大数到最后一位。 重复上述过程 平均时间复杂度：O（n^2） public static void BubbleSort(int [] arr){ int temp;//临时变量 for(int i=0; i<arr.length-1; i++){ //表示趟...
HTML实现有序排列和无序排列
monologuezjp的博客
05-29 9732
一、HTML实现有序排列 有序序列标签都是成组出现的 <ol> <li>这是一号</li> <li>这是2号</li> <li>可以有很多li标签</li> </ol> 在<ol>标签中，可以定义有序序列的样式。有序序列默认排列方式是数字序列，顺序排列。如下图...
常用排序算法总结
11-06
### 常用排序算法总结 #### 一、冒泡排序 冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，依次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复进行的，直到没有再需要...
Java排序算法总结
12-22
【Java排序算法总结】 在计算机科学中，排序算法是用于对数据进行排列的算法，而Java作为一种广泛应用的编程语言，提供了多种实现排序的方案。以下是对几种常见的Java排序算法的详细解析： 一、冒泡排序 冒泡排序...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
java-排序算法总结
最新发布
02-27
在编程领域，排序算法是计算机科学中的核心概念，特别是在Java这样的高级编程语言中。排序算法是用来组织和优化数据结构的关键工具，它可以帮助我们快速查找、分析和处理大量数据。本篇将深入探讨Java中实现的几种...
排序算法总结及习题2
08-08
本文主要总结了七种常见的排序算法：名次排序、冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，以及两种特殊情况下的排序方法——基数排序和箱子排序。 1. 名次排序（Ranking）： 名次排序是一种统计...
各种排序算法总结
01-24
常用排序算法总结，包括插入排序(InsertionSort)，冒泡排序(BubbleSort)，选择排序(SelectionSort)，快速排序（QuickSort)， * 二路归并排序(MergeSort)，堆排序(HeapSort)。有每一种排序算法的复杂度分析以及实现...
常见排序算法总结.pdf
03-28
【排序算法总结】 排序算法是计算机科学中处理数据排列的重要工具，主要分为稳定排序和非稳定排序、内排序和外排序两大类。稳定排序保证了相同元素在排序后的相对位置不变，而非稳定排序则不作此保证。内排序是指...
排序算法总结.pdf
03-30
【排序算法总结】 排序算法是计算机科学中一种重要的算法，主要任务是对一组数据进行排列，使其按照特定的顺序呈现。本文将重点介绍几种基础的排序算法，包括它们的工作原理、性能特点以及适用场景。 1、**稳定度*...
Java集合的有序、无序、排序性质讨论
热门推荐
Alex-zhai专栏
05-05 1万+
首先搞清楚有序、无序及排序性质的差别。 集合的有序、无序是指插入元素时，保持插入的顺序性，也就是先插入的元素优先放入集合的前面部分。 而排序是指插入元素后，集合中的元素是否自动排序。（例如升序排序）HashMap、 HashSet、 HashTable 等 基于哈希存储方式的集合是无序的。其它的集合都是有序的。而TreeMap TreeSet 等集合是排序的。
对无序数组进行排序
然并卵0808的博客
05-19 3387
/** * asc 升序 * desc 降序 */ public class BubbleSort { public static void main(String[] args) { int[] a = new int[]{3, 5, 1, 43, 44, 2, 21, 44, 55, 77, 88, 33}; BubbleSort(a,"asc...
对一组数据做无序排列（组合）的简单实现
weixin_33724570的博客
11-06 1069
2019独角兽企业重金招聘Python工程师标准>>> ...
希尔排序(c++)
weixin_30595035的博客
04-02 94
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。[1] 希尔排序是基于插入排序的以下两点性质...
数据结构详解：排序算法总结与复杂性分析
本资源是一份关于常用排序算法总结的PPT课件，主要涵盖了数据结构中的排序理论和实践。章节9详细介绍了排序的基本概念，包括排序的定义，即通过特定规则重新排列数据，使其满足非递减关系。排序被划分为稳定和不稳定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值