排序专题java实现

安逸0306

已于 2022-02-08 18:45:24 修改

阅读量57

点赞数

分类专栏：算法总结篇排序专题文章标签：排序算法算法 java

于 2022-02-06 17:07:31 首次发布

本文链接：https://blog.csdn.net/weixin_44021708/article/details/122799086

版权

算法总结篇同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

排序专题

1 篇文章 0 订阅

订阅专栏

本文介绍了四种经典的排序算法：冒泡排序、选择排序、插入排序及其优化版本希尔排序。详细阐述了每种算法的工作原理、代码实现及性能分析，包括时间复杂度和空间复杂度。冒泡排序通过重复交换相邻元素实现排序，选择排序每次选取最小元素放到正确位置，插入排序则将元素逐个插入到已排序部分，希尔排序则是插入排序的优化，通过增量分组减少比较次数。

摘要由CSDN通过智能技术生成

一、冒泡排序

1.冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1算法描述：

比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

1.2代码实现

/**
 * 冒泡排序
 * 
 */
public class maopao {

    public static void main(String[] args) {
        int [] array = {2,1,3,4,7,5,6};
        int [] res = bubbleSort(array);
        for(int i:res){
            System.out.println(i);
        }
    }
    public static int [] bubbleSort(int[] array){
        if(array.length==0){
            return array;
        }
        for(int i = 0;i<array.length;i++){
            for(int j = 0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]) {
                    int temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }

            }
        }
        return array;
    }
}

/**
 * 冒泡排序优化后
 *如果第一次就是排序好的，进行一次比较后 就可以提前结束
 */
public class maopao {

    public static void main(String[] args) {
        int [] array = {2,1,3,4,7,5,6};
        int [] res = bubbleSort(array);
        for(int i:res){
            System.out.println(i);
        }
    }
    public static int [] bubbleSort(int[] array){
        if(array.length==0){
            return array;
        }
        for(int i = 0;i<array.length;i++){
            boolean flag = true;
            for(int j = 0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]) {
                    flag = false;
                    int temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }

            }
            if(flag){
                break;
            }
        }
        return array;
    }
}

1.3算法分析

时间复杂度：最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

空间复杂度：S(n)=O(1)

二、选择排序

2.1表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.2算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

2.3代码实现

public class SelectSort {
    public static void main(String[] args) {
        int [] array = {2,1,3,4,7,5,6};
        int [] res = selectSort(array);
        for(int i:res){
            System.out.println(i);
        }
    }
    public static int [] selectSort(int [] array){
        if(array.length==0){
            return array;
        }
        for(int i = 0;i<array.length-1;i++){
            int minindex = i;//假设最小值下标
            for(int j = i;j<array.length;j++){
                if(array[j]<array[i]){
                    minindex=j;//记录最小值下表
                }
            }
            int temp = array[i];
            array[i] = array[minindex];
            array[minindex]=temp;
        }
        return array;
    }
}

2.4性能分析

最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

S(n)=O(1)

三、插入排序

3.1插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

3.2代码步骤：

　a、默认从第二个数据开始比较。

　　b、如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入（狡猾）。否则，退出循环

　　c、说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入（交换）。否则退出。

3.3代码实现

/**
 * 插入排序
 *
 */
public class InsertInto {
    public static void main(String[] args) {
        int [] array = {2,1,3,4,7,5,6};
        int [] res = insertsort(array);
        for(int i:res){
            System.out.println(i);
        }
    }

    public static int [] insertsort(int [] array){
        for(int i = 1;i<array.length;i++){
            for(int j =i;j>0;j--){
                if(array[j]<array[j-1]){
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1]=temp;
                }
                else{
                    break;
                }
            }
        }
        return array;
    }
}

三、希尔排序（插入排序的变种版本）

3.1

简单插入算法存在的问题：

当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响

3.2

希尔排序是希尔（Donald Shell）于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止

3.3代码描述

　a、基本上和插入排序一样的道理

　　b、不一样的地方在于，每次循环的步长，通过减半的方式来实现

　　c、说明：基本原理和插入排序类似，不一样的地方在于。通过间隔多个数据来进行插入排序。

3.4代码实现

/**
 * 希尔排序
 */
public class xier {
    public static void main(String[] args) {
        int [] array = {2,1,3,4,7,5,6};
        int [] res = xiersort(array);
        for(int i:res){
            System.out.println(i);
        }
    }

    public static int [] xiersort(int [] array){
        for(int i = array.length/2;i>0;i=i/2){
            //i用来控制步长
            for(int j = i;j<array.length;j++){
                for(int k = j;k>0&&k-i>=0;k-=i){
                    if(array[k]<array[k-i]) {
                        int temp = array[k];
                        array[k] = array[k - i];
                        array[k - i] = temp;
                    }else{
                        break;
                    }
                }
            }
        }
        return array;

    }
}