排序算法

最新推荐文章于 2021-03-02 07:33:53 发布
最新推荐文章于 2021-03-02 07:33:53 发布
阅读量290 收藏
点赞数
分类专栏： Java 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunrain62/article/details/69067936
版权

排序算法

排序算法

资料

面试中的 10 大排序算法总结

冒泡排序

  • 从后往前循环比较相邻两数，小数前大数后，一遍完成最小数即排在最前，最后循环排序

实现

public static void bubbleSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    int index = arr.length - 1;
    for (int i = 0; i < index; i++) {
        for (int j = index; j > i; j--) {  // 最小在最前
            if (arr[j] < arr[j - 1]) {  // 小在前大在后
                exchange(arr, j, j - 1);
            }
        }
    }
}

private static void exchange(int[] arr, int i, int j) {
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

简单选择排序

  • 从前向后循环排序，查找最小数互换位置

实现

public static void selectSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    int minIndex;
    int length = arr.length;
    for (int i = 0; i < length - 1; i++) {
        // 选择最小
        minIndex = i;
        for (int j = i + 1; j < length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        // 置最前
        if (minIndex != i) {
            exchange(arr, i, minIndex);
        }
    }
}

堆排序

  • 使用二叉堆的特性，调整为大顶堆，选择最大值出堆，最后循环调整大顶堆出堆

特性

  • 树是一对多的数据结构，从一个根结点开始，生长出它的子结点，而每一个子结点又生长出各自的子结点，成为子树。如果某个结点不再生长出子结点了，它就成为叶子。
  • 二叉树每个结点最多只有两棵子树，而且左右子树是有顺序的，不可颠倒。
  • 满二叉树的所有分支结点都既有左子树又有右子树，并且所有叶子都在同一层。
  • 完全二叉树不一定是满的，但它自上而下，自左而右来看的话，是连续没有缺失的。
  • 二叉堆是完全二叉树或者近似完全二叉树，父结点的值总是大于或等于(小于或等于)任何一个子节点的值。
  • 存储为一维数组，子i父(i-1)/2，父i子2i+1和2i+2
  • 入堆，末尾添加，尾元素比较上浮
  • 出堆，首尾互换，首元素比较下沉，尾元素出堆

实现

public static void heapSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    int length = arr.length;
    for (int i = length / 2 - 1; i >= 0; i--) {  // 从最后一个元素的父开始整理，建立大顶堆
        adjustMaxHeap(arr, i, length);
    }

    for (int i = length - 1; i > 0; i--) {  // 堆出队列，首尾互换，最大置尾，堆调整
        exchange(arr, 0, i);
        adjustMaxHeap(arr, 0, i);
    }
}

private static void adjustMaxHeap(int[] arr, int start, int end) {
    int temp = arr[start];

    int child = start * 2 + 1; // 左边子
    while (child < end) {
        if ((child + 1) < end && arr[child] < arr[child + 1]) {  // 两子节点比较选大
            child++; // 右边子
        }

        if (arr[child] <= temp) break; // 已是大顶堆

        // 否则父沉子浮
        arr[start] = arr[child];

        // 再循环调整
        start = child;
        child = start * 2 + 1;
    }
    arr[start] = temp;
}

直接插入排序

  • 分序列为左有序右无序，从第二个数开始向后循环，与有序序列循环比较大小确定位置插入

特性

  • 如果序列基本有序或者长度较小时，使用直接插入排序效率就非常高

实现

public static void insertSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    int insertNum;
    int length = arr.length;
    for (int i = 1; i < length; i++) {
        insertNum = arr[i]; // 无序序列第一个数，即需要插入的数
        int j = i - 1; // 有序序列最后位置
        while (j >= 0 && arr[j] > insertNum) {  // 大则后移
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = insertNum;
    }
}

二分插入排序

  • 分序列为左有序右无序，从第二个数开始向后循环，在有序序列中二分查找确定位置插入

实现

public static void binarySort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    int insertNum;
    int length = arr.length;
    for (int i = 1; i < length; i++) {
        insertNum = arr[i]; // 无序序列第一个数，即需要插入的数

        // 二分查找
        int left = 0; // 插入位置
        int right = i - 1; // 有序序列最后位置
        for (int middle; left <= right; ) {
            middle = left + (right - left) / 2;
            if (arr[middle] < insertNum) {
                left = middle + 1;
            } else if (arr[middle] > insertNum) {
                right = middle - 1;
            } else {
                left = middle + 1;
                break;
            }
        }

        // 批量后移
        for (int j = i - 1; j >= left; j--) {
            arr[j + 1] = arr[j];
        }

        arr[left] = insertNum;
    }
}

希尔排序

  • 增量分组，组内插入排序，然后增量二分缩减再插入排序，最后循环缩减增量至一

特性

  • 时间复杂度可以达到O(n^1.3)

实现

public static void shellSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    for (int step = arr.length / 2; step >= 1; step /= 2) {  // 增量分组
        for (int i = 0; i < step; i++) {  // 组内插入排序
            insertSort(arr, step);
        }
    }
}

private static void insertSort(int[] arr, int step) {
    int insertNum;
    int length = arr.length;
    for (int i = step; i < length; i += step) {
        insertNum = arr[i]; // 无序序列第一个数，即需要插入的数
        int j = i - step; // 有序序列最后一个数
        while (j >= 0 && arr[j] > insertNum) {  // 大则后移
            arr[j + step] = arr[j];
            j -= step;
        }
        arr[j + step] = insertNum;
    }
}

快速排序

  • 确定首数为基准数比较大小，从右往左循环小数换位，从左往右循环大数换位，循环至中间相遇位置置为基准数，最后以中间位置分左右两个序列递归

实现

public static void quickSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    quickSort(arr, 0, arr.length - 1);
}

private static void quickSort(int[] arr, int start, int end) {
    if (start >= end) return;

    int baseNumber = arr[start]; // 基准数
    int left = start, right = end;
    while (left < right) {
        while (left < right && arr[right] >= baseNumber) right--; // 右边寻找小与基准数
        if (left < right) arr[left++] = arr[right]; // 小数左移
        while (left < right && arr[left] <= baseNumber) left++; // 左边寻找大于基准数
        if (left < right) arr[right--] = arr[left]; // 大数右移
    }
    arr[left] = baseNumber; // 基准赋值

    // 分开递归
    quickSort(arr, start, left - 1);
    quickSort(arr, left + 1, end);
}

归并排序

  • 二分序列归并排序，最后比较大小合并

特性

  • 使用了递归分治的思想，先递归划分子问题，然后合并结果

实现

public static void mergeSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    mergeSort(arr, 0, arr.length - 1);
}

private static void mergeSort(int[] arr, int start, int end) {
    if (start >= end) return;

    // 二分递归
    int middle = (start + end) / 2;
    mergeSort(arr, start, middle);
    mergeSort(arr, middle + 1, end);

    merge(arr, start, middle, end); // 合并
}

private static void merge(int[] arr, int start, int middle, int end) {
    int left = start, right = middle + 1;
    int length = end - start + 1;
    int[] temp = new int[length]; // 临时数组

    // 存入临时数组
    int index = 0;
    while (left <= middle && right <= end) {  // 左右两数组比较，小的存入
        temp[index++] = arr[left] <= arr[right] ? arr[left++] : arr[right++];
    }
    // 剩下的存入临时数组
    while (left <= middle) {
        temp[index++] = arr[left++];
    }
    while (right <= end) {
        temp[index++] = arr[right++];
    }

    // 还原
    for (int i = 0; i < length; i++) {
        arr[start + i] = temp[i];
    }
}

计数排序

  • 序列的值作为计数数组的下标，统计每个数字的个数，最后依次输出计数数组的下标

特性

  • 待排序的数要满足一定的范围的正整数
  • 计数排序需要比较多的辅助空间
  • 时间复杂度为O(n)

实现

public static void countSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    // 以值为脚标建立计数数组
    int max = 0;
    for (int item : arr) {
        if (item > max) max = item;
    }

    // 映射分配，排序
    int[] count = new int[max + 1];
    Arrays.fill(count, 0);
    for (int i : arr) {
        count[i]++;
    }

    // 还原
    int index = 0;
    for (int i = 0; i <= max; i++) {
        for (int j = 0; j < count[i]; j++) {
            arr[index++] = i;
        }
    }

}

桶排序

  • 序列分别映射至有序的桶，桶内排序，最后依次输出

特性

  • 映射函数：关键字k1 < k2，那么f(k1) <= f(k2)，即桶(i)最大的数小于桶(i+1)中最小的数
  • 桶越多，桶内需排序的数则越少，单占用空间越大

实现

public static void bucketSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    // 创建桶，使用链表
    int bucketNumber = 10;
    List<List<Integer>> buckets = new ArrayList<>();
    for (int i = 0; i < bucketNumber; i++) {
        buckets.add(new LinkedList<Integer>());
    }

    // 映射分配
    int index;
    for (int item : arr) {
        index = item / bucketNumber; // 映射关系
        buckets.get(index).add(item);
    }

    // 排序，还原
    index = 0;
    for (List<Integer> bucket : buckets) {
        if (!bucket.isEmpty()) {
            Collections.sort(bucket); // 桶内排序
            for (Integer integer : bucket) {
                arr[index++] = integer; // 还原
            }
        }
    }
}

基数排序

  • 序列按最大位数分趟，按进制分桶，按位的值映射至桶，再依次输出，最后趟循环

特性

  • 多关键字分成多趟单关键字，单关键字排序，最后趟循环

实现

public static void radixSort(int[] arr) {
    if (arr == null || arr.length == 0) return;

    // 确定趟数，趟数为最大位数
    int max = 0;
    for (int item : arr) {
        int length = Integer.toString(item).length();
        if (length > max) max = length;
    }

    // 创建桶，桶数为进制数
    int bucketNumber = 10;
    List<List<Integer>> buckets = new ArrayList<>();
    for (int i = 0; i < bucketNumber; i++) {
        buckets.add(new LinkedList<Integer>());
    }

    // 按趟排序
    int index;
    for (int i = 0; i < max; i++) {
        // 映射分配，排序
        for (int item : arr) {
            // 映射关系，按位获取
            String s = Integer.toString(item);
            index = 0;
            if (s.length() > i) {
                index = s.charAt(s.length() - i - 1) - '0';
            }

            buckets.get(index).add(item);
        }

        // 还原
        index = 0;
        for (List<Integer> bucket : buckets) {
            if (!bucket.isEmpty()) {
                for (Integer integer : bucket) {
                    arr[index++] = integer;
                }
            }
            bucket.clear();
        }
    }
}
雨林15
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
子数组合并算法之向右循环
基督山伯爵的博客
03-20 1089
今天的算法课上,老师出了一道题：对两个已排好序的子序列，试设计一个合并算法使得算法的时间复杂度在最极端的情况下都小于等于O（n）,可借助1个空间复杂度。 上网搜了半天，发现解决这个问题有两种基本的方式，一种是本文要讨论的向右循环，另一种我还没有看，等有时间了在补上。        算法的基本思想： 假设的两个子数组是a[0:k-1]和a[k:n]. step1:取前一个数组的第一位，使用二
合并两个有序数组_向右循环移位
胡杨
06-05 3474
设子数组a[0:k-1]和a[k,]
合并两个有序子数组
田野中的锋芒
04-11 2080
设子数组a[0:k-1]和a[k,n-1]已经排好序(0&lt;=k&lt;=n-1).设计一个合并这两个子数组的排序好的数组a[0:n-1]的算法。要求算法最坏情况下所用的计算时间为O(n)，且只用到O(1)的辅助空间。分析解答此题可以用向右(左)循环换位合并的思想，先用二分搜索查找a[0]在数组a[k:n-1]中的位置p使得a[p]&lt;a[0]&lt;=a[p+1].然后数组a[0:p]向...
java循环换位合并算法_用java实现换位法生成全排列
weixin_30369779的博客
03-02 318
import java.util.ArrayList;import java.io.*;//换位法生成全排列class ReplaceArrangement{//从控制台读入数据private static String readDataFromConsole(String prompt) {BufferedReader br = new BufferedReader(new InputStrea...
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
最新发布
01-15
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其在数据处理和算法设计中扮演着核心角色。本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡...
最快的排序算法 最快的内部排序法—桶排序法，排序算法数据结构
04-07
最快的排序算法 最快的内部排序法—桶排序法，排序算法数据结构
常见经典排序算法（C语言）1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排序 堆排序.docx
05-07
常见的经典排序算法有希尔排序、二分插入法、直接插入法、带哨兵的直接排序法、冒泡排序、选择排序、快速排序、堆排序等。 一、希尔排序（Shell 排序法） 希尔排序法，又称宿小增量排序，是 1959 年由 D.L.Shell ...
最快的排序算法 最快的内部排序法—桶排序法 (1)，排序算法数据结构
04-07
最快的排序算法 最快的内部排序法—桶排序法 (1)，排序算法数据结构
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
冒泡排序法+输入输出数组
10-31
上次的改进，审核求过.
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
数组循环移位算法（左旋字符串）【总结】
weixin_30644369的博客
10-09 182
问题：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。如把字符串abcdef左旋转2位得到字符串cdefab。请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 解法一：（循环换位算法）不考虑时间和空间的限制。设移动的位数为k。则循环k次，每次移动1位。这样的空间复杂度是O(1)，时间复杂度是O(n*k)。如果k小于n，则O(n^...
归并排序汇总
码农也有梦
03-29 718
1.具体原理就不过多介绍了，先把C++程序设计上面的代码放上来 #include using namespace std; void arraycopy(int source[], int sourceStartIndex, int target[], int targetStartIndex, int length); void merge(int list1[], int list1Le
java循环换位合并算法_如何在minimax算法中实现换位表?
weixin_31642161的博客
03-02 126
我目前正在制作一个简单的象棋引擎,问题是即使使用一个简单的求值函数,纵观深度为2,引擎也需要大约15秒的时间才能做出动作。我想通过使用换位表来提高引擎的性能,所以我尝试自己实现一个换位表,但在性能上没有任何提高。我的实现可能有什么问题,我该如何解决?function alphaBeta(node, depth, alpha, beta, maximisingPlayer){if(depth ===...
通过队列循环换位
qq_41947857的博客
06-05 394
function Queue() { this.dataStore = []; this.enqueue = enqueue; this.dequeue = dequeue; this.front = front; this.back = back; this.toString = toString; this.empty = empty;...
数据排序算法详解：选择排序法
选择排序是一种简单直观的排序算法，它的基本思想是在未排序的序列中找到最小（或最大）的元素，放到序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（或最大）的元素，然后放到已排序序列的末尾，以此类推...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值