【数据结构（java）】---七大经典排序

最新推荐文章于 2024-07-25 17:45:03 发布
最新推荐文章于 2024-07-25 17:45:03 发布
阅读量1.1k 收藏 39
点赞数 14
分类专栏： 数据结构 JAVA 文章标签： 数据结构 java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41098429/article/details/120874279
版权

引言

排序算法是数据结构中最基本的算法之一，在现实生活中应用也非常广泛。常见的排序算法：
在这里插入图片描述

注：

1)本文所有代码的测试用例为

public static void main(String[] args) {
        int[] array = {2,9,7,4,1,8,0,5,4,6};
        System.out.println(Arrays.toString(array));
        //排序算法

        System.out.println(Arrays.toString(array));
    }

2)本文实现的均为升序
3）本文的交换函数

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

4）测试优化程度代码

public static void main(String[] args) {
        long  start = System.currentTimeMillis();
        Random random = new Random(10_0000);
        int[] array = new int[10_0000];
        //数组为有序数组
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        // 数组为无序数组
//        for (int i = 0; i < array.length; i++) {
//            array[i] = random.nextInt();
//        }
        //排序算法
        
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

插入排序

直接插入排序

插入排序是一种简单直观对的排序算法，打过扑克牌的同学应该都能秒懂，他的工作原理是先构建有序的序列，对未排序的数据，在已排序的序列中从后向前扫描，找到相应的位置并插入。
1） 算法步骤
首先将待排序的第一个序列的第一个元素看成有序序列，让后把第二个元素当成是未排序序列。从头到尾一次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（当待排序的元素的与有序序列中的某个元素相等，则将待排序的元素插入到相等元素的后面）
2） 动图演示
请添加图片描述
3） 代码实现

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

4）总结

时间复杂度平均为O（n^2）,最坏为O（n ^2),最好（当序列为有序时）为O（n）
空间复杂度为O(1)，
稳定性：稳定。

希尔排序

希尔排序（Shell Sort），是插入排序的一种改进版，但是希尔排序是非稳定的排序。
希尔排序的基本思想是：先将整个待排序的循序分成若干个子序列分别进行直接插入排序，待整个序列的趋于有序时在进行直接插入排序。
1）算法步骤
选择一个增量gap,根据间隔gap进行分组，对每组进行直接插入排序，然后通过gap /= 2;来改变分组的距离，在分别对每组进行直接插入排序，知道gap=1,是就是对整个序列进行插入排序。（当序列趋于有序时直接插入排序越快）
2）动图演示
请添加图片描述
3）代码实现

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 -= gap) {
                if (tmp < array[j]){
                    array[j + gap] = array[j];
                }else {
                    break;
                }
            }
            array[j + gap] = tmp;
        }
    }
    public static void shellSort(int[] array){
        int gap = array.length;
        while (gap > 1){
            gap /= 2;
            shell(array,gap);
        }
    }

4）总结

时间复杂度：O（n^1.3 - n ^1.5）
空间复杂度为：O（1）
稳定性：不稳定

选择排序

选择排序

选择排序是一种简单直观的排序算法，无论什么数据的时间复杂度都为O（n^2）。
1）算法步骤
第一步，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。第二步，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。
2）动图演示
请添加图片描述
3)代码实现

public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int min = i;
            for (int j = i ; j < array.length; j++) {
                if (array[j] < array[min]){
                    min = j;
                }
            }
            swap(array,i,min);
        }
    }

4）总结

时间复杂度：O（n^2）
空间复杂度：O（1）
稳定性：不稳定

堆排序

堆排序，是利用堆这种数据结构所设计的一种排序算法。堆是一个近似的完全二叉树的结构。并且都满足堆积的性质：即子节点的值总是小于或大于父节点的值。

大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序中用于升序排列。
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序中用于降序排列。

1）算法步骤
1.先创建一个大堆。
2.交换堆顶与堆尾的值；
3.删除堆尾，并使用向下调整算法，将堆调整为大堆。
4.重复步骤2，知道只剩下堆顶元素。
2）动图演示
请添加图片描述
3）代码实现

public static void heapSort(int[] array){
        //将大堆
        creatBigHeap(array);
        //交换堆顶与堆尾的位置
        for (int i = array.length - 1; i > 0 ; i--) {
            swap(array,0, i);
            //交换之后，再次调整为大堆
            shiftDown(array,0,i);
        }
    }
    //由于是升序建大堆
    private static void creatBigHeap(int[] array) {
        for (int parent = (array.length - 1) / 2; parent >= 0 ; parent--) {
            shiftDown(array,parent, array.length - 1);
        }
    }
//向下调整算法
    private 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;
            }
        }
    }

4）总结

时间复杂度：为O（nlogn）
空间复杂度：O（1）
稳定性：不稳定

交换排序

冒泡排序

冒泡排序也是一种简单直观的排序算法。它重复地走访过要排序的序列，一次比较相邻的两个元素，如果前一个元素大于后一个元素的值，就交换这两个元素的值。从第一对比较到最后一对知道所以元素有序。

1）算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作相同的工作，从开始第一对到结尾的最后一对。这步完成之后，最后的元素就是序列中的最大值。针对所有的元素重复以上的步骤，除了最后一个。直到序列有序。

2）动图演示
请添加图片描述
3）代码实现

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

4）算法优化
设置一个flag = false，若在一趟排序之后元素没有发生交换，说明该序列已经有序，不需要在进行排序。

public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length; i++) {
        	boolean flag = false;
            for (int j = 1; j < array.length - i ; j++) {
                if (array[j - 1] > array[j]){
                    swap(array,j - 1, j);
                    flag = true;
                }
            }
            if(flag == false){
            	break;
            }
        }
    }

5)总结

时间复杂度：O（n^2）
空间复杂度：O（1）
稳定性：稳定

快速排序

快速排序是一种分而治之的思想，效率高，是处理大数据最快的排序算法之一了。

1）算法步骤
1.从序列中挑选一个元素作为基准（pivot）；
2.重新排序序列，所有元素比基准值小的放在基准的前面，所有元素比基准值大的摆在基准的后面。
3.递归地吧小于基准元素的子序列和大于基准值元素的子序列进行排序。

2）动图演示
请添加图片描述
3）代码实现
挖坑法：

public static void quickSort(int[] array,int left,int right){

        if (left >= right){
            return;
        }

        int piovt = partition(array,left,right);
        quickSort(array,left,piovt - 1);
        quickSort(array,piovt + 1, right);
    }

    private static int partition(int[] array, int left, int right) {
        int tmp = array[left];
        while (left < right){
            while (array[right] >= tmp && left < right){
                right--;
            }
            array[left] = array[right];
            while (array[left] <= tmp && left < right){
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

hoare法

private static int partition1(int[] array, int left, int right) {
        int tmp = array[left];
        int start = left;
        while (left < right){
            while (array[right] >= tmp && left < right){
                right--;
            }
            while (array[left] <= tmp && left < right){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,start,right);
        return right;
    }

4)算法优化
1）当每次选的基准是最大值或者最小值时，快排的效率就会降低，因此为了避免这种情况的出现，采用三数取中的方法来优化：选取left与right与他们的中值mid坐标中中间的那个值作为基准就可以避免基准是最大值或者最小值的情况。
代码实现：

public static void medianOfThree(int[] array,int left,int right){
        int mid = (left + right) / 2;

        if (array[mid] >array[left]){
            swap(array,mid,left);
        }// array[mid] <= array[left];

        if (array[right] < array[left]){
            swap(array,left,right);
        }// array[left] <= array[right];

        if (array[left] < array[mid]){
            swap(array,mid,left);
        }//保证了左边的数值为三个数的中间值
    }

2）当序列趋于有序时快排花费的时间会比较长，所以当递归到一定区域时采用插入排序来进行优化。

public static void quickSort(int[] array,int left,int right){

        if (left >= right){
            return;
        }

        if (right - left < 100){
            insertSort1(array,left,right);
        }
//        medianOfThree(array,left,right);
        int piovt = partition(array,left,right);
        quickSort(array,left,piovt - 1);
        quickSort(array,piovt + 1, right);
    }

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

    private static int partition(int[] array, int left, int right) {
        int tmp = array[left];
        while (left < right){
            while (array[right] >= tmp && left < right){
                right--;
            }
            array[left] = array[right];
            while (array[left] <= tmp && left < right){
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

5）非递归实现快速排序

public static void quickSortNor(int[] array){
        Stack<Integer> stack = new Stack<>();
        stack.push(array.length - 1);
        stack.push(0);
        while (!stack.isEmpty()){
            int left = stack.pop();
            int right = stack.pop();
            if (left >= right){
                continue;
            }

            int pivot = partition(array,left,right);
            stack.push(pivot - 1);
            stack.push(left);
            stack.push(right);
            stack.push(pivot + 1);
        }
    }

6）总结

时间复杂度为：O（nlogn）
空间复杂度为：O（logn）
稳定性：不稳定

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的典型应用。
1)算法步骤
将序列的n个元素分成长度为1的子序列，让在两两合并为有序的序列，知道所有的序列有序。请添加图片描述
2）动图演示
请添加图片描述
3）代码实现

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

    private static void mergeSortInternal2(int[] array, int left, int right) {
        if (left>=right){
            return;
        }
        int mid = (left + right) / 2;
        //分为长度为1的区间
        mergeSortInternal2(array,left,mid);
        mergeSortInternal2(array,mid + 1, right);

        int[] tmp = new int[right - left + 1];
        int k = 0;
        int s1 = left;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = right;
        // 合并
        while (s1 <= e1 && s2 <= e2){
            if (array[s1] < array[s2]){
                tmp[k++] = array[s1++];
            }else {
                tmp[k++] = array[s2++];
            }
        }

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

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

        for (int i = 0; i < k; i++) {
            array[left + i] = tmp[i];
        }
    }

4）非递归实现

public static void mergeSortNor(int[] array){
        int gap = 1;
        for (int i = gap; i < array.length; i *= 2) {
            merge2(array,i);
        }
    }

    private static void merge2(int[] array, int gap) {

        int s1 = 0;
        int e1 = s1 + gap - 1;
        int s2 = e1 + 1;
        int e2 = (s2 + gap - 1 >= array.length - 1)? (array.length - 1) : (s2 + gap - 1);
        int[] tmp = new int[array.length];
        int k = 0;
        //当有两个子序列时
        while (s2 < array.length){
            while (s1 <= e1 && s2 <= e2){
                if (array[s1] < array[s2]){
                    tmp[k++] = array[s1++];
                }else {
                    tmp[k++] = array[s2++];
                }
            }

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

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

            s1 = e2 + 1;
            e1 = s1 + gap - 1;
            s2 = e1 + 1;
            e2 = (s2 + gap - 1 >= array.length - 1)? (array.length - 1) : (s2 + gap - 1);
        }
        //当只有一个序列时
        while (s1 <= array.length - 1){
            tmp[k++] = array[s1++];
        }

        for (int i = 0; i < k; i++) {
            array[i] = tmp[i];
        }

    }

5）总结
时间复杂度：O(nlogn)
空间复杂度：O（n）
稳定性：稳定

总结

在这里插入图片描述

八只脚抠脚
关注
  • 14
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
【数据结构】常见七大排序总结
四季轮换叶，一路招摇胜
10-23 6720
常见七大排序概念算法总结
Java 数据结构篇-深入了解排序算法（动态图 + 实现七种基本排序算法）
小扳手
01-28 7651
1.0 冒泡排序的实现 + 动态演示图 2.0 选择排序的实现 + 动态演示图 3.0 堆排序的实现 + 动态演示图 4.0 插入排序的实现 + 动态演示图 5.0 希尔排序的实现 + 动态演示图 6.0 归并排序的实现 + 动态演示图 7.0 快速排序的实现 + 动态演示图
Java实现数据结构----插入排序直接插入排序
m0_56642224的博客
03-14 1700
七大基于比较的排序之插入排序-直接排序 直接插入排序-原理 主要步骤： 1.先假设第一个元素已经排好序 2.然后依次取出还需要进行排序的下一个元素，也就是排序完成的元素后面的下一个元素，取出下一个元素，设为待插入元素，在已经排序的元素序列中从后向前扫描，如果该元素（已排序）大于待插入元素，将该元素移到下一位置。 3.重复步骤2，直到找到已排序的元素小于或者等于待排序元素的位置，插入元素 4. 重复2，3的步骤，完成排序。 这样说可能还是有很多人不理解，那就画图来说明一下吧： 实现 性能分析 折半插入排
数据结构Java版排序（一）
weixin_58850105的博客
02-17 3631
目录 1.概念 1.1稳定性 2.七大排序 2.1插入排序 2.1.1直接插入排序-原理 2.1.2性能分析 2.1.3折半插入排序（了解） 2.2希尔排序 2.2.1原理 2.2.2性能分析 2.3选择排序 2.3.1原理 2.3.2性能分析 2.4堆排序 2.4.1原理 2.4.2性能分析 2.5冒泡排序 2.5.1原理 2.5.2性能分析 2.6快速排序（重要） 2.6.1原理 2.6.2性能分析 1.概念 排序，就是使一串记录，按照其中的某个或某..
【数据结构与算法】Java实现七大排序算法汇总
冲击大厂之路!!!
10-22 2166
凿壁偷光，8000字总结Java实现七大排序算法！
【Java 数据结构】十大排序 (动图解析)
书生-w的博客
04-24 1万+
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
Java排序（七大排序合集）
Violet277的博客
04-30 6239
排序是算法中有着很重要的地位。它会涉及到很多方面的知识，不仅仅是算法相关的知识，还有很多很数据结构相关的知识，所以了解排序，对于我们学习算法和数据结构都是很有帮助的。 其中常见的排序有其中排序方法，分别为冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序，本文则是围绕着着其中排序方法进行讲解。
【尚硅谷】Java数据结构与算法笔记07 - 排序算法
热门推荐
知不足而奋进，望远山而前行
01-13 1万+
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较 相邻元素的值, 若发现逆序则交换, 使值较大的元素逐渐从前移向后部, 就象水底下的气泡一样逐渐向上冒。优化。
数据结构-二叉排序树的操作与实现
m0_61789994的博客
06-01 2280
二叉排序树（Binary Search Tree，简称BST）是一种二叉树，它满足以下条件：1. 左子树上所有节点的值均小于它的根节点的值；2. 右子树上所有节点的值均大于它的根节点的值；3. 左右子树也分别为二叉排序树。二叉排序树的定义可以用递归的方式描述，即一个二叉树是二叉排序树，当且仅当它的左子树是二叉排序树，右子树是二叉排序树，并且左子树中所有节点的值都小于根节点的值，右子树中所有节点的值都大于根节点的值。二叉排序树是一种常见的数据结构，可以用于排序、查找和数据统计等操作。
Java基础---常用类大全以及各数据结构的方法大全
tq02的博客
07-15 2441
不含讲解，包括了Java语言和Java数据结构所需要学的类和方法，趋向于笔记，可以复习哦。记录了Math类、Random类、String类、时间类、数组类等
2022届-JAVA开发笔试题.docx
12-19
本资源摘要信息涵盖了JAVA开发笔试题的知识点，总结了 JAVA 编程语言、数据结构、算法、数据库、网络协议等方面的知识点。 一、JAVA编程语言 1. JAVA基本语法：变量声明、数据类型、运算符、控制结构、函数等。 2....
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
数据结构与算法-java版
03-05
### 数据结构与算法-java版 #### 一、Java与面向对象程序设计 - **Java语言基础知识** - **基本数据类型及运算**：Java支持多种基本数据类型，包括整型（如byte、short、int、long）、浮点型（float、double）、...
java数据结构.rar
04-27
总的来说，这个Java数据结构的视频教程全面覆盖了从基础到高级的数据结构知识，包括数组、排序、栈、队列、链表和递归等核心概念。通过学习这些内容，开发者可以更好地设计和实现高效的数据处理算法，提升软件的性能...
【数据结构】单链表的增删改查
最新发布
2302_78914800的博客
07-25 750
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 625
【代码】c语言（7.23）
数据结构：（1）线性表
weixin_71751116的博客
07-24 1053
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
EXT4 数据结构
弥川的博客
07-25 338
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

八只脚抠脚

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

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

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

打赏作者

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

抵扣说明：

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

余额充值