java萌新的进化旅程07

最新推荐文章于 2024-08-06 00:00:00 发布

YaeSakuraZR

最新推荐文章于 2024-08-06 00:00:00 发布

阅读量203

点赞数 2

分类专栏： java 文章标签：排序冒泡排序选择排序直接插入排序 shell排序

本文链接：https://blog.csdn.net/YaeSakuraZR/article/details/84372916

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

四种排序方法

本篇博客主要介绍排序的四种基本方法：冒泡排序、选择排序、直接插入排序、shell排序

一、冒泡排序

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

冒泡排序的流程图
在这里插入图片描述
冒泡排序一共比较n-1趟

冒泡排序的例题

public  static void bubbleSort(){
        int arr[]={3,2,6,4,5,1};
        int max=0;
        int tmp=arr.length;
        for (int i = 0; i < tmp-1; i++) {
            for (int j = 0; j <tmp-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    max=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=max;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

由此可见
冒泡排序的时间复杂度：O（n^2）
空间复杂度：O（1）
是否为稳定排序：是

在这里细心的人可能会发现一个问题，冒泡排序中有时候会对两个本就有序的值比较，例如上面流程图中的第2趟第三列，3<4，但是仍然进行了一次比较，这样做比较浪费时间，所以下面对冒泡进行优化。
首先，思路是这样的，设置一个标记位来标记是否发生了交换，如果没有发生交换就提前结束，具体实施如下：

public  static void bubbleSort(){
        int arr[]={3,2,6,4,5,1};
        int max=0;
        int tmp=arr.length;
        for (int i = 0; i < tmp-1; i++) {
            boolean swap=false;
            for (int j = 0; j <tmp-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    max=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=max;
                    swap=true;
                }
            }
            if(!true){
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }

冒泡排序优化后的最好情况的时间复杂度：O（n）

二、选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

选择排序的流程图
在这里插入图片描述
选择排序一共比较n-1趟
在这里可以看出选择排序与冒泡排序十分相似，这也是很多初学者容易混淆的地方，这两种排序的代码也很相近。

选择排序的例题

    public static void selectSort(int arr[]) {
        int max=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j <arr.length ; j++) {
                if(arr[i]>arr[j]){
                    max=arr[i];
                    arr[i]=arr[j];
                    arr[j]=max;

                }
            }
        }
        System.out.print(Arrays.toString(arr));
    }

由此可见
选择排序的时间复杂度：O（n^2）
空间复杂度：O（1）
是否为稳定排序：否

三、直接插入排序

直接插入排序(Straight Insertion Sort)是一种最简单的排序方法，其基本操作是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。
这个东西可能不太好理解，这里举个例子：
在日常生活中，经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中。例如:一组从小到大排好顺序的数据列{1,2,3,4,5,6,7,9,10}，通常称之为有序列，我们用序号1,2,3，…表示数据的位置，欲把一个新的数据8插入到上述序列中。
完成这个工作的步骤:
①确定数据"8"在原有序列中应该占有的位置序号。数据"8"所处的位置应满足小于或等于该位置右边所有的数据，大于其左边位置上所有的数据。
②将这个位置空出来，将数据"8"插进去。

直接插入排序流程图
在这里插入图片描述

直接插入排序的例题

    public static void insertSort(int[] arr) {
        int tmp=0;
        for (int i = 1; i <arr.length ; i++) {
            tmp=arr[i];
            int j=0;
            for (j = i-1;j>=0; j--) {
                if(arr[j]>tmp){
                    arr[j+1]=arr[j];
                }else{
                    break;
                }
            }
            arr[j+1]=tmp;
        }
        System.out.println(Arrays.toString(arr));
    }

由此可见
直接插入排序的时间复杂度：时间复杂度：
无序：0(n^2)
有序：0(n)
越有序越快
空间复杂度：O（1）
是否为稳定排序：否

四、shell排序

shell排序的核心思想是将一组数组拆分为几组，然后这几组内进行排序。
在这里插入图片描述
如果有10000个数据，普通排序要进行10000^2次，而shell排序则只用进行1000000次
shell排序的流程图

shell排序的例题

public class ShellSort {
    public static void main(String[] args) {
        int arr[]={65,5,23,47,9,11,3,17,10,14,45,62,58,19,36};
       shellSort(arr);
    }

    public static void shellSort(int arr[]) {
        int drr[]={5,3,1};
        for (int i = 0; i <drr.length ; i++) {
            shell(arr,drr[i]);
        }
        System.out.println(Arrays.toString(arr));
    }

    public static void shell(int arr[],int gap) {
        int tmp;
        for (int i = gap; i <arr.length ; i++) {
            tmp=arr[i];
            int j=0;
               for (j = i-gap;j>=0; j-=gap) {
                   if(arr[j]>tmp){
                       arr[j+gap]=arr[j];
                   }else{
                        break;
                   }
                }
                arr[j+gap]=tmp;
            }
        }
}