Java实现七种【排序算法】+图解+完整代码+分析

置顶 已于 2022-05-19 18:49:48 修改
阅读量4.2k 收藏 12
点赞数 6
分类专栏： 数据结构与算法 文章标签： 数据结构 排序算法 算法 快速排序 java
于 2020-12-13 14:26:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46360532/article/details/111106623
版权

参考书目：《大话数据结构》

本文涉及的排序算法

一、冒泡排序（优化版）

0.基本思想：一种交换排序，两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录位置。

1.思路图解：
在这里插入图片描述

2.代码实现：

public class BubbleSort {
    public static int[] sort(int[] array) {
        int i, j;
        int len = array.length;
        int[] copyArray = Arrays.copyOf(array, len);
        boolean flag = true;

        for (i = 0; i < len - 1 && flag; i++) {
            flag = false;
            for (j = len - 2; j >= i; j--) {
                if (copyArray[j] > copyArray[j + 1]) {
                    swap(copyArray, j, j + 1);
                    flag = true;
                }
            }
        }

        return copyArray;
    }

    private static void swap(int[] array, int x, int y) {
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }
}

3.分析：

  • 平均时间：O (n^2)
  • 最差时间：O (n^2)
  • 稳定度：稳定
  • 额外空间：O (1)
  • 最佳实践：n 小时好

二、简单选择排序

0.基本思想：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换。

1.思路图解：

在这里插入图片描述

2.代码实现：

public class SelectSort {

    public static int[] sort(int[] array) {
        int i, j;
        int len = array.length;
        int[] copyArray = Arrays.copyOf(array, len);
        int minIndex = 0;

        for (i = 0; i < len - 1; i++) {
            minIndex = i;
            for (j = i + 1; j < len; j++) {
                if (copyArray[j] < copyArray[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                swap(copyArray, i, minIndex);
            }
        }

        return copyArray;
    }

    private static void swap(int[] array, int x, int y) {
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }
}

3.分析：

  • 平均时间：O (n^2)
  • 最差时间：O (n^2)
  • 稳定度：不稳定
  • 额外空间：O (1)
  • 最佳实践：n 小时好
  • 最大特点就是交换移动数据次数相当少，性能上略优于冒泡排序

三、直接插入排序

0.基本思想：将一个记录插入到以及排好序的有序表中，从而得到一个新的、记录数增1的有序表。

1.思路图解：

在这里插入图片描述

2.代码实现：

public class InsertSort {
    public static int[] sort(int[] array) {
        int i, j;
        int len = array.length;
        int[] copyArray = Arrays.copyOf(array, len);
        int tmp = 0;

        for (i = 0; i < len - 1; i++) {
            if (copyArray[i] > copyArray[i + 1]) {
                tmp = copyArray[i + 1];
                for (j = i; j >= 0 && copyArray[j] > tmp; j--) {
                    copyArray[j + 1] = copyArray[j];
                }
                copyArray[j + 1] = tmp;
            }
        }

        return copyArray;
    }
}

3.分析：

  • 平均时间：O (n^2)
  • 最差时间：O (n^2)
  • 稳定度：稳定
  • 额外空间：O (1)
  • 最佳实践：序列中基本有序时较好
  • 优于冒泡和简单选择排序

四、希尔排序

0.基本思想：把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，所有记录恰被分成一组，算法便终止。因此，将关键字较小的记录，不是一步一步地往前挪动，而是跳跃式地往前移，从而使得每完成一轮循环后，整个序列就朝着有序坚实地迈进一步。

1.思路图解：

在这里插入图片描述

2.代码实现：

public class ShellSort {
    public static int[] sort(int[] array) {
        int i, j;
        int len = array.length;
        int[] copyArray = Arrays.copyOf(array, len);
        int increment = len - 1;
        int tmp = 0;

        //用 do-while 是为了 len = 2 时这种特殊情况
        do {
            increment = increment / 3 + 1;
            for (i = 0; i < len - increment; i++) {
                if (copyArray[i] > copyArray[i + increment]) {
                    tmp = copyArray[i + increment];
                    for (j = i; j >= 0 && copyArray[j] > tmp; j -= increment) {
                        copyArray[j + increment] = copyArray[j];
                    }
                    copyArray[j + increment] = tmp;
                }
            }
        } while (increment > 1);

        return copyArray;
    }
}

3.分析：

  • 平均时间：O (nlogn)
  • 最差时间：O (n^s, 1 < s < 2)
  • 稳定度：不稳定
  • 额外空间：O (1)
  • 由于记录是跳跃式移动，所以这并不是一种稳定的排序算法

五、堆排序

0.基本思想：将待排序的序列构造成一个大顶锥（适用于从小到大排序），此时整个序列的最大值就是堆顶的根节点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余n-1个序列重新构造成一个堆，这样就会得到n个元素的次大值。如此反复执行，便能得到一个有序序列。

1.思路图解：

在这里插入图片描述

2.代码实现：

public class HeapSort {

    public static int[] sort(int[] array) {
        int i;
        int n = array.length;

        //构建大顶堆
        for (i = (n - 1) / 2; i >= 0; i--) {
            heapAdjust(array, i, n - 1);
        }

        //对大顶堆进行堆排序
        for (i = n - 1; i > 0; i--) {
            swap(array, 0, i);
            heapAdjust(array, 0, i - 1);
        }

        return array;
    }

    private static void heapAdjust(int[] array, int start, int end) {
        int j;
        int tmp = array[start];

        for (j = 2 * start; j <= end; j *= 2) {
            if (j < end && array[j] < array[j + 1]) {
                j++; //j为当前start结点，和此结点的左右孩子直接的较大值的下标
            }
            if (tmp >= array[j]) {
                break; //不需要调整，这时a[start]本来就是三角形的较大值
            }
            array[start] = array[j];
            start = j;
        }

        array[start] = tmp; //若经历了for构造，则应为最初的array[start]找一个归宿
    }

    private static void swap(int[] array, int x, int y) {
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }
}

3.分析：

  • 平均时间：O (nlogn)
  • 最差时间：O (nlogn)
  • 稳定度：不稳定
  • 额外空间：O (1)
  • 最佳实践：n 大时好
  • 由于记录的比较与交换是跳跃式进行，因此也是一种不稳定的排序算法
  • 由于初始构建堆所需比较次数较多，因此不适合待排序序列个数较少的情况

六、归并排序（递归版）+归并排序（递归优化版）

0.基本思想：初始序列含有n个元素，则可看成是n个有序子序列，每个子序列的长度为1，然后两两归并，得到Math.ceil(n/2)个长度为2或1的有序子序列；再两两归并，…，如此重复，直到得到一个长度为n的有序序列位置，这种排序方法称为2路归并排序。

1.思路图解：

在这里插入图片描述

2.代码实现：

//递归实现
public class MergeSort {
    public static int[] sort(int[] a, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            sort(a, low, mid);
            sort(a, mid + 1, high);
            //左右归并
            merge(a, low, mid, high);
        }
        return a;
    }

    public static void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;
        // 把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (a[i] < a[j]) {
                temp[k++] = a[i++];
            } else {
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖nums数组
        for (int index = 0; index < temp.length; index++) {
            a[low + index] = temp[index];
        }
    }
}

2.5.代码实现（优化版）：

public class MergeSort2 {

    public static void sort(int[] a) {
        int n = a.length - 1;
        MSort(a);
    }

    private static void MSort(int[] SR) {
        int n = SR.length - 1;
        int[] TR = new int[n + 1];
        int k = 1;
        while (k < n) {
            MergePass(SR, TR, k, n);
            k = 2 * k;
            MergePass(TR, SR, k, n);
            k = 2 * k;
        }
    }

    // 将SR[s..n]归并为有序的TR[s..n]
    private static void MergePass(int[] SR, int[] TR, int s, int n) {
        int i = 1;
        int j;
        while (i <= n - 2 * s + 1) {
            Merge(SR, TR, i, i + s - 1, i + 2 * s - 1);
            i = i + 2 * s;
        }
        if (i < n - s + 1) {
            Merge(SR, TR, i, i + s - 1, n);
        } else {
            for (j = i; j <= n; j++) {
                TR[j] = SR[j];
            }
        }
    }

    // 将有序的SR[s..m]和SR[m+1..n]归并为有序的TR[i..n]
    private static void Merge(int[] SR, int[] TR, int s, int m, int n) {
        int j, k, l; // k为左块的起始下标，j为右块的起始下标
        for (k = s, j = m + 1; s <= m && j <= n; k++) { // SR中记录由小到大归并入TR
            if (SR[s] < SR[j]) {
                TR[k] = SR[s++];
            } else {
                TR[k] = SR[j++];
            }
        }
        if (s <= m) {
            for (l = 0; l <= m - s; l++) {
                TR[k + l] = SR[s + l]; // 将剩余的SR[s..m]复制到TR
            }
        }
        if (j <= n) {
            for (l = 0; l <= n - j; l++) {
                TR[k + l] = SR[j + l]; // 将剩余的SR[j..m]复制到TR
            }
        }
    }

}

3.分析：

  • 平均时间：O (nlogn)

  • 最差时间：O (nlogn)

  • 稳定度：稳定

  • 最佳实践：n 大时好

  • 空间复杂度：O(nlogn) 和 O(n)

  • 需要两两比较，不存在跳跃，是一种稳定的排序算法

  • 比较占用内存，但效率高

  • 尽量用非递归版（优化版）

七、快速排序+快速排序（四度优化版）

0.基本思想：通过一趟排序将待排序记录分割成独立的两部分，其中每一部分记录的关键字均比另一部分记录的关键字小，则可以分别对着两部分记录继续进行排序，以达到整个序列有序的目的。

1.思路图解：

在这里插入图片描述

2.代码实现：

public class QuickSort {
    public static void sort(int[] a) {
        int n = a.length - 1;
        QSort(a, 1, n);
    }

    private static void QSort(int[] a, int low, int high) {
        if (low < high) {
            int pivot = Partition(a, low, high); // 将a[low..high]一分为二，算出枢轴下标pivot
            QSort(a, low, pivot - 1); // 对低子表递归排序
            QSort(a, pivot + 1, high); // 对高子表递归排序
        }
    }

    // 交换顺序表a中子表的记录，使枢轴记录到为，并返回其位置
    private static int Partition(int[] a, int low, int high) {
        int pivotkey = a[low]; // 用子表的第一个记录作枢轴记录
        while (low < high) { // 从表的两端交替向中间扫描
            while (low < high && a[high] >= pivotkey) {
                high--;
            }
            swap(a, low, high); // 将比枢轴值小的记录交换到低端
            while (low < high && a[low] <= pivotkey) {
                low++;
            }
            swap(a, low, high); // 将比枢轴值大的记录交换到高端
        }
        return low; // 最终low == high，所有返回枢轴所在位置
    }

    private static void swap(int[] a, int x, int y) {
        int temp;
        temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }

}

2.代码实现（优化版）：

public class QuickSortUp {

    // 1.优化选取枢轴（三数取中），选取更较为合适的枢轴值，使得左小右大更均匀;
    // 2.优化交换操作为替换，分析得知，swap交换操作本身不必要;
    // 3.优化小数组时的排序方案为直接插入排序，而对于大数组则采用快排;
    // 4.优化递归操作，将对高子表的递归转为只对低子表的迭代版递归

    public static void sort(int[] a) {
        int n = a.length - 1;
        QSort(a, 1, n);
    }

    private static void QSort(int[] a, int low, int high) {
        int ORDINARY_LEN = 7; // 数组长度阈值，当小于时，可用直接插入排序
        int pivot; // 枢轴的下标，将某个数放在此位置，使得它左边的值都比它小，右边的都比它大
        if ((high - low) > ORDINARY_LEN) {
            while (low < high) {
                pivot = Partition(a, low, high); // 将a[low..high]一分为二，算出枢轴下标pivot
                QSort(a, low, pivot - 1); // 对低子表递归排序
                low = pivot + 1; // 尾递归
            }
        } else {
            InterSort.sort(a);
        }
    }

    // 交换顺序表a中子表的记录，使枢轴记录到为，并返回其位置
    private static int Partition(int[] a, int low, int high) {
        int pivotkey;
        int m = low + (high - low) / 2;
        if (a[low] > a[high]) {
            swap(a, low, high);
        }
        if (a[m] > a[high]) {
            swap(a, high, m);
        }
        if (a[m] > a[low]) {
            swap(a, m, low);
        }
        pivotkey = a[low]; // 此时a[low]为三数取中得到的中间值
        a[0] = pivotkey; // 哨兵
        while (low < high) { // 从表的两端交替向中间扫描
            while (low < high && a[high] >= pivotkey) {
                high--;
            }
            a[low] = a[high]; //改交换为替换
            while (low < high && a[low] <= pivotkey) {
                low++;
            }
            a[high] = a[low];
        }
        a[low] = a[0];
        return low; // 最终low == high，所有返回枢轴所在位置
    }

    private static void swap(int[] a, int x, int y) {
        int temp;
        temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }

}

3.分析：

  • 平均时间：O (nlogn)
  • 最差时间：O (n^2)
  • 稳定度：不稳定
  • 最佳实践：n 大时好
  • 空间复杂度：O(logn) 和 O(n)
  • 由于关键字的比较和交换是跳跃进行的，因此也不稳定
  • 优化后性能提升

End.总结

在这里插入图片描述

超周到的程序员
关注
  • 6
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
七种排序算法Java版.doc
09-01
七种排序算法Java版
排序算法java描述
05-25
本人希望编写一个工具类实现各种排序算法的调用，针对数字的排序！
java排序代码
09-04
排序: TreeSet支持两种排序方式： 自然排序：TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列。 定制排序：在创建TreeSet集合对象时，并提供一个Comparator接口实现类对象与该TreeSet集合关联， 由Comparator实现类对象负责集合元素的排序逻辑。 // 自定义比较器 class MyTreeSetCompartor implements Comparator<Object> { // 实现compare方法 @Override public int compare(Object o1, Object o2) { String str1 = String.valueOf(o1); String str2 = String.valueOf(o2); //return str1.compareTo(str2); return str2.compareTo(str1); } } TreeSet<Object> set = new TreeSet<Object>(new MyTreeSetCompartor());
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
Java排序代码.docx-综合文档
05-21
Java排序代码.docx
快速排序代码
鹜骜的博客
12-10 2814
public static void quickSort(int[] arr,int low,int high){ int i,j,temp,t; if(low>high){ return; } i=low; j=high; //temp就是基准位 tem...
Java常用实现八种排序算法与代码实现
热门推荐
java_atguigu的博客
04-02 1万+
一、交换排序 所谓交换，就是序列中任意两个元素进行比较，根据比较结果来交换各自在序列中的位置，以此达到排序的目的。 1. 冒泡排序 冒泡排序是一种简单的交换排序算法，以升序排序为例，其核心思想是： 从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 轮到下一组相邻元素，执行同样的比较操作，再找下一组，直到没有相邻元素可比较为止，此时最后的元素应是最大的数。 除了每次排序得到的最后一个元素，对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止。
十大排序（含java代码）
qq_62928039的博客
03-29 5906
十大排序算法详解：包括冒泡排序、选择排序、快速排序、插入排序、计数排序、希尔排序、归并排序、桶排序、堆排序、基数排序
Java代码【快速排序】详解
Toufahaizai的博客
07-22 512
目录概要原理双边循环法双边循环法代码实现单边循环法单边循环法代码实现非递归实现????个人总结 概要 快速排序是一种交换排序，通过元素之间的比较和交换位置来达到排序目的。 原理 在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成两部分。 这种思路叫做：分治法 代码中方法说明： quickSort方法通过递归方式，实现分而治之的思想。 partition方法实现元素交换，让数列中的元素依据自身大小，分别交换到基准元素的左右两边 双边循环法
Java排序算法代码集（7个）
Lawrence
03-31 3836
0.注 以下代码是以前参考视频课程或者其他人的博客写的，现在是复习+做个备份在CSDN上，大部分都忘了为何这样写了，希望各位如果拿某部分代码跑出了问题，可以把用例留个言让我检查反思一下，感激不尽~ 1.冒泡排序 public static void bubbleSort(int[] arr){ for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length - i - 1; j++) {
数据结构之冒泡排序算法（图解+分析+代码调优）
12-22
冒泡排序是一种比较简单的排序算法，其基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，可以形象的理解为像水底下的气泡...
图解程序员必须掌握的Java常用8大排序算法
09-03
本文以图片与文字结合的方式讲解了程序员必须掌握的Java常用8大排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下
java常见排序算法合集讲解以及java实现.zip
11-29
Java中常见的排序算法 1.直接插入排序 2.希尔排序 3.选择排序 4.冒泡排序 5.归并排序 6.快速排序 7.堆排序 8.计数排序 9.桶排序 10....包含这十种算法的讲解以及动态图解（ppt）和java实现
图文讲解Java中实现quickSort快速排序算法的方法
09-02
主要介绍了Java中实现quickSort快速排序算法的方法,文章最后还介绍了一种单向扫描的实现方法,需要的朋友可以参考下
【超全！】图解Java数据结构和算法(共195集)【资料+视频+课件+代码+笔记】
10-13
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
分治算法解析与实战【九大经典例子（附完整代码）】（上篇）
Zhou_LC的博客
01-06 8765
一、【分治算法】简介 1.基本思想：”分而治之“，将一个复杂问题分解成两个或多个相同或相似的子问题，再把子问题分解成更小的子问题…直到最后子问题可以简单的直接求解，原问题的解即为所有子问题的解的合并。 2.经典例子： 汉诺塔 二分查找（递归版） 大整数乘法 棋盘覆盖 合并排序 快速排序 线性时间选择 最接近点对问题 循环赛日程表 二、经典例子的代码实现 1.汉诺塔： (1)草图分析： （2）代码实现 public class Hanoitower { public static void m
数据结构【完整代码】之（C语言实现【哈夫曼编码】）
Zhou_LC的博客
11-28 3004
本文包含两个文件的代码和一张测试效果图： HuffmanCD.h文件： 从叶到根逆向求哈夫曼编码 HuffmanCodingTest.cpp文件： 用于测试 效果图：（如下） 效果图： HuffmanCD.h文件： #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct{ int weight; int parent,lchild,rchild; }HTNode,*Huff
Java实现四种【查找算法】+图解+完整代码+分析
Zhou_LC的博客
12-11 2592
参考书目：《大话数据结构》 一.哨兵法： 1.思路图解： 2.代码实现： public class SentrySearch { public static int search(int[] a, int key) { int i; a[0] = key; // 设置a[0]存储要查找的值，称之为“哨兵” i = a.length - 1; // 循环从数组尾部开始 while (a[i] != key) {
Java常用排序算法&程序员必须掌握的8大排序算法+二分法查找
最新发布
05-27
Java常用的排序算法有冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序和堆排序。 程序员必须掌握的8大排序算法包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序和计数排序。 其中，冒泡排序和选择排序都是比较简单的排序算法，但是时间复杂度较高；插入排序和希尔排序相对而言速度更快，但是对数据的要求比较高；归并排序、快速排序和堆排序则是效率比较高的排序算法，但是实现较为复杂。 二分法查找也是一种常用的查找算法，它是一种基于比较的查找方法，可以在有序数组中快速定位目标元素。二分法查找的时间复杂度为O(logN)，是一种比较高效的查找算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

超周到的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值