数据结构之排序算法（Java代码实现）

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

排序算法的作用就是将无序的数组按升序或降序排列。

一、选择排序

选择排序，就是在每一次大小比较中，为数组的每个位置选出大小适当的值，比如：如果要将数组进行升序排列，那么要为数组的第一个位置选出最小的值，第二个位置选出次大的值。
假设需要对一个整形数组{45, 38, 66, 90, 88, 10, 25}进行升序排序，选择排序的步骤如下：
第一步：为第一个位置（数组索引为0）选出最小的值
（1）45 > 38，45与38调换位置，{38, 45, 66, 90, 88, 10, 25}
（2）38 < 66，位置不变，{38, 45, 66, 90, 88, 10, 25}
（3）38 < 90，位置不变，{38, 45, 66, 90, 88, 10, 25}
（4）38 < 88，位置不变，{38, 45, 66, 90, 88, 10, 25}
（5）38 > 10，38与10调换位置，{10, 45, 66, 90, 88, 38, 25}
（6）10 < 25，位置不变，{10, 45, 66, 90, 88, 38, 25}
对应的Java代码如下：

for (int i = 0, j = i + 1; j < arr.length; j++) {
    if (arr[i] > arr[j]) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

第二步：为第二个位置（数组索引为1）选出最第二小的值
此时不用与第一个位置比较，相当于在由第二个位置以后的元素组成的数组中，为第二个位置选出最小值。对应Java代码如下：

for (int i = 1, j = i + 1; j < arr.length; j++) {
    if (arr[i] > arr[j]) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

以此类推，直到第n（n = arr.length - 1）个位置选出了第n小的值。
以上步骤（也就是选择排序的全过程）对应的Java代码如下：

for (int i = 0; i < arr.length - 1; i++) {
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[i] > arr[j]) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

二、冒泡排序

冒泡排序，就是数组中每两个相邻元素进行比较，将较大值或较小值不停地推向数组的最后。这个算法的名字由来是因为越小或越大的元素会经由交换慢慢“浮”到数组后面，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
假设需要对一个整形数组{45, 38, 66, 90, 88, 10, 25}进行升序排序，冒泡排序的步骤如下：
第一步：将最大值冒泡到数组最后一个位置
（1）45 > 38，交换位置，{38, 45, 66, 90, 88, 10, 25}
（2）45 < 66，不变，{38, 45, 66, 90, 88, 10, 25}
（3）66 < 90，不变，{38, 45, 66, 90, 88, 10, 25}
（4）90 > 88，交换位置，{38, 45, 66, 88, 90, 10, 25}
（5）90 > 10，交换位置，{38, 45, 66, 88, 10, 90, 25}
（6）90 > 25，交换位置，{38, 45, 66, 88, 10, 25, 90}
对应Java代码如下：

for (int i = 0, j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
    }
}

第二步：将次大值冒泡到数组倒数第二个位置

for (int i = 1, j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
    }
}

以此类推，直到倒数第n（n < arr.length）个位置选出了第n大的值。
以上步骤（也就是冒泡排序的全过程）对应的Java代码如下：

for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

三、插入排序

插入排序，是让长度为n的数组的前m个元素组成的局部数列都保持升序或降序，不断往局部数列中插入数组的元素，直到m = n。
插入排序的思路如下：
（1）从第一个元素开始，该元素可以认为已经排好序。
（2）取出下一个元素，在已经排好序的元素序列中从后往前扫描进行比较。
（3）如果该元素(已排序) 大于新元素，则将该元素移到下一位置。
（4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
（5）将新元素插入到该位置后面。
（6）重复步骤2~5。
假设需要对一个整形数组{45, 38, 66, 90, 88, 10, 25}进行升序排序，插入排序的步骤如下：
第一步：局部数列中加入数组的第一个元素45，符合升序排列；
第二步：局部数列中加入数组的第二个元素38，{45, 38}，不符合升序排列，比较一次，交换一次，变为{38, 45}；
第三步：{38, 45, 66}符合升序，位置不变；
第四步：{38, 45, 66, 90}符合升序，位置不变；
第五步：{38, 45, 66, 90, 88}不符合升序，其重新排序如下：{38, 45, 66, 88, 90}
第五步由于88比前三个元素都大，看不出元素从后往前的移动过程。接着看第六步。
第六步：{38, 45, 66, 88, 90, 10}不符合升序，其重新排序过程为：
90 > 10，{38, 45, 66, 88, 10, 90}
88 > 10，{38, 45, 66, 10, 88, 90}
66 > 10，{38, 45, 10, 66, 88, 90}
45 > 10，{38, 10, 45, 66, 88, 90}
38 > 10，{10, 38, 45, 66, 88, 90}
比较6次，交换6次。
对应Java代码如下：

int i = 5;
int localMax = arr[i];
for (int j = i - 1; j >= 0; j--) {
    if (arr[j] > localMax) {
        int temp = arr[j];
        arr[j] = localMax;
        arr[j + 1] = temp;
    }
    localMax = arr[j];
}

得到排序结果：10 38 45 66 88 90 25
前五个元素组成的数列按升序排序了。
以此类推，直到前n（n < arr.length）个位置都按升序排序。
以上步骤（也就是插入排序的全过程）对应的Java代码如下：

@Test
public void insertSort() {
    int[] arr = {45, 38, 66, 90, 88, 10, 25};

    for (int i = 1; i < arr.length; i++) {
        int localMax = arr[i];
        for (int j = i - 1; j >= 0; j--) {
            if (arr[j] > localMax) {
                int temp = arr[j];
                arr[j] = localMax;
                arr[j + 1] = temp;
            }
            localMax = arr[j];
        }
    }

    printArr(arr);

}

以下为可用于单元测试的Java代码：

import org.junit.Test;

public class SortTest {

    // 选择排序 升序
    @Test
    public void selectSortAsc() {
        int[] arr = {45, 38, 66, 90, 88, 10, 25};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        printArr(arr);
    }

    // 选择排序 降序
    @Test
    public void selectSortDesc() {
        int[] arr = {45, 38, 66, 90, 88, 10, 25};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] < arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        printArr(arr);
    }

    // 冒泡排序 升序
    @Test
    public void bubbleSortAsc() {
        int[] arr = {45, 38, 66, 90, 88, 10, 25};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        printArr(arr);
    }

    // 冒泡排序 降序
    @Test
    public void bubbleSortDesc() {
        int[] arr = {45, 38, 66, 90, 88, 10, 25};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] < arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        printArr(arr);
    }

    // 插入排序 升序
    @Test
    public void insertSortAsc() {
        int[] arr = {45, 38, 66, 90, 88, 10, 25};

        for (int i = 1; i < arr.length; i++) {
            int localMax = arr[i];
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] > localMax) {
                    int temp = arr[j];
                    arr[j] = localMax;
                    arr[j + 1] = temp;
                }
                localMax = arr[j];
            }
        }

        printArr(arr);

    }

    // 插入排序 降序
    @Test
    public void insertSortDesc() {
        int[] arr = {45, 38, 66, 90, 88, 10, 25};

        for (int i = 1; i < arr.length; i++) {
            int localMax = arr[i];
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] < localMax) {
                    int temp = arr[j];
                    arr[j] = localMax;
                    arr[j + 1] = temp;
                }
                localMax = arr[j];
            }
        }

        printArr(arr);

    }

    // 打印数组
    private void printArr(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

}

选择排序、冒泡排序和插入排序的时间复杂度都是O(n^2)
以下代码测试了极端情况下这三种算法进行比较和排序的次数：

import org.junit.Test;

public class SortCountTest {

    // 选择排序 降序
    @Test
    public void selectSortDescCount() {
        int cnt_compare = 0;
        int cnt_exchange = 0;

        int[] arr = new int[50];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                cnt_compare ++;
                if (arr[i] < arr[j]) {
                    cnt_exchange ++;
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        printArr(arr);
        System.out.println("比较次数：" + cnt_compare);
        System.out.println("交换次数：" + cnt_exchange);
    }


    // 冒泡排序 降序
    @Test
    public void bubbleSortDescCount() {
        int cnt_compare = 0;
        int cnt_exchange = 0;

        int[] arr = new int[50];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                cnt_compare ++;
                if (arr[j] < arr[j + 1]) {
                    cnt_exchange ++;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        printArr(arr);
        System.out.println("比较次数：" + cnt_compare);
        System.out.println("交换次数：" + cnt_exchange);
    }

    // 插入排序 降序
    @Test
    public void insertSortDescCount() {
        int cnt_compare = 0;
        int cnt_exchange = 0;

        int[] arr = new int[50];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        for (int i = 1; i < arr.length; i++) {
            int localMin = arr[i];
            for (int j = i - 1; j >= 0; j--) {
                cnt_compare ++;
                if (arr[j] < localMin) {
                    cnt_exchange ++;
                    int temp = arr[j];
                    arr[j] = localMin;
                    arr[j + 1] = temp;
                }
                localMin = arr[j];
            }
        }

        printArr(arr);
        System.out.println("比较次数：" + cnt_compare);
        System.out.println("交换次数：" + cnt_exchange);

    }

    // 打印数组
    private void printArr(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

}

三个单元测试的结果都是：
比较次数：1225
交换次数：1225
可以看出三种算法都需要执行N*N/2次比较和N*N/2次交换，算法的时间复杂度均为O(N^2)。

西丽沙河尚
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【数据结构】排序算法（Java实现）
Slimshady的博客
06-26 513
文章目录排序算法排序算法说明算法复杂度总结冒泡排序（Bubble Sort）选择排序（Selection Sort）插入排序（Insertion Sort）希尔排序（Shell Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort） 排序算法 排序算法说明 排序的定义 对一序列对象根据某个关键字进行排序。 术语说明 稳定 ：如果a原本在b前面，并且a=b，则排序之后a仍然在b的前面； 不稳定 ：如果a原本在b的前面，而a=b，则排序之后a可能会出现在b的后面
数据结构----排序算法总结（Java）
ITCSDN_的博客
08-29 693
排序算法总结---建议收藏排序算法概述一：冒泡排序（BubbleSorting） 1.冒泡排序简要概述 2.冒泡排序图解 3.代码实现 排序算法概述   所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。 一：冒泡排序（BubbleSo
数据结构-排序基础代码
IT1995的博客
12-17 5299
数据结构-排序基础代码
【数据结构】八大排序算法-代码实现+复杂度分析+稳定性分析+总结
chuxinchangcun的博客
09-27 902
注意：1.对于快速排序:如果加了三数取中 + 三路归并 最坏就不是O(N^2)2.为了绝对的速度选快排，为了省空间选堆排，为了稳定性选归并3.时间复杂度:O(N*logN)，额外空间复杂度低于O(N)，且稳定的基于比较的排序是不存在的。
【数据结构】排序算法大全（快速、堆、归并、插入、折半、希尔、冒泡、计数、基数）各算法比较、解析＋完整代码
最新发布
m0_61628700的博客
05-27 551
5.当low==high时完成遍历，将基准元素放入low指针所指的地方，此时基准元素已经排序完成；若左右孩子一样大，优先和左孩子换，建堆时是稳定的，但是在排序时，堆顶和堆底互换，不稳定。对于小根堆，新元素放到表尾（堆底），与父节点对比，若新元素比父节点更加小，则互换。2.随机选取一个元素。2.遍历序列，将比基准元素小的放在基准元素的左边，比基准元素大的放在右边；对于大根堆，新元素放到表尾，与父节点对比，若新元素比父节点更加大，则互换。3.对比i，j所指元素，更小的先加入长序列，并且更小的元素所在指针加一；
数据结构各类排序算法详解+代码分析
LRY89757的博客
06-30 1918
数据结构各类排序算法详解+代码分析 前言 不知不觉，数据结构已经学完了，博主也马上大二了????时间过得太快了????，但是数据结构学得确实不太好，楼主花了将近一天的时间整理了一下排序的有关算法。希望对大家也有所帮助。 目录数据结构各类排序算法详解+代码分析前言插入排序基本思想直接插入排序折半插入排序二路排序希尔排序快速排序选择排序基本思想简单选择排序锦标赛排序堆排序堆定义建堆堆排序算法代码解析归并排序基数排序总结排序方法比较方法选择写在后面 插入排序 基本思想 每步将一个待排序记录，按其关键码大小，插
【数据结构】——八大排序（详解+图+代码详解）看完你会有一个全新认识
m0_74092462的博客
04-12 1372
排序在生活中是非常重要的，所以排序在数据结构中也占有很大的地位，相信大家可能被这些排序弄得比较混淆或者对某个排序原理没有弄清，相信看完本篇会对你有所帮助！排序的概念与应用排序概念排序：排序就是使一串数据，按某个或者某些关键字的大小，递减或者递增排列起来的操作稳定性：在排序的过程中，可能存在两个或者以上的关键字相等的记录，排序的结果可能会不一样，这里就分成了稳定和不稳定。
数据结构与算法：12种排序全代码
qq_42667970的博客
12-13 2471
排序 文章目录排序1.冒泡排序思路：优化：交换过程：C语言代码：优化后：2.直接插入排序思路：过程：代码：3.折半插入排序折半查找代码4.希尔插入排序思路：排序过程：代码5.选择排序思路:排序过程：代码6.鸡尾酒排序法思路:代码7.堆排序思路：代码8.归并排序思路：代码9.快速排序思路：代码10.计数排序思想：代码11.桶排序思路：代码12.基数排序思路过程：代码代码 各种排序算法的时间复杂度和空...
数据结构与算法代码详解JAVA版
08-26
本资源"数据结构与算法代码详解JAVA版"聚焦于使用Java语言来理解和实现这些核心概念。 首先，数据结构是组织和存储数据的方式，它为高效地执行各种操作提供了便利。常见的数据结构包括数组、链表、栈、队列、树（如...
数据结构与算法（Java代码实现）.zip
10-22
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关重要..."数据结构与算法（Java代码实现）"的压缩包很可能包含了上述各种数据结构和算法的Java实现，通过阅读和运行这些代码，可以进一步加深理解和掌握。
java数据结构排序算法之树形选择排序详解
08-30
java数据结构排序算法之树形选择排序详解 树形选择排序是一种高效的排序算法，它可以降低比较次数，提高排序效率。下面我们将详细介绍树形选择排序的原理、实现技巧与相关注意事项。 树形选择排序的原理： 树形...
java数据结构排序算法之归并排序详解
08-30
Java数据结构排序算法之归并排序详解 Java数据结构排序算法之归并排序是基于合并的思想，将两个或两个以上有序表合并成一个新的有序表。这种方法被称作是2-路归并排序（基本操作是将待排序列中相邻的两个有序子...
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8829
数据结构中最全的排序算法（C语言实现）
【数据结构】--八大排序算法【完整版】
m0_74044018的博客
07-23 1801
数据结构中的8大排序：直接插入排序，希尔排序...他们的具体实现，递归与非递归实现等
【数据结构】排序算法总结及代码实现
热门推荐
如风逝去
07-23 1万+
我们通常说的排序算法指的是内部排序算法，即数据在内存中进行排序。 首先先来看一下我们学过的排序都有什么？ 排序可以大的方面分为比较排序和非比较排序？ 比较排序有： 1、冒泡排序 2、选择排序 3、插入排序 （1）二分插入排序 （2）希尔排序 4、归并排序 5、堆排序 6、快速排序 非比较排序有： 1、计数排序 2、基数排序 3、桶排序 我们先对各种排序进行对比： ...
数据结构学习【各种排序算法代码实现】
toro180的博客
02-09 1235
数据结构学习【各种排序算法代码实现】
排序算法
clearLB的博客
09-11 299
冒泡算法 冒泡算法的基本思想是： 比较相邻的元素，如果第一个比第二个大，就交换他们两个 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这一步做完后，最后的元素会是最大的数 针对所有的元素重复以上的步骤，除了最后一个 冒泡排序代码： class Solution { public: vector<int> bubblingSort(vector<int> nums) { for (int i = 0; i < nums.size() - 1; i++)
数据结构中常见的排序及代码演示
C/C++ 数据结构与算法 Linux MySQL 计算机网络 实战项目 LeetCode刷题 牛客网刷题 剑指Offer等
10-11 158
常见的数据结构中的排序算法有冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序等冒泡排序：比较相邻的元素，如果前一个比后一个大，就交换它们的位置，一轮下来可以将最大的元素放到最后面。时间复杂度为O(n^2)
【数据结构】——常见排序算法（演示图+代码+算法分析）
weixin_53269843的博客
07-01 1328
文章主要对插入排序算法、希尔排序算法、选择排序算法、冒泡排序算法、堆排序算法、快速排序算法进行分析，包含每个算法的基本思想、代码、演示图和算法分析，其中快速排序 有三数取中、挖坑法、前后指针法，递归实现和非递归实现。
Java实现的数据结构与算法实战
“数据结构与算法 java版”是关于编程领域中的核心主题——数据结构和算法的书籍，特别针对Java编程语言进行了深入讲解。本书涵盖了Java的基础知识，如基本数据类型、流程控制、字符串和数组，以及面向对象特性，如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值