十大排序算法-1

梦里梦外; 2023-10-02 18:53 23阅读 0赞

## 1.冒泡排序 ##

#### 1.1 简介 ####

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

#### 1.2 步骤 ####

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#### 1.3 演示 ####

![91447414e08f37fcef006493494825e8.gif][]

#### 1.4 代码实现 ####

/**
         * 冒泡排序
         * @param array 需要排序的数组
         * @return 返回排序好的数组
         */
        @Test
        public int[] test1(int[] array){
            int[] arr = Arrays.copyOf(array, array.length);
            for (int i = 0; i < arr.length; i++) {
    //            设置标记，若为true,表示没有排序，跳出
                boolean flag=true;
                for (int j = 0; j < arr.length; j++) {
                    if (arr[j+1]>arr[j]){
                        int temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
    //                    进入交换，表示排序未完成，所以将标记设为flase
                        flag=false;
                    }
                }
                if(flag){
                    break;
                }
            }
            return arr;
        }

## 2.选择排序 ##

#### 2.1 简介 ####

选择排序（Selection sort）是一种简单直观的排序算法。 它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。 以此类推，直到全部待排序的数据元素的个数为零。 选择排序是不稳定的排序方法。

#### 2.2 步骤 ####

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

#### 2.3 演示 ####

![b5ea40b609e893d8d30587c0930197e6.gif][]

#### 2.4 代码实现 ####

/**
         * 快速排序
         * @param array 需要排序的数组
         * @return 返回排序好的数组
         */
        @Test
        public int[] test2(int[] array){
            int[] arr = Arrays.copyOf(array, array.length);
    //        一共循环n-1轮
            for (int i = 0; i < arr.length-1; i++) {
    //            每一轮查找的次数为n-i
                int min = i;
                for (int j = i+1; j < arr.length; j++) {
                    if (arr[j]<arr[min]){
    //                    记录当前找到的最小值的下标
                        min=j;
                    }
                }
    //            将找到的最小值和当前i的位置交换
                if (min!=i){
                    int temp=arr[i];
                    arr[i]=arr[min];
                    arr[min]=temp;
                }
            }
            return arr;
        }

## 3.插入排序 ##

#### 3.1 简介 ####

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

#### 3.2 步骤 ####

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。

#### 3.3 演示 ####

![88968b0e364fc8891ebe70e62d8001b6.gif][]

#### 3.4 代码 ####

/**
         * 插入排序
         * @param array 需要排序的数组
         * @return 返回排序好的数组
         */
        @Test
        public int[] test3(int[] array){
            int[] arr = Arrays.copyOf(array, array.length);
    //        从下标为1的地方开始插入，因为下标为零只有一个元素，默认为有序的
            for (int i = 1; i < arr.length; i++) {
    //            temp为需要插入的数
                int temp = arr[i];
                int j=i;
                while (j>0&&temp<arr[j-1]){
                    arr[j]=arr[j-1];
                    j--;
                }
    //            存在比他小的数插入
                if (j!=i){
                    arr[i]=temp;
                }
            }
            return arr;
        }

## 4.希尔排序 ##

#### 4.1 简介 ####

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

*  插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
 *  但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

#### 4.2 步骤 ####

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

按增量序列个数 k，对序列进行 k 趟排序；

每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

#### 4.3 演示 ####

![3a7d7b1e2ae4045d7d16ce8d6192d690.gif][]

#### 4.4 代码 ####

/**
         * 希尔排序
         * @param arr 需要排序的数组
         * @return 返回排序好的数组
         */
        @Test
        public int[] test4(int[] arr) {
            int length = arr.length;
            int temp;
            for (int step = length / 2; step >= 1; step /= 2) {
                for (int i = step; i < length; i++) {
                    temp = arr[i];
                    int j = i - step;
                    while (j >= 0 && arr[j] > temp) {
                        arr[j + step] = arr[j];
                        j -= step;
                    }
                    arr[j + step] = temp;
                }
            }
            return arr;
        }

[91447414e08f37fcef006493494825e8.gif]: https://img-blog.csdnimg.cn/img_convert/91447414e08f37fcef006493494825e8.gif
[b5ea40b609e893d8d30587c0930197e6.gif]: https://img-blog.csdnimg.cn/img_convert/b5ea40b609e893d8d30587c0930197e6.gif
[88968b0e364fc8891ebe70e62d8001b6.gif]: https://img-blog.csdnimg.cn/img_convert/88968b0e364fc8891ebe70e62d8001b6.gif
[3a7d7b1e2ae4045d7d16ce8d6192d690.gif]: https://img-blog.csdnimg.cn/img_convert/3a7d7b1e2ae4045d7d16ce8d6192d690.gif