简单排序算法

最新推荐文章于 2022-11-08 23:49:13 发布

GaoYang8320

最新推荐文章于 2022-11-08 23:49:13 发布

阅读量1.6k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/gaoyang8320/article/details/81938918

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文主要介绍三种简单的排序算法，冒泡排序，选择排序，插入排序。
参考：

冒泡排序

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

举例说明：要排序数组：int[] arr={6,3,8,2,9,1};

第一趟排序：

第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1
第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1
第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 1
第四次排序：8和9比较，8小于9，不交换位置：3 6 2 8 9 1
第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9
第一趟总共进行了5次比较，排序结果： 3 6 2 8 1 9

第二趟排序：

第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9
第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9
第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9
第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9
第二趟总共进行了4次比较，排序结果： 3 2 6 1 8 9

第三趟排序：

第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9
第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 9
第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9
第二趟总共进行了3次比较，排序结果： 2 3 1 6 8 9

第四趟排序：

第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9
第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9
第二趟总共进行了2次比较，排序结果： 2 1 3 6 8 9

第五趟排序：

第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9
第二趟总共进行了1次比较，排序结果： 1 2 3 6 8 9

最终结果：1 2 3 6 8 9

冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
用时间复杂度来说：

如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。
如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：冒泡排序的最坏时间复杂度为：O(n2) 。

综上所述：冒泡排序总的平均时间复杂度为：O(n2) （n的平方）。

代码实现

public class BubbleSort {
    public static void bubbleSort(int[] array){
        int i,j,k;
        int len=array.length;
        int temp;
        for (i=0;i<len;i++){
            for (j=0;j<len-i-1;j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
                /**
                 * 显示每次排序结果，便于理解
                 */
                for (k = 0; k < len; k++)
                    System.out.print(array[k] + " ");
                System.out.println();
            }
            System.out.println("*****************");
        }
    }
    public static void main(String[] argus){
        int[] array={6,3,8,2,9,1};
        bubbleSort(array);
    }
}

输出为：

3 6 8 2 9 1 
3 6 8 2 9 1 
3 6 2 8 9 1 
3 6 2 8 9 1 
3 6 2 8 1 9 
*****************
3 6 2 8 1 9 
3 2 6 8 1 9 
3 2 6 8 1 9 
3 2 6 1 8 9 
*****************
2 3 6 1 8 9 
2 3 6 1 8 9 
2 3 1 6 8 9 
*****************
2 3 1 6 8 9 
2 1 3 6 8 9 
*****************
1 2 3 6 8 9 
*****************
*****************

Process finished with exit code 0

选择排序

选择排序是对冒泡排序的改进，它的比较次数与冒泡排序相同，但交换次数要小于冒泡排序。当数据量较大时，效率会有很大的提升，但时间复杂度仍为O(n*n)。

基本原理如下：对于给定的一组记录，经过第一轮比较后得到最小的记录，然后将该记录与第一个记录的位置进行交换；接着对不包括第一个记录以外的其他记录进行第二轮比较，得到最小的记录并于第二个记录进行位置交换；重复该过程，直到进行比较的记录只有一个为止。
举例：数组 int[] arr={5,2,8,4,9,1};

第一趟排序：原始数据：5 2 8 4 9 1
最小数据1，把1放在首位，也就是1和5互换位置，
排序结果：1 2 8 4 9 5

第二趟排序：
第1以外的数据{2 8 4 9 5}进行比较，2最小，
排序结果：1 2 8 4 9 5

第三趟排序：
除1、2以外的数据{8 4 9 5}进行比较，4最小，8和4交换
排序结果：1 2 4 8 9 5

第四趟排序：
除第1、2、4以外的其他数据{8 9 5}进行比较，5最小，8和5交换
排序结果：1 2 4 5 9 8

第五趟排序：
除第1、2、4、5以外的其他数据{9 8}进行比较，8最小，8和9交换
排序结果：1 2 4 5 8 9

选择排序的时间复杂度：简单选择排序的比较次数与序列的初始排序无关。假设待排序的序列有 N 个元素，则比较次数永远都是N (N - 1) / 2。而移动次数与序列的初始排序有关。当序列正序时，移动次数最少，为 0。当序列反序时，移动次数最多，为3N (N - 1) / 2。
所以，综上，简单排序的时间复杂度为 O(N*N)

代码实现

public class SelectSort {

    public static void selectSort(int[] array){
        int i,j,k;
        int len=array.length;
        int temp;
        int minIndex;
        for (i=0;i<len-1;i++){
            minIndex=i;
            for (j=i+1;j<len;j++)
                if (array[j]<array[minIndex])
                    minIndex=j;
            temp=array[minIndex];
            array[minIndex]=array[i];
            array[i]=temp;

            /**
             * 打印排序结果，便于理解
             */
            System.out.println("**************");
            for (k = 0; k < len; k++)
                System.out.print(array[k] + " ");
            System.out.println();
        }
    }

    public static void main(String[] args){
        int[] arr={5,2,8,4,9,1};
        selectSort(arr);
    }
}

输出为：

**************
1 2 8 4 9 5 
**************
1 2 8 4 9 5 
**************
1 2 4 8 9 5 
**************
1 2 4 5 9 8 
**************
1 2 4 5 8 9 

Process finished with exit code 0

插入排序

插入排序是简单排序中最快的排序算法，虽然时间复杂度仍然为O(n*n)，但是却比冒泡排序和选择排序快很多。

对于给定的一组记录，初始时假设第一个记录自成一个有序序列，其余记录为无序序列。接着从第二个记录开始，按照记录的大小将当前处理的记录插入到其之前的有序序列中，直至最后一个记录插入到有序序列中为止。

可以类比玩扑克牌的过程：先拿一张5在手里，再摸到一张4，比5小，插到5前面，摸到一张6，比5大，插到5后面，摸到一张8，比6大，插到6后面…..

例子
待比较数据：7, 6, 9, 8, 5,1

第一轮：指针指向第二个元素6，假设6左面的元素为有序的，将6抽离出来，形成7,,9,8,5,1，从7开始，6和7比较，发现7>6。将7右移，形成,7,9,8,5,1，6插入到7前面的空位，结果：6,7,9,8,5,1
第二轮：指针指向第三个元素9，此时其左面的元素6,7为有序的，将9抽离出来，形成6,7,_,8,5,1，从7开始，依次与9比较，发现9左侧的元素都比9小，于是无需移动，把9放到空位中，结果仍为：6,7,9,8,5,1
第三轮：指针指向第四个元素8，此时其左面的元素6,7,9为有序的，将8抽离出来，形成6,7,9,,5,1，从9开始，依次与8比较，发现8<9，将9向后移，形成6,7,,9,5,1，8插入到空位中，结果为：6,7,8,9,5,1
第四轮：指针指向第五个元素5，此时其左面的元素6,7,8,9为有序的，将5抽离出来，形成6,7,8,9,,1，从9开始依次与5比较，发现5比其左侧所有元素都小，5左侧元素全部向右移动，形成,6,7,8,9,1，将5放入空位，结果5,6,7,8,9,1。
第五轮：同上，1被移到最左面，最后结果：1,5,6,7,8,9。

时间复杂度，由于仍然需要两层循环，插入排序的时间复杂度仍然为O(n*n)。

比较次数：在第一轮排序中，插入排序最多比较一次；在第二轮排序中插入排序最多比较二次；以此类推，最后一轮排序时，最多比较N-1次，因此插入排序的最多比较次数为1+2+…+N-1=N*(N-1)/2。尽管如此，实际上插入排序很少会真的比较这么多次，因为一旦发现左侧有比目标元素小的元素，比较就停止了，因此，插入排序平均比较次数为N*(N-1)/4。

移动次数：插入排序的移动次数与比较次数几乎一致，但移动的速度要比交换的速度快得多。

综上，插入排序的速度约比冒泡排序快一倍（比较次数少一倍），比选择排序还要快一些，对于基本有序的数据，插入排序的速度会很快，是简单排序中效率最高的排序算法。

代码实现：

public class InsertSort {
    public static void insertSort(int[] array){
        int i,j,k;
        int len=array.length;
        int temp;
        for (i=1;i<len;i++){
            temp=array[i];
            j=i;
            if (array[j-1]>temp)
                while (j>=1 && array[j-1]>temp){
                    array[j]=array[j-1];
                    j--;
                }
            array[j]=temp;

            /**
             * 打印排序结果，便于理解
             */
            System.out.println("**************");
            for (k = 0; k < len; k++)
                System.out.print(array[k] + " ");
            System.out.println();
        }
    }

    public static void main(String[] args){
        int[] arr={7, 6, 9, 8, 5,1};
        insertSort(arr);
    }

输出为：

**************
6 7 9 8 5 1 
**************
6 7 9 8 5 1 
**************
6 7 8 9 5 1 
**************
5 6 7 8 9 1 
**************
1 5 6 7 8 9 

Process finished with exit code 0

GaoYang8320

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
简单排序算法

本文主要介绍三种简单的排序算法，冒泡排序，选择排序，插入排序。参考：https://www.cnblogs.com/shen-hua/p/5422676.htmlhttps://www.cnblogs.com/shen-hua/p/5424059.htmlhttps://www.cnblogs.com/bjh1117/p/8335628.htmlhttps://www.cnblog...
复制链接

扫一扫