Java中的三个基础排序(冒泡排序,直接插入排序,选择排序)

原创 2018年04月17日 16:07:35

Java中有很多的排序方法,比如:冒泡排序、快速排序、选择排序、插入排序、希尔排序等很多的排序方法,我们来看一下三个比较基础的关于数组的排序方法:冒泡排序,直接插入排序和选择法排序。

冒泡排序:一次比较两个元素,如果第一个元素比第二个大,那么他们交换位置,依次进行比较相邻的两个元素,从开始的第一个到结尾的最后两个相邻元素的比较完成后,最后一个元素应为该数组中最大的数;然后重复以上步骤(除了确定以后的元素),直到没有元素进行比较的时候,此时的数组已经排序完成。
比如说我现在要比较这么一个数组:

int[] array = {14,16,7,28,99,54,1,10};

那么它所实现的过程是如何呢?我以画图的形式表达出来:
第一趟的比较,确定了最大数99
第一趟的比较,确定了最大数99

第二趟的比较,确定了最大数54和99
第二趟的比较,确定了最大数54和99

第三趟的比较,确定了最大数28,54和99
第三趟的比较,确定了最大数28,54和99

第四趟的比较,确定了最大数16,28,54和99
第四趟的比较,确定了最大数16,28,54和99

第五趟的比较,确定了最大数14,16,28,54和99
第五趟的比较,确定了最大数14,16,28,54和99

第六趟的比较,确定了最大数10,14,16,28,54和99
第六趟的比较,确定了最大数10,14,16,28,54和99

最后一趟则排序完成,那么我们如果想用代码实现该排序方法,应该怎么实现?
此时我们需要两个for循环,外循环控制该数组排序的趟数
内循环控制每一趟排序的次数

/**
 * 冒泡排序
 * @author 王瑜
 *冒泡排序的实现
 */
public class WangYu {
    public static void show(int[] array){//遍历数组
        for(int k = 0;k < array.length;k++){
            System.out.print(array[k]+ "   ");
        }
    }
    public static void bubbleSort(int[] array){
        int tmp = 0;//定义一个中间变量
        for(int i = 0;i < array.length;i++){//外层循环控制排序的趟数
            for(int j = 0; j < array.length -1 -i;j++){//内层循环控制每一趟排序的次数
                if(array[j] > array[j+1]){//如果前一个数比后一个数大,则交换位置用中间变量
                tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {//利用写的功能函数进行测试
        int[] array = {14,16,7,28,99,54,1,10};
        bubbleSort(array);
        show(array);
    }
}

输出为:

1   7   10   14   16   28   54   99

如上所示,这就是冒泡排序的思想及实现方法
那么冒泡排序是否稳定呢?
理所当然是稳定的,因为它是相邻的两个元素依次进行比较,从未有跳跃的比较,所以肯定是稳定的
它的时间复杂度是多少呢?
是O(n^2)

看完了冒泡排序,我们再来看另一个基础排序的方法:直接插入排序
直接插入排序是什么呢?像我们玩扑克牌一样,接起的第一张牌是已经确定的一张(即是有序的),后面再接上来的牌跟第一张牌比较,确定第二张的顺序,依次类推;
即将数组中后面无序的元素提出来,跟已经有序的前面的元素进行依次比较,插入到该有序元素中,保证了依然有序,当所有元素插入完毕,则完成排序。
想要实现本方法呢,需要定义一个中间变量,中间变量的值为无序元素中提取出来的元素,然后将有序的最后(右)一个元素与该元素比较,依次向前比较,保证插入后有序即可
若我想将这么一组元素实现排序(使用直接插入排序),则方法如图
直接插入排序

int[] array = {13,52,36,77,55,1,22,3,7};

i为1号下标,且j为i-1的下标,先将i位置的数存储在tmp中间变量中,如果i位置的数的值大于j位置的数的值,则将现在j位置的值赋值给i所在的值,执行j–;继续让前面有序的值跟tmp(也就是原本无序中的值进行比较)如果大于则和以上执行相同步骤,小于的话则跳出循环,并将tmp的值赋值给所空位置,完成排序
第一趟比较:{13,52,36,77,55,1,22,3,7 }
第二趟比较:{13,36,52,77,55,1,22,3,7}
第三趟比较:{13,35,52,77,55,1,22,3,7}
第四趟比较:{13,35,52,55,77,1,22,3,7}
第五趟比较:{1,13,35,52,55,77,22,3,7}
第六趟比较:{1,13,22,35,52,55,77,3,7}
第七趟比较:{1,3,13,22,35,52,55,77,7}
第八趟比较:{1,3,7,13,22,35,52,55,77}
粗体为确定的有序序列;

那我们来看一下如何可以实现该排序呢?上代码:

/**
 * 直接插入排序
 * @author 王瑜
 *InsertSort
 */
public class WangYu {//遍历数组
    public static void show(int[] array){
        for(int k = 0;k < array.length;k++){
            System.out.print(array[k]+ "   ");
        }
    }
    public static void InsertSort(int[] array){//直接插入排序的方法
        int j;
        for(int i = 1;i < array.length;i++){从数组的第二个元素开始提取向前比较插入
            int tmp = array[i];
            for(j = i - 1; j >= 0;j--){
                if(tmp < array[j]){//如果插入的元素小于有序的最后一个元素,则j位置的元素后移
                    array[j + 1] = array[j];

                }
                else{
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }
    public static void main(String[] args) {
        int[] array = {13,52,36,77,55,1,22,3,7};
        InsertSort(array);
        show(array);
    }
}

输出为:

1   3   7   13   22   36   52   55   77 

稳定性:直接插入排序没有跳跃排序,所以其是稳定的
时间复杂度:O(n^2)

那么我们再看最后一个基础排序————>选择法排序
选择法排序是如何实现的呢?
将指定排序位置与其他数组元素进行对比,如果满足条件就交换元素值,(把满足条件的元素与指定的排序位置交换)
每一趟从未排序的数据元素中取出最小(或最大)的一个元素,顺序地放在已经排好序的数列的最后,直到全部待排序的元素排序完毕
也就是从0索引开始,依次和后面元素比较,小的往前放,第一次完毕,最小值出现在了最小索引处
也就是假设有这么一个数组

int[] array = {20,11,13,10};

从20开始向后比较,20比11大,所以交换位置成了{11,20,13,10} 此时的11要继续和13,10比较,就会变成{10,20,13,11}
那么如果我想要排序这个数组

int[] array = {23,55,17,10,25,66,99};

该如何实现呢?

/**
 * 选择排序
 * @author 王瑜
 *SelectSort
 */
public class WangYu {
    public static void show(int[] array){
        for(int k = 0;k < array.length;k++){
            System.out.print(array[k]+ "   ");
        }
    }
    public static void SelectSort(int[] array){
        int tmp = 0;
        int minIndex = 0;
        for(int i = 0;i < array.length;i++){
            minIndex = i;
            for(int j = i + 1;j < array.length;j++){
            if(array[minIndex] > array[j]){
                tmp = array[minIndex];
                array[minIndex] = array[j];
                array[j] = tmp;
            }
            }
        }

    }
    public static void main(String[] args) {
        int[] array = {23,55,17,10,25,66,99};
        SelectSort(array);
        show(array);
    }
}

输出为:

10   17   23   25   55   66   99 

稳定性:因为有跳跃的比较,所以是不稳定的
时间复杂度:O(n^2)

程序员必知的8大排序(①直接插入排序②希尔排序③简单选择排序④堆排序⑤冒泡排序⑥快速排序⑦归并排序⑧基数排序)

8种排序之间的关系:   1,  直接插入排序    (1)基本思想:在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排 好顺序的,现在要把第n个数插到...
  • Summer_YuXia
  • Summer_YuXia
  • 2016-11-20 14:42:14
  • 1412

简单排序:冒泡排序、直接插入排序、直接选择排序

简单排序:冒泡排序、直接插入排序、直接选择排序
  • wangyanming123
  • wangyanming123
  • 2016-06-03 10:23:49
  • 596

三种基本排序-冒泡排序、直接插入排序、选择排序

冒泡排序(从大到小)       原理:对于n个数,需要进行n-1次扫描,每次扫描通过相邻两个数的比较,找出最大的数,放到数列顶部。      程序:    1.冒泡排序1:每次扫描把下一个元素和最前...
  • chao360559040
  • chao360559040
  • 2010-10-29 11:25:00
  • 14420

排序算法: 冒泡排序, 快速排序,希尔排序,直接插入排序 ,直接选择排序,归并排序,堆排序

几种排序算法分析:     冒泡排序:   冒泡排序的方法排序速度比较慢。   思路:进行n-1排序,第一次排序先找出最小的数字,放在第一个位置,然后在剩余的数字中再找出最小的数字,放在第二个...
  • dahai_881222
  • dahai_881222
  • 2012-08-03 14:36:50
  • 4589

直接插入排序/快速排序/选择排序/冒泡排序(详细实现算法和性能比较)

  • 2016年03月20日 15:36
  • 332KB
  • 下载

冒泡排序-插入排序-快速排序-选择排序---飞天博客

请看文章: 排序经典集合:插入排序,冒泡排序,快速排序,选择排序,代码简单请看下面的基本介绍和代码 插入排序:直接插入排序是一种最简单的排序方法,它的基本操作是将一个记录插入到一排好序的有序表中   ...
  • xh199110
  • xh199110
  • 2014-09-29 17:37:02
  • 1697

7种常用排序算法实现(C++)(冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序)

  • 2014年04月11日 22:46
  • 525KB
  • 下载

冒泡排序 快速排序 选择排序 堆排序 直接插入排序 希尔排序 归并排序

#include using namespace std; void Swap(int* a,int* b){ int tmp=*a; *a=*b; *b=tmp; } void Bubbl...
  • shidalong2014
  • shidalong2014
  • 2015-01-07 23:19:50
  • 238

Java排序算法之冒泡排序和选择排序

前言:纵然伤心,也不要愁眉不展,因为你不知是谁会爱上你的笑容。——泰戈尔 《飞鸟集》 原文出处: import java.util.Arrays; class Demo { public...
  • u014158743
  • u014158743
  • 2016-09-19 23:14:52
  • 1028

随机生成30个数,试比较直接插入排序、简单选择排序、冒泡排序、快速排序、堆排序和希尔排序的时空性能和稳定性。

随机生成30个数,试比较直接插入排序、简单选择排序、冒泡排序、快速排序、堆排序和希尔排序的时空性能和稳定性。...
  • LiuBo_01
  • LiuBo_01
  • 2017-11-05 20:35:50
  • 899
收藏助手
不良信息举报
您举报文章:Java中的三个基础排序(冒泡排序,直接插入排序,选择排序)
举报原因:
原因补充:

(最多只允许输入30个字)