常用的排序

最新推荐文章于 2024-07-24 12:10:43 发布
最新推荐文章于 2024-07-24 12:10:43 发布
阅读量290 收藏 1
点赞数 1
分类专栏： 数据结构 java 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44518702/article/details/119917962
版权

常用的排序

1.插入排序

（类似插入扑克牌）

在这里插入图片描述

在这里插入图片描述

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 {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

时间复杂度 最好O(n) 平均O(N^2) 最坏O（N^2） 空间复杂度O(1) 稳定

越有序越快

2.折半插入排序

在一个有序的序列中，找到新元素在该序列中的位置，然后插入。如图1所示，共有n个元素，前i个元素已经是有序序列，现在要将第i个元素插入其中。折半插入排序需要做两步工作：找到待插入元素的位置、插入。

public class ZheBanInsertSort {
    private static void zheBanInsert(int[] arr) {
        for (int i=1;i<arr.length;i++){
            int temp = arr[i];
            // 用折半查找法去查找
            int low = 0;
            int high = i-1;
            while (low<=high){
                int mid = (low+high)/2;
                if (arr[mid]>temp){
                    high = mid - 1;
                }else {
                    low = mid + 1;
                }
            }
            // 确定最后的位置为low或者high+1
            for (int j=i-1;j>=low;j--){
                arr[j+1] = arr[j];
            }
            // 赋值
            arr[low] = temp;
        }
        System.out.println("折半插入排序："+Arrays.toString(arr));

3.希尔排序

分组的思想 ：每组进行直接插入法 最后整体有序

时间复杂度最好 O(N) 平均O(n^1.5) 最坏O(n^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 {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }
public static void shellSort(int[] array) {
        int[] drr = {5,3,1};
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
    }

在这里插入图片描述

4.选择排序

它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
在这里插入图片描述

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

时间复杂度O(N^2) 空间复杂度O(1) 不稳定

在这里插入图片描述

双向排序 每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完

public static void selectSortOP(int []array){
  int low = 0;
    int high = array.length - 1;
    // [low, high] 表示整个无序区间
    // 无序区间内只有一个数也可以停止排序了
    while (low <= high) {
        int min = low;
        int max = low;
        for (int i = low + 1; i <= max; i++) {
            if (array[i] < array[min]) {
                min = i;
           }
            if (array[i] > array[max]) {
                max = i;
           }
       }
        swap(array, min, low);
        // 见下面例子讲解
        if (max == low) {
            max = min;
       }
        swap(array, max, high);
   }
}
private void swap(int[] array, int i, int j) {
    int t = array[i];
    array[i] = array[j];
    array[j] = t;
}

5.堆排序

在这里插入图片描述

 public static void adjust(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]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

    public static void createHeap(int[] array) {
        //p 是每颗子树的根节点
        for (int p = (array.length-1-1)/2; p >= 0; p--) {
            adjust(array,p,array.length);
        }
    }

    public static void heapSort(int[] array) {
        //1.大堆  -> O(n)
        createHeap(array);
        //2、排序-》n*logn
        int end = array.length-1;
        while (end > 0) {
            int tmp = array[0];
            array[0] = array[end];
            array[end] = tmp;
            adjust(array,0,end);
            end--;
        }
    }

时间复杂度：n*logn 空间复杂度：O(1) 稳定性：不稳定

6.冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
在这里插入图片描述
在这里插入图片描述

 public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            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;
                }
            }
        }
    }

时间复杂性 O（N^2） 空间复杂O(1) 稳定

优化

 public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            boolen flag=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;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
    }

7.快速排序

在这里插入图片描述

 public static int partion(int[] array,int start,int end) {
     
        int tmp = array[start];
        while (start < end) {
            while (start < end && array[end] >= tmp) {
                end--;
            }
            if(start >= end) {
                array[start] = tmp;
                break;
            }else {
                array[start] = array[end];
            }
            while (start < end && array[start] <= tmp) {
                start++;
            }
            if(start >= end) {
                array[start] = tmp;
                break;
            }else {
                array[end] = array[start];
            }
        }
        return start;
    }
    public static void quick(int[] array,int low,int high) {
        if(low >= high) {
            return;
        }
        int par = partion(array,low,high);
        quick(array,low,par-1);
        quick(array,par+1,high);
    }
    public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }

在这里插入图片描述

时间复杂度：Nlog2N 最坏N^2 空间复杂度 最好 logN 最坏O（N） 不稳定

三数取中

public static int partion(int[] array,int start,int end) {
        int tmp = array[start];
        while (start < end) {
            while (start < end && array[end] >= tmp) {
                end--;
            }
            if(start >= end) {
                array[start] = tmp;
                break;
            }else {
                array[start] = array[end];
            }
            while (start < end && array[start] <= tmp) {
                start++;
            }
            if(start >= end) {
                array[start] = tmp;
                break;
            }else {
                array[end] = array[start];
            }
        }
        return start;
    }
public static void medianOfThree(int[] array,int start,int mid,int end) {

        //array[mid] <= array[start] <= array[end]
        if(array[start] < array[mid]) {
            int tmp = array[start];
            array[start] = array[mid];
            array[mid] = tmp;
        }// array[mid] <= array[start]

        if(array[start] > array[end]) {
            int tmp = array[start];
            array[start] = array[end];
            array[end] = tmp;
        }//array[start] <= array[end]

        if(array[mid] > array[end]) {
            int tmp = array[mid];
            array[start] = array[end];
            array[mid] = tmp;
        }//array[mid] <= array[end]
    }

    public static void insertSort2(int[] array,int start,int end) {
        for (int i = start; 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;
        }
    }

    public static void quick(int[] array,int low,int high) {
        if(low >= high) {
            return;
        }
        //优化2、直接插入排序
        if(high-low+1 < 100) {
            insertSort2(array,low,high);
            return;
        }
        //优化1、三数取中
        int mid = (low+high)>>>1;
        medianOfThree(array,low,mid,high);
        int par = partion(array,low,high);
        quick(array,low,par-1);
        quick(array,par+1,high);
    }

非递归快速排序

public static void quickSort(int[] array) {
        //quick(array,0,array.length-1);
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int high = array.length-1;
        int par = partion(array,low,high);
        //1、分别判断 左右两边是否有两个元素以上，包含两个元素
        //左边有2个元素以上
        if(par > low+1) {
            //入栈：
            stack.push(low);
            stack.push(par-1);
        }
        //右边有2个元素以上
        if(par < high-1) {
            stack.push(par+1);
            stack.push(high);
        }
        while (!stack.empty()) {
            high = stack.pop();
            low = stack.pop();
            par = partion(array,low,high);
            if(par > low+1) {
                //入栈：
                stack.push(low);
                stack.push(par-1);
            }
            //右边有2个元素以上
            if(par < high-1) {
                stack.push(par+1);
                stack.push(high);
            }
        }
    }

8.归并排序

在这里插入图片描述
在这里插入图片描述

public static void merge1(int[] array,int low,int mid,int high) {
        int[] tmpArr = new int[high-low+1];
        int k = 0;// 数组下标
        int s1 = low;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = high;
        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }

        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }

        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }

        for (int i = 0; i < tmpArr.length; i++) {
            array[i+low] = tmpArr[i];
        }

    }

    public static void mergeSortRec(int[] array,int low,int high) {
        if(low >= high) {
            return;
        }
        int mid = (high+low) / 2;
        mergeSortRec(array,low,mid);
        mergeSortRec(array,mid+1,high);
        merge1(array,low,mid,high);
    }

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



    public static void merge(int[] array,int gap) {
        int[] tmpArr = new int[array.length];
        int k = 0;
        int s1 = 0;
        int e1 = s1+gap-1;
        int s2 = e1+1;
        int e2 = s2+gap-1 >= array.length ? array.length-1 : s2+gap-1;
        while (s2 < array.length) {
            //两个归并段都有数据
            while (s1 <= e1 && s2 <= e2) {
                if(array[s1] <= array[s2]) {
                    tmpArr[k++] = array[s1++];
                }else {
                    tmpArr[k++] = array[s2++];
                }
            }
            while (s1 <= e1) {
                tmpArr[k++] = array[s1++];
            }
            while (s2 <= e2) {
                tmpArr[k++] = array[s2++];
            }
            s1 = e2+1;
            e1 = s1+gap-1;
            s2 = e1+1;
            e2 = s2+gap-1 >= array.length ? array.length-1 : s2+gap-1;
        }

        while (s1 <= array.length-1) {
            tmpArr[k++] = array[s1++];
        }
        for (int i = 0; i < tmpArr.length; i++) {
            array[i] = tmpArr[i];
        }
    }

    public static void mergeSort(int[] array) {

        for (int gap = 1; gap < array.length; gap *= 2) {
            merge(array,gap);
        }

    }

​ 时间复杂度： O(n*logn)
​ 空间复杂度： O(n)
​ 稳定性：稳定
​ 堆排 快排 归并 O(Nlog2n)

海量数据排序 ：将分成小文件 进行排序 之后进行归并

非比较排序

基数排序：

在这里插入图片描述

​ 计数排序

  • 找出待排序的数组中最大和最小的元素；
  • 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  • 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  • 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

在这里插入图片描述

桶排序

  • 设置一个定量的数组当作空桶；
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • 对每个不是空的桶进行排序；
  • 从不是空的桶里把排好序的数据拼接起来。

在这里插入图片描述

总结

在这里插入图片描述

力争做大牛的小王
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
常用排序算法C语言实现
03-10
本资源"常用排序算法C语言实现"提供了一个实践平台，帮助学习者将理论知识转化为实际代码。 首先，让我们探讨几种常见的排序算法及其C语言实现： 1. **冒泡排序（Bubble Sort）**：冒泡排序是最基础的排序方法，...
常用十大排序算法
热门推荐
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
八大常用排序
weixin_58867976的博客
02-09 1万+
目录 前言 一、插入排序 二、希尔排序 三、选择排序 四、堆排序 五、冒泡排序 六、快速排序 七、归并排序 八、计数排序 前言 此篇博客都是以升序为例，降序只需更改部分地方即可，所以只排一个 一、插入排序 单趟排序 如上图，在一个有序数组中插入一个6，只要找到比6小的数，此数后面的数往后挪动，然后在其后插入6即可 整个插入排序 外面只需套一层循环即可，为了保证不越界，所以i最多只能是倒数第二个元素的下标 如上图，起初可将第一个数看成是有序的，第二个数..
常用排序算法总结和对比
qq_45974648的博客
03-02 2459
文章目录1、常用排序算法总结和对比2、算法的时间复杂度3、算法的空间复杂度 1、常用排序算法总结和对比 排序算法 平均时间复杂度 最好情况 最坏情况 空间复杂度 排序方式 稳定性 冒泡排序 O(n²) O(n) O(n²) O(1) In-place 稳定 简单选择 O(n²) O(n²) O(n²) O(1) In-place 不稳定 直接插入 O(n²) O(n) O(n²) O(1) In-place 稳定 希尔排序 O(nlogn) O(nlog²n) O(nlog²n)
c语言的5种常用排序方法
sanguine_boy的博客
03-09 2万+
c语言的5种常用排序算法 1、冒泡排序（最常用） 冒泡排序是最简单的排序方法：原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。（注意每一轮都是从a[0]开始比较的） 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实...
详解Java常用排序算法（10种，含演示动画）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 2万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
常用排序
wiscourper的博客
04-03 8770
排序算法经过了很长时间的演变，产生了很多种不同的方法。对于初学者来说，对它们进行整理便于理解记忆显得很重要。每种算法都有它特定的使用场合，很难通用。因此，我们很有必要对所有常见的排序算法进行归纳。 排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。 内排序有可以分为以下几类： 　　(...
JS实现各种常用排序
果冻
02-23 5013
一、插入排序 插入排序有直接插入排序，折半插入排序，希尔排序，这里只实现常用的直接插入排序 直接插入排序 思想 将左侧序列看成一个有序序列，每次将一个数字插入该有序序列。 插入时，从有序序列最右侧开始比较，若比较的数较大，后移一位。 function insertSort(array) { //第一个默认已经排好 for (let i = 1; i < array.length; i++) { let target = i; for (..
9种常用排序算法总结（超详细）
qq_39471489的博客
07-12 1万+
以int型数据为例，且0号下标数组用来做为交换辅助空间，数据从1号下标开始存储 一、插入排序 基本思想：每一趟将一个待排序的记录，按其关键字的大小插入到已经排好序的一组记录的适当位置上，直到全部待排序记录全部插入为止。 直接插入排序 排序过程： 1、将待排序数组arr[1…n]看作两个集合，arr[1]为有序集合中元素，arr[2…n]为无序集合中元素，a[0]用来临时存放当前待排序记录 2、外层循环每次从无序集合中选择一个待插入元素(n-1次)，每次使用顺序查找法，内层循环查找arr[i]在有序集合中的.
C语言常用排序方法
m0_73685411的博客
12-08 6388
C语言常用的几种排序方法
【面试算法题】十种常用排序算法详解
indeedes的博客
04-04 5431
排序算法的稳定性： 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，如果排序以后，保证这些记录的相对次序保持不变，即在原序列中，a[i]=a[j]，且 a[i] 在 a[j] 之前，排序后保证 a[i] 仍在 a[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。 一.选择排序 每次从待排序的元素中选择最小的元素，依次和第1、2、3...位置的元素进行交换。这样在数组前面的部分形成有序区域。每进行一次交换，有序区域长度加一。 public static ...
常用排序算法
01-28
常用排序算法 在计算机科学中，排序算法是最基本也是最重要的一种算法。排序算法可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。内...
js常用排序实现代码
10-28
以下是一些常见的JavaScript排序算法的实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序以及归并排序。 1. **冒泡排序（Bubble Sort）**： 冒泡排序是一种简单但效率较低的排序算法。它通过重复遍历...
常用排序算法源码
05-22
这里我们主要探讨五种常见的排序算法，这些算法的源码你可以在提供的压缩包文件中找到：MergeSort（归并排序）、RadixSort（基数排序）、InsertionSort（插入排序）、SwapSort（可能是冒泡排序或快速排序的误称）...
STL——常用排序算法
weixin_74207910的博客
07-24 355
2.random_shuffle()//随机打乱顺序。4.reverse()//反转。
使用 React 和 Redux 进行井字游戏并附带源代码.zip
最新发布
07-24
项目：使用 React 和 Redux 进行井字游戏并附带源代码 使用 react 和 redux 的井字游戏是一个简单的 react 项目。整个项目都是使用 react components 和redux制作的。游戏很简单，玩法也很多。要运行此项目，您必须先安装 NodeJS。 关于项目 井字游戏反应而 redux 是使用ReactJS开发的。说到这个游戏，它具有高级功能和游戏玩法。要运行此项目，首先，您必须安装费用到您的系统。然后运行npm安装然后开始运行npm开始。游戏启动后，您可以选择不同的游戏选项。您还可以选择所需的网格框数量。此外，您还可以选择对手的类型。 要运行此项目，您需要 在计算机上安装NodeJS 并使用现代浏览器，例如 Google Chrome、  Mozilla Firefox。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
使用 JavaScript 编写的专注力游戏（附源代码）.zip
07-24
项目：JavaScript 中的专注力游戏（附源代码） 专注力游戏是一个使用 JavaScript、CSS 和 HTML 开发的简单项目。这款游戏很有趣。玩家必须点击移动的框并获得分数。要点击正确的位置，玩家需要在这个游戏中集中注意力。这款游戏可以帮助玩家练习以进一步增强他们的专注力。 游戏制作 这个游戏项目仅使用 HTML、CSS 和 JavaScript。说到这个游戏的特点，用户必须单击移动框并得分。游戏有三种模式：简单、中等和困难。游戏的 PC 控制非常简单。您只需使用光标单击移动框的碎片即可。 该游戏包含大量的 javascript 以确保游戏正常运行。 如何运行该项目？ 要运行此游戏，您不需要任何类型的本地服务器，但需要浏览器。我们建议您使用现代浏览器，如 Google Chrome 和 Mozilla Firefox。要玩游戏，首先，单击 index.html 文件在浏览器中打开游戏。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
人脸识别方案资料61EDA-C1590.zip
07-24
人脸识别方案资料61EDA_C1590.zip
Python常用排序和搜索算法总结
常用算法(python)包括很多种排序和搜索算法，比如冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、基数排序、桶排序、深度优先搜索、广度优先搜索、二分查找、线性查找、素字符串...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

力争做大牛的小王

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

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

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

打赏作者

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

抵扣说明：

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

余额充值