常见排序算法java实现

已于 2022-06-05 19:09:53 修改
阅读量193 收藏
点赞数 2
分类专栏： 数据结构与算法 文章标签： 排序算法 java 算法
于 2022-06-05 19:02:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AK47red/article/details/125135306
版权

排序

模版类 SortExample

package com.wy.mycode.algorithm.sort.common;

/**
 * @author HelloWorld
 * @create 2022/6/3 17:16
 * @email helloworld.dng@gmail.com
 *
 * 排序算法模版类
 */
public class SortExample {
    /**
     * @description 比较两个数的大小  v < w 返回 true
     * @author HelloWorld
     * @create 2022/6/3 18:56
     * @param v
     * @param w
     * @return boolean
     */
    public static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /**
     * @description  交换数组元素位置
     * @author HelloWorld
     * @create 2022/6/3 19:05
     * @param a
     * @param i
     * @param j
     * @return void
     */
    public static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    /**
     * @description 单行打印数组元素
     * @author HelloWorld
     * @create 2022/6/3 19:08
     * @param a
     * @return void
     */
    public static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    public static void show(String msg, Comparable[] a) {
        System.out.print(msg + ": ");
        show(a);
    }

    /**
     * @description  判断数组元素是否有序
     * @author HelloWorld
     * @create 2022/6/3 19:11
     * @param a
     * @return boolean
     */
    public static boolean isSorted(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i-1])) {
                return false;
            }
        }
        return true;
    }
}

测试数据

package com.wy.mycode.algorithm.sort.common;

import java.util.Random;

/**
 * @author HelloWorld
 * @create 2022/6/3 19:27
 * @email helloworld.dng@gmail.com
 *
 */

public class TestExampleData implements Comparable<TestExampleData>{

    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value + "";
    }

    @Override
    public int compareTo(TestExampleData a) {
        if (this.getValue() - a.getValue() >= 0) {
            return 1;
        }
        return -1;
    }

    /**
     * @description 返回长度为n的int型随机数组, 数组中的数据范围 [0, 1000]
     * @author HelloWorld
     * @create 2022/6/3 19:34
     * @param n
     * @return com.wy.mycode.algorithm.sort.common.TestExampleData[]
     */
    public static TestExampleData[] getTestData(int n) {
        TestExampleData[] array = new TestExampleData[n];
        for (int i = 0; i < n; i++) {
            TestExampleData testExampleData = new TestExampleData();
            Random random = new Random();
            testExampleData.value = random.nextInt(1001);
            array[i] = testExampleData;
        }
        return array;
    }


}

选择排序

第一次：选择数组中的最小的元素，与数组中的第一个元素交换位置(如果第一个元素就是最小的，也交换)
第二次：从剩下元素中选择最小的元素，与数组中第二个元素交换位置
如此往复，直到遍历完整个数组

对于长度为n的数组，选择排序需要 n 2 2 \dfrac{n^2}{2} 2n2​ 次比较和 n 次交换

package com.wy.mycode.algorithm.sort;

import com.wy.mycode.algorithm.sort.common.SortExample;
import com.wy.mycode.algorithm.sort.common.TestExampleData;

/**
 * @author HelloWorld
 * @create 2022/6/3 19:14
 * @email helloworld.dng@gmail.com
 * 选择排序
 */
public class Selection extends SortExample {
    /**
     * @description 第一次：选择数组中的最小的元素，与数组中的第一个元素交换位置(如果第一个元素就是最小的，也交换)
     *              第二次：从剩下元素中选择最小的元素，与数组中第二个元素交换位置
     *              如此往复，直到遍历完整个数组
     * @author HelloWorld
     * @create 2022/6/3 19:16
     * @param a
     * @return void
     */
    public static void sort(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            int min = i;
            // 找到当前最小的元素
            for (int j = i; j < a.length; j++) {
                if (less(a[j], a[min])) {
                    min = j;
                }
            }
            // 交换位置
            exch(a, i, min);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        TestExampleData[] array = TestExampleData.getTestData(10);
        show("排序前", array);
        sort(array);
        if (isSorted(array)) {
            show("排序后", array);
            return;
        }
         show("排序失败", array);

    }
}

插入排序

遍历数组，将数据插入到合适到位置
第一次：只有一个数，那么它一定在它最合适的位置
第二次：比较第二个数与第一个数的大小，如果第二个数小于第一个数，交换他们位置
第三次：比较第三个数与前两个数的大小，并按照比较结果交换它们位置
直到数组遍历完

package com.wy.mycode.algorithm.sort;

import com.wy.mycode.algorithm.sort.common.SortExample;
import com.wy.mycode.algorithm.sort.common.TestExampleData;

/**
 * @author HelloWorld
 * @create 2022/6/3 21:11
 * @email helloworld.dng@gmail.com
 * 插入排序
 */
public class Insertion extends SortExample {
    /**
     * @description 遍历数组，将数据插入到合适到位置
     *              第一次：只有一个数，那么它一定在它最合适的位置
     *              第二次：比较第二个数与第一个数的大小，如果第二个数小于第一个数，交换他们位置
     *              第三次：比较第三个数与前两个数的大小，并按照比较结果交换它们位置
     *              直到数组遍历完
     * @author HelloWorld
     * @create 2022/6/3 21:13
     * @param array
     * @return void
     */
    public static void sort(Comparable[] array) {
        for (int i = 1; i < array.length; i++) {
            for (int j = i; j > 0 && less(array[j], array[j-1]); j--) {
                exch(array, j, j-1);
            }
        }
    }

    public static void main(String[] args) {
        TestExampleData[] testData = TestExampleData.getTestData(10);
        show("排序前",  testData);
        sort(testData);
        if (isSorted(testData)) {
            show("排序后", testData);
            return;
        }
        show("排序失败", testData);
    }
}

希尔排序

希尔排序的思想是使数组中任意间隔为h的元素都是有序的

希尔排序轨迹：间隔为 5，3， 1

排序前

4938659776132749554

第一次间隔为5，得到的子序列为：

(49, 13) (38, 27) (65, 49) (97, 55) (76, 4)

对子序列进行插入排序，得到：

1327495544938659776

第二次间隔为3，得到的子序列为：

(13, 55, 38, 76) (27, 4, 65) (49, 49, 97)

对子序列进程插入排序，得到:

1344938274955659776

最后一次间隔为1，得到的子序列就是第二次排序后的序列，对该序列进行插入排序

4132738494955657697
package com.wy.mycode.algorithm.sort;

import com.wy.mycode.algorithm.sort.common.SortExample;
import com.wy.mycode.algorithm.sort.common.TestExampleData;

/**
 * @author HelloWorld
 * @create 2022/6/4 21:17
 * @email helloworld.dng@gmail.com
 * 希尔排序
 */
public class Shell extends SortExample {
    /**
     * @description 希尔排序
     * @author HelloWorld
     * @create 2022/6/4 22:27
     * @param array
     * @return void
     */
    public static void sort(Comparable[] array) {
        int length = array.length;
        int h = 1;

        // h初始化
        while (h < length / 3) {
            // h的可能为：1， 4， 13， 40， 121， 364， 1093...
            h = 3 * h + 1;
        }

        while (h >= 1) {
            // 对间隔为h的子序列进行插入排序
            // 由于希尔排序的 h 一定存在一个值 1， 即对整个array进行插入排序，故，只需要将原插入逻辑改写

            /*  插入排序对逻辑，只需要将 1 换为h即可
                 for (int i = 1; i < array.length; i++) {
                     for (int j = i; j > 0 && less(array[j], array[j-1]); j--) {
                        exch(array, j, j-1);
                     }
                 }
             */
            for (int i = h; i < length; i++) {
                for (int j = i; j >= h && less(array[j], array[j-h]); j = j - h) {
                   exch(array, j, j-h);
                }
            }
            h /= 3;
        }
    }

    public static void main(String[] args) {
        TestExampleData[] array = TestExampleData.getTestData(21);
        show("排序前", array);
        sort(array);
        if (isSorted(array)) {
            show("排序后", array);
            return;
        }
        show("排序失败", array);

    }
}

归并排序

将两个有序数组归并成一个更大的有序数组

534629817108788375

第一次：待合并的有序数组为 534 与 629， 817与108， 788与375，合并后的结果为：

534629108817375788

第二次：待合并的有序数组为 (534, 629) 与 （108，817), (375, 788), 合并后的结果为

108534629817375788

第三次：待合并的有序数组为 (108, 534. 629, 817) 与 (375, 788), 合并后的结果为

108375534629788817

递归实现

package com.wy.mycode.algorithm.sort;

import com.wy.mycode.algorithm.sort.common.SortExample;
import com.wy.mycode.algorithm.sort.common.TestExampleData;

/**
 * @author HelloWorld
 * @create 2022/6/5 08:53
 * @email helloworld.dng@gmail.com
 */
public class Merge extends SortExample {
    /** 辅助数组 */
    private static Comparable[] aux;

    /**
     * @description  将两个有序数组合并为 1 个有序数组
     * @author HelloWorld
     * @create 2022/6/5 15:39
     * @param array
     * @param low
     * @param mid
     * @param high
     * @return void
     */
    public static void merge(Comparable[] array, int low, int mid, int high) {
        // 第一个有序数组的第一个坐标
        int i = low;
        // 第二个有序数组的第一个坐标
        int j = mid + 1;

        // 初始化辅助数组
        for (int k = low; k <= high ; k++) {
            aux[k] = array[k];
        }
        for (int k = low; k <= high; k++) {
            if (i > mid) {
                // 此时说明，第一个数组，已经被合并完了，只需要将第二个数组剩余部分全部加进去
                array[k] = aux[j++];
            }else if (j > high) {
                // 第二个数组合并完成了
                array[k] = aux[i++];
            }else if (less(aux[j], aux[i])) {
                array[k] = aux[j++];
            }else {
                array[k] = aux[i++];
            }
        }

    }

    public static void sort(Comparable[] array) {
        // 辅助数组初始化容量
        aux = new Comparable[array.length];
        sort(array, 0, array.length - 1);
    }

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

        int mid = low + (high - low) / 2;
        sort(array, low, mid);
        sort(array, mid+1, high);
        merge(array, low, mid, high);
    }

    public static void main(String[] args) {
        TestExampleData[] testData = TestExampleData.getTestData(100);
        show("排序前", testData);
        sort(testData);
        if (isSorted(testData)) {
            show("排序后", testData);
            return;
        }
        show("排序失败", testData);

    }
}

快速排序

选定一个基数 a，是 <= a的数都位于a的左边，> a 的数都位于a的右边

package com.wy.mycode.algorithm.sort;

import com.wy.mycode.algorithm.sort.common.SortExample;
import com.wy.mycode.algorithm.sort.common.TestExampleData;

/**
 * @author HelloWorld
 * @create 2022/6/5 16:44
 * @email helloworld.dng@gmail.com
 */
public class Quick extends SortExample {
    public static void sort(Comparable[] array) {
        sort(array, 0, array.length - 1);
    }

    private static void sort(Comparable[] array, int low, int high) {
        if (low >= high) {
            return;
        }
        int v = partition(array, low, high);
        sort(array, low, v-1);
        sort(array, v+1, high);
    }


    /**
     * @description 选取数组中的第一个数为基数v，使 < v 的数位于v的右边， >= v 的数位于v的左边
     * @author HelloWorld
     * @create 2022/6/5 16:49
     * @param array
     * @param low
     * @param high
     * @return int
     */
    private static int partition(Comparable[] array, int low, int high) {
        int i = low;
        int j = high + 1;
        Comparable v = array[low];
        while (true) {
            // 找到左边第一个大于 v 的数
            while (less(array[++i], v)) {
                if (i == high) {
                    break;
                }
            }
            // 找到右边第一个小于v的数
            while (less(v, array[--j])) {
                if (j == low) {
                    break;
                }
            }

            if (i >= j) {
                break;
            }
            // 交换它们的位置
            exch(array, i, j);
        }
        // 将 v 放入正确的位置
        exch(array, low, j);
        // 返回 v 的下标
        return j;
    }

    public static void main(String[] args) {
        TestExampleData[] testData = TestExampleData.getTestData(10);
        show("排序前", testData);
        sort(testData);
        if (isSorted(testData)) {
            show("排序后", testData);
            return;
        }
        show("排序失败", testData);
    }
}

冒泡排序

​ 两两比较，交换位置；每次都能确定一个数的最终位置

package com.wy.mycode.algorithm.sort;

import com.wy.mycode.algorithm.sort.common.SortExample;
import com.wy.mycode.algorithm.sort.common.TestExampleData;

/**
 * @author HelloWorld
 * @create 2022/6/5 17:40
 * @email helloworld.dng@gmail.com
 */
public class Bubble extends SortExample {
    public static void sort(Comparable[] array) {
        // 对n个数进行，冒泡排序，最多要进行 n - 1 轮，因为每次都能确定一个数都位置
        for (int i = 1; i < array.length; i++) {
            // 结束循环的标志 是否发生交换
            boolean eachFlag = false;
            // 第二层循环表示 每个数要比较的次数
            for (int j = 0; j < array.length - i; j++) {
                if (less(array[j+1], array[j])) {
                    exch(array, j+1, j);
                    eachFlag = true;
                }
            }
            if (!eachFlag) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        TestExampleData[] testData = TestExampleData.getTestData(6000);
        show("排序前", testData);
        sort(testData);
        if (isSorted(testData)) {
            show("排序后", testData);
            return;
        }
        show("排序失败", testData);
    }
}
HelloWorld. py
关注
专栏目录
排序算法详解（java代码实现）
wadfdhsajd的博客
06-07 238
排序算法大致分为内部排序和外部排序两种内部排序：待排序的记录全部放到内存中进行排序，时间复杂度也就等于比较的次数外部排序：数据量很大，内存无法容纳，需要对外存进行访问再排序，把若干段数据一次读入内存使用内部排序的方法进行排序后写入外存，再将这若干个已经排序的数据进行归并，时间复杂度等于IO(访问外存)的次数​ 交换排序。属于比较简单直观的排序算法，以升序为例（从小到大），每次比较相邻的两个元素，如果左侧元素比右侧的大，则交换两个元素的位置，每次把循环中最大的元素放在循环的最后，像冒泡一样从小到最大。1.1
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
八大排序算法java代码
03-06 92
1.冒泡排序 　　public static void main(String[] args) { int[] arr = {1,4,2,9,5,7,6}; System.out.println("排序前:"+Arrays.toString(arr)); bubbleSort(arr); System.out....
排序算法java源代码_排序算法汇总（java实现，附源代码）
weixin_39956558的博客
02-13 125
整理系统的时候发现了原来写的各种算法的总结，看了一下，大吃一惊，那时候的我还如此用心，具体的算法，有的已经模糊甚至忘记了，看的时候就把内容整理出来，顺便在熟悉一下，以后需要的时候就可以直接过来摘抄了。下面是总结的几个常用的排序算法：插入排序快速排序冒泡排序堆排序计数排序桶排序可能大家对插入排序，快速排序，冒泡排序比较常用，在满足需求的时候也简单一些，下面逐一说一下每个算法的实现方式，不保证是写的最...
排序算法及其Java代码实现
和而不流
02-24 475
排序算法及其Java代码实现排序算法及其Java代码实现 冒泡排序 插入排序 快速排序 选择排序 希尔排序 1.冒泡排序冒泡排序基本概念是： 依次比较相邻的两个数，将小数放在前面，大数放在后面。 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续， 直至比较最后两个数，将小数放前，大数放后。至此第一趟结束， 将最大的数放到了最后。
常见排序算法（Java代码实现）
最新发布
mydesss的博客
04-25 460
常见排序算法
几种常见排序算法JAVA实现.pdf
07-14
几种常见排序算法JAVA实现.pdf
java实现数据结构常见排序算法及详解
11-08
### Java 实现数据结构常见排序算法及详解 #### 排序算法概述 排序算法是计算机科学中的基础概念之一，主要用于将一系列数据按照特定规则进行排列。根据数据处理方式的不同，排序算法大致分为两大类：比较排序与非...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
java排序算法代码_Java实现八种排序算法（代码详细解释）
weixin_42134878的博客
02-16 385
package八大排序算法;importjava.util.Arrays;importorg.junit.Test;/*** 1、插入排序 直接插入排序、希尔排序 折半插入排序* 2、交换排序 冒泡排序、快速排序* 3、选择排序 直接选择排序、堆排序* 4、归并排序* 5、分配排序 基数排序 箱排序**** 八大...
各种排序算法Java代码实现
qq_42368456的博客
06-18 341
一、冒泡排序 ​ public static void bubbleSort(int[] arr){ if(arr == null || arr.length < 2) return; for(int end = arr.length - 1; end > 0; end--){ for(int i = 0; i < end; i++){ if(arr[i...
各类排序算法总结（Java代码实现）
在猿类世界奋斗的小晨
07-07 477
一、   稳定性 稳定性是指待排序的序列中有两个或者两个以上相同的项，排序前和排序后，看这些相同的项的相对位置有没有没发生变化，如果没有发生变化，就是稳定的；如果发生变化，就是不稳定的。 二、   排序分类以及复杂度 2.1、      插入类排序 2.1.1、直接插入排序 最坏时间复杂度：O(n^2) 最好时间复杂度：O(n) 平均时间复杂度：O(n^2) 空间复杂度：O(1)
常见14种经典排序算法（Java代码实现）
数据结构和算法
12-12 1423
尊重原创，转载请标明出处   http://blog.csdn.net/abcdef314159 ，想了解更多算法题可以关注微信公众号“数据结构和算法”，每天一题为你精彩解答。 一，冒泡排序 排序算法其实有很多，冒泡排序基本上算是最简单的一种排序算法了。他的原理就和他的名字一样，通过不断的比较把小的数据不断的往前移。其实冒泡排序有很多变种，我们会一一来看。我们先看下最常见的一种代码 pub...
java 排序的代码_Java 常用的八种排序算法与代码实现
weixin_31487533的博客
02-23 644
Java 常用的九种排序算法与代码实现排序问题一直是程序员工作与面试的重点，今天特意整理研究下与大家共勉！这里列出 8 种常见的经典排序，基本涵盖了所有的排序算法。1. 直接插入排序我们经常会到这样一类排序问题：把新的数据插入到已经排好的数据列中。将第一个数和第二个数排序，然后构成一个有序序列将第三个数插入进去，构成一个新的有序序列。对第四个数、第五个数…… 直到最后一个数，重复第二步。如题所示：...
八大排序算法总结Java代码实现（建议收藏后食用）
xiangjunyes的博客
08-05 1293
排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。假设含有n个记录的序列为{r1，r2，·······，rn},，其相应的关键字分别为{k1，k2，·······，kn}。需要确定1,2·····，n的一种排列 p1，p2，·······，pn，使其相应的关键字满足kp1≤ kp2···· ≤kpn非递增（非递减）关系，即使得序列成为一个按关键字有序的序列{r1，r2，·······，rn}，这样的操作称为排序。......
python基础--十大排序算法
DAICONG’s Blog
02-25 569
排序算法一览表 1、冒泡排序 冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢”浮“到数列的顶端。 1.1、算法描述 比较相邻的元素。如果第一个比第二个大，就交换他们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；​ 针对所有的元素重复
8大Java排序方法(由简入繁)，有代码详解和原理指导
Byyyi耀的博客
01-09 2691
Java8大排序方法
Java常用实现八种排序算法与代码实现
热门推荐
java_atguigu的博客
04-02 1万+
一、交换排序 所谓交换，就是序列中任意两个元素进行比较，根据比较结果来交换各自在序列中的位置，以此达到排序的目的。 1. 冒泡排序 冒泡排序是一种简单的交换排序算法，以升序排序为例，其核心思想是： 从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 轮到下一组相邻元素，执行同样的比较操作，再找下一组，直到没有相邻元素可比较为止，此时最后的元素应是最大的数。 除了每次排序得到的最后一个元素，对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止。
必看：七大排序算法（Java实现 + 详细过程图解）
DEGv587的博客
12-11 1020
必须掌握的算法基础题 - 排序篇 目录 1.直接插入排序 - insertSort 2.希尔排序 - shellSort 3.直接选择排序 - selectSort 4.堆排序 - heapSort 5.冒泡排序 - bubbleSort 6.快速排序 - quickSort 7.归并排序 - mergeSort 1.直接插入排序 - insertSort * 时间复杂度 * 最坏 - O(n^2) 最好 - O(n) * 空间复杂度：O(1) * 稳定性：稳定的 算法思想： ..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值