七大排序（Java）

最新推荐文章于 2024-08-05 17:56:32 发布
最新推荐文章于 2024-08-05 17:56:32 发布
阅读量470 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 java 开发语言 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60358891/article/details/129191731
版权

目录

一、插入排序

1. 直接插入排序

2. 希尔排序

二、选择排序

1. 直接选择排序

 2. 堆排序

 三、交换排序

1. 冒泡排序

 2. 快速排序

四、归并排序

五、总结

一、插入排序

1. 直接插入排序

   抓一张牌，在有序的牌中，找到合适的位置并且插入。

  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：稳定

 代码：

    public static void insertSort(long[] array) {
        for (int i = 1; i < array.length; i++) {
            //认为第一个数已经有序，所以循环 n - 1 次
            long tmp = array[i];
            int j = i - 1;
            for(; j >= 0; j--) {
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
                    break;
                }
            }
            //j回退到了 小于0 的地方
            array[j + 1] = tmp;
        }
    }

2. 希尔排序

   插入排序的升级版本，即进行大量的分组插排。

  • 时间复杂度：O(n^1.3 ~ n^1.5)
  • 空间复杂度：O(1)
  • 稳定性：不稳定

代码：

    //gap：组数
    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 gap = array.length;
        while (gap > 1) {
            shell(array,gap);
            gap = gap / 2;
        }
        shell(array, 1);
    }

二、选择排序

1. 直接选择排序

   找到无序区间中最小的元素的下标，然后将该元素放到无序区间的开始（有序区间的最后）。

  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：不稳定 

代码：

    // array: 待排序区间
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int minIdx = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[i]) {
                    minIdx = j;
                }
            }
            swap(array, minIdx, i);
        }
    }

 2. 堆排序

   选择排序的升级版本。将无序区间维护成一个大堆（因为从小到达排序，需要大堆）。利用大堆，从无序区间中找到最大值，交换。

  • 时间复杂度：O( N*log(N))
  • 空间复杂度：O(1)
  • 稳定性：不稳定

代码：

    //堆排序
    public static void heapSort(int[] array) {
        //1.建堆 O(n)
        creatHeap(array);
        int end = array.length - 1;
        //2.交换然后调整 O(n * log(n))
        while (end > 0) {
            swap(array, 0, end);
            shiftDown(array, 0, end);
            end--;
        }
    }

    public static void creatHeap(int[] array) {
        for (int parent = (array.length - 1 - 1)/ 2; parent >= 0; parent--) {
            shiftDown(array, parent, array.length);
        }
    }

    public 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++;
            }
            //child 下标为左右孩子中最大的孩子的下标
            if (array[child] > array[parent]) {
                swap(array, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

 三、交换排序

1. 冒泡排序

   从前往后，两两元素进行比较，前者大于后者则交换。每次循环完一个元素，后面的有序区间就多加一个元素。

  • 时间复杂度：O(N^2)
  • 有序情况下：O(n)
  • 空间复杂度：O(1)
  • 稳定性：稳定

代码：

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

 2. 快速排序

   ①在待排序区间内，选择一个基准值（pivot），本次代码中选择的是最右边；

   ②对待排序区间进行 partition 操作，目标：将待排序区间分开，左边的小于等于pivot，右边的大于等于pivot；

   ③分别再对左右两个小区间按照相同的方式进行处理。

  • 时间复杂度：
  •      最好【每次可以均匀的分割待排序序列】：O(N*log(N))
  •      最坏：数据有序 或者逆序的情况  O(N^2)
  • 空间复杂度：
  •      最好：O(logN)
  •      最坏：O(n)   单分支的一棵树
  • 稳定性：不稳定

代码： 

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

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

        if (left >= right) {
            return;
        }
        int pivot = partition(array, left, right);

        quick(array, left, pivot - 1);
        quick(array, pivot + 1, right);
    }

    //挖坑法
    public static int partition(int[] array, int start, int end) {
        int tmp = array[start];
        while (start < end) {
            while(start < end && array[end] >= tmp) {
                end--;
            }
            //end位置的元素小于基准值，挖坑
            array[start] = array[end];
            while(start < end && array[start] <= tmp) {
                start++;
            }
            //start位置的元素大于基准值，挖坑
            array[end] = array[start];
        }
        array[start] = tmp;
        return start;
    }

   由于用到了递归，当基准值左右边已经有序时，还需要栈空间来进行递归，所以当数据过大时，可能会导致栈溢出的情况，所以要将快速排序进行优化。

  • 当待排序区间元素个数小于某个范围时，可以使用插入排序。
  • 找基准值时，采用三数取中法。

代码： 

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

    public static void quick(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        //优化1：元素小于某个区间时，使用插入排序
        if (right - left + 1 < 1400) {
            insertSort(array, left, right);
        }
        //优化2：三数取中法
        int MinIdx = FindMinIdx(array, left, right);
        swap(array, MinIdx, left);

        int pivot = partition(array, left, right);

        quick(array, left, pivot - 1);
        quick(array, pivot + 1, right);
    }

    //挖坑法
    public static int partition(int[] array, int start, int end) {
        int tmp = array[start];
        while (start < end) {
            while(start < end && array[end] >= tmp) {
                end--;
            }
            //end位置的元素小于基准值，挖坑
            array[start] = array[end];
            while(start < end && array[start] <= tmp) {
                start++;
            }
            //start位置的元素大于基准值，挖坑
            array[end] = array[start];
        }
        array[start] = tmp;
        return start;
    }

    //插入排序
    public static void insertSort(int[] array, int start, int end) {
        for (int i = 1; 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 {
                    //array[j + 1] = tmp
                    break;
                }
            }
            // j 回退到了小于 0 的位置
            //或者从 break 出来
            array[j + 1] = tmp;
        }
    }

    //三数取中法
    private static int FindMinIdx(int[] array, int start, int end) {
        int mid = start + ((end - start) >>> 1);
        if (array[start] < array[end]) {
            if (array[mid] < array[start]) {
                return start;
            } else if (array[mid] > array[end]) {
                return end;
            } else {
                return mid;
            }
        } else {
            if (array[mid] > array[start]) {
                return start;
            } else if (array[mid] < array[end]) {
                return end;
            } else {
                return mid;
            }
        }
    }

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

快速排序非递归版本：利用栈存储 left 和 right 的值。

   public static void quickSort非递归(int[] array) {
        Deque<Integer> stack = new LinkedList<>();
        int left = 0;
        int right = array.length - 1;
        int pivot = partition(array, left, right);

        if (pivot > left + 1) {
            //左边有两位数
            stack.push(left);
            stack.push(pivot - 1);
        }
        if (pivot < right - 1) {
            stack.push(pivot + 1);
            stack.push(right);
        }

        while(!stack.isEmpty()) {
            right = stack.pop();
            left = stack.pop();
            pivot = partition(array, left, right);

            if (pivot > left + 1) {
                //左边有两位数
                stack.push(left);
                stack.push(pivot - 1);
            }
            if (pivot < right - 1) {
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }

四、归并排序

   归并排序是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

  • 时间复杂度：O(N*log(N))
  • 空间复杂度：O(n)
  • 稳定性：稳定

   在写归并排序代码之前，需要先会写：两个有序数组合并为一个有序数组。

代码：

    //将两个有序数组合并为一个有序数组
    //array1 和 array2 均为有序数组
    public static int[] mergeArray(int[] array1, int[] array2) {
        int[] tmp = new int[array1.length + array2.length];
        int s1 = 0;
        int s2 = 0;
        int e1 = array1.length - 1;
        int e2 = array2.length - 1;
        int k = 0;

        while (s1 <= e1 && s2 <= e2){
            if (array1[s1] <= array2[s2]) {
                tmp[k++] = array1[s1++];
                //k++;
                //s1++；
            } else {
                tmp[k++] = array2[s2++];
            }
        }

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

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

归并排序代码：

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

    private static void mergeSortInternal(int[] array, int low, int high) {
        if (low >= high) {
            return;
        }

        int mid = low + ((high - low) >>> 1);

        mergeSortInternal(array, low, mid);
        mergeSortInternal(array, mid + 1, high);

        merge(array, low, mid, high);
    }
   public static void merge(int[] array, int low, int mid, int high) {
        int[] tmp = 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]) {
                tmp[k++] = array[s1++];
            } else {
                tmp[k++] = array[s2++];
            }
        }

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

        //普通的归并数组需要直接返回 tmp 数组
        //但是在归并排序中，要将 tmp 数组重新拷贝到 array 数组中，
        //并且考虑在右子树中合并时，不能覆盖左边已经合并好的元素
        for (int i = 0; i < k; i++) {
            array[low + i] = tmp[i];
        }
    }

非递归版本：

    public static void mergeSort非递归(int[] array) {
        int nums = 1; //每组的数据个数
        while (nums < array.length) {
            for (int i = 0; i < array.length; i++) {
                int left = i;
                int mid = left + nums - 1;
                //防止越界
                if (mid >= array.length) {
                    mid = array.length - 1;
                }
                int right = mid + nums;
                //防止越界
                if (right >= array.length) {
                    right = array.length - 1;
                }
                //下标确定之后进行合并
                merge(array, left, mid, right);
            }
            nums *= 2;
        }
    }

五、总结

   七大排序中：

稳定的排序：冒泡排序、插入排序、归并排序

插入排序主要看数组是否有序，来影响其时间复杂度
归并排序无论什么情况下，时间复杂度都为 O(N*log(N))

时间复杂度为O(N*log(N))的排序：快速排序、堆排序、归并排序

要想速度快就选 快速排序
要想稳定就选 归并
要想空间复杂度低就选 堆排序

 

排序时间复杂度空间复杂度稳定性
插入排序O(N^2)O(1)稳定
希尔排序O(N^1.3)O(1)不稳定
选择排序O(N^2)O(1)不稳定
堆排序O(N*log(N))O(1)不稳定
冒泡排序O(N^2)O(1)稳定
快速排序O(N*log(N))O(log(N))不稳定
归并排序O(N*log(N))

O(n)

稳定

 

AJIUZ
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
七大排序算法的java实现
04-09
这七大排序算法各有特点，适应不同的场景。插入排序和选择排序适合小规模数据，而归并排序和快速排序在大规模数据上表现优异。堆排序和快速排序是原地排序，不需要额外空间，而归并排序则需要额外的空间。希尔排序则...
七种排序算法Java版.doc
09-01
本篇文章主要探讨了七种经典的排序算法的Java实现，包括冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序。 1. **冒泡排序**： 冒泡排序是一种简单的交换排序，它通过重复遍历待排序的列表，...
计算机七大排序
10-16
"计算机七大排序" 计算机七大排序是计算机科学中最基本也是最重要的算法之一。排序算法的目的是将一组无序的数据按照一定的规则排列成有序的数据，以便于后续的数据处理和分析。七大排序算法包括冒泡排序、直接插入...
Java中七大基于比较的排序算法
01-21
目录插入排序直接插入排序基本原理代码实现性能分析折半插入排序代码实现希尔排序基本原理代码实现性能分析选择排序单向选择排序基本原理代码实现性能分析双向选择排序代码实现堆排序基本原理代码实现性能分析冒泡...
数据结构与算法--栈
wumingzei的博客
08-02 1070
栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。允许插入和删除运算的一端称为栈顶（top），不允许插入和删除的另一端称为栈底（bottom）。在栈顶进行的插入操作称为入栈或进栈(push),在栈顶进行的删除操作称为出栈或退栈(pop)特点：后进先出（LIFO, Last In First Out）。栈的后进先出特性。顺序栈和链栈的入栈、出栈操作。栈在中缀表达式转换为后缀表达式中的应用。
【数据结构】——链式二叉树
2402_82668782的博客
08-02 964
1>二叉树的结构体 包含了数据和指向左右子树的指针}BTNode;<2>二叉树结点的创建<3>二叉树的创建Tip：二叉树是递归定义的，都可以单独看作 根、左子树、右子树。
数据结构(5.4_1)——树的存储结构
m0_65240792的博客
08-02 320
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
数据结构：栈（含源码）
最新发布
2401_86551514的博客
08-05 304
先判断容量是否有足够的空间让数据入栈，在第一次入栈是先给定4个空间，后面每次不够时就将空间数乘以2， 还有一个判断是否开辟成功（这个可以不写，一般都会开辟成功）。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出的原则。我们在创建栈时，一般是创建支持动态增长的栈，定长的静态栈不实用。出栈非常的简单，只要将top数减少一个就行了，相当于是下一次入栈是直接把这个数据修改掉，就算没修改，打印时也不影响。
数据结构（其四）--特殊矩阵的存储
sjj_1234567的博客
08-05 544
所以，aij 前面有 [n + ... + (n - i + 2)] + (j - i)个元素，中括号里的是此行往上的，那个j-i是当前行内aij 之前的元素。（对于aij），前(i - 1)行，有3(i - 1) - 1个元素(每行有三个元素，但第一行只有两个)；一维数组的地址是连续的，只要知道了起始地址（LOC，默认是a[0]的地址），就可以知道所有元素的地址。是第k + 1个元素，在前i-1行，与前i行之间，3(i - 1) - 1 < k + 1。获取常数项，数组下标就是 n*(n+1)/2。
【C语言】【数据结构】冒泡排序及优化
2401_86272648的博客
08-02 342
冒泡排序是一种简单的排序算法。一次从前往后地走访待排序的元素序列被称为一趟，每一趟都会把相邻的两个元素的错误顺序交换，将当前趟次中最大或者最小的元素像“冒泡泡”一样冒到最后面，反复地走访元素序列，直到所有元素都排好序。
数据结构：双向链表
2401_86551514的博客
08-03 467
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
【数据结构入门 】栈
KevinRay_0854的博客
08-02 612
通过构建一个栈，我们可以非常方便地实现后进先出的数据结构，使得我们能够高效地处理一些具有类似特性的问题。因此，了解和掌握栈的概念和操作是很重要的。在接下来的内容中，我们将详细介绍栈的基本原理、以及常见实现方式。希望通过本文的学习，读者能够深入理解栈，并能够在实际编程中熟练运用。
Redis 数据结构深度解析：跳跃表（Skiplist）
lssffy的博客
08-02 491
本文旨在全面解析跳跃表的设计原理、结构特点、实现方式以及其在Redis中的应用，并通过示例代码帮助读者深入理解跳跃表的工作机制。跳跃表是一种概率性的数据结构，基于多层链表，与平衡树和二分查找相比，跳跃表在实现上更为简单，同时保持了类似的平均时间复杂度和最坏时间复杂度。探讨跳跃表的变种和改进方法，如确定性跳跃表、压缩跳跃表等，以及它们在现代数据库和分布式系统中的潜在应用。Redis的跳跃表实现在保持数据结构本身优势的同时，进行了适应性的优化，以满足高并发和大数据量的需求。第三部分：跳跃表的效率和优化。
《数据结构（C语言版）第二版》第五章-树和二叉树（5.4-5.5.1）
qq_44883214的博客
07-29 307
【代码】《数据结构（C语言版）第二版》第五章-树和二叉树（5.4-5.5.1）
数据结构———队列
w13114的博客
08-02 812
队列是一种特殊的线性表，它只允许在一端进行插入操作，在另一端进行删除操作。插入的一端称为队尾（Rear），删除的一端称为队头（Front）。
数据结构：顺序表
2401_86551514的博客
08-01 978
顺序表是线性表的一种，而线性表是n个具有相同特性的数据元素的有限序列，线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的⼀条直线，但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储，这个物理结构是否连续就是看物理地址上是否连续。顺序表与数组的区别：顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接⼝。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出，如果喜欢的话，
数据结构： 单向链表
2401_86551514的博客
08-02 856
链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉或者加上，不会影响其他车厢，每节车厢都是独立存在的，车厢是独立存在的，且每节车厢都有车门，想象⼀下这样的场景，假设每节车厢的车门都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头走到车尾？与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“节点”， 节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
【数据结构初阶】深度理解 “栈” （附源码）
稻草人
08-03 993
栈的概念与结构、初始化、销毁、入数据、取数据、获取栈中有效元素的个数、出栈
Java七大排序算法详解及实现
"Java的7种排序算法，包括冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序的详细解释和Java代码实现。" 在编程领域，排序算法是基础且重要的组成部分，尤其在Java这样的编程语言中。以下是这7...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值