完整排序算法（冒泡排序，选择排序--更新中）

排序算法的介绍

冒泡排序

基本介绍

图解

冒泡排序应用实例

我们举一个具体的案例来说明冒泡算法。我们将五个无序的数： 3，9，-1，10，20.。使用冒泡排序算法将排成一个从小到大的有序数列。

图解冒泡排序算法的过程

冒泡排序规则小结：

 1. 一共进行数组的大小-1次大的循环
 2. 每一趟排序的次数在逐渐的减少
 3. 如果我们发现在某趟偶排序中，没有发生一次交换，可以提前结束冒泡排序，这个就是优化

代码实现

冒泡排序—确认数组

package com.sort;

/**
 * 冒泡排序
 * DuanXS
 */
public class BubbleSort {
    public static void main(String[] args) {
        //确定数组
        int arr[] = {3,9,-1,10,-2};
        
    }
}

为了容易理解，我们把冒泡排序的演变过程，给大家展示出来

 //为了容器理解，我们把冒泡排序的演变过程，给大家展示出来
        //第一趟就是把最大的数组排在最后
            //临时变量
        int temp = 0;
        for (int j = 0; j < arr.length-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第一趟排序后的数组");
        System.out.println(Arrays.toString(arr));

第二趟排序，就是将第二大的数排在倒数第二位

  //第二趟排序，就是将第二大的数排在倒数第二位
        for (int j = 0; j < arr.length-1-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第二趟排序后的数组");
        System.out.println(Arrays.toString(arr));

第三趟排序，就是将第三大的数排在倒数第三位

 //第三趟排序，就是将第三大的数排在倒数第三位
        for (int j = 0; j<arr.length-1-2; j++){
            //如果卡面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第三趟排序后的数组");
        System.out.println(Arrays.toString(arr));

第四趟排序，就是将第四大的数排在倒数第四位

 //第四趟排序，就是将第四大的数排在倒数第四位
        for (int j = 0; j<arr.length-1-3; j++){
            //如果卡面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第四趟排序后的数组");
        System.out.println(Arrays.toString(arr));

找到规律 简化代码

 //找到规律 简化代码
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第"+i+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));
        }

在一趟排序中，一次交换都没有发生过 直接结束

 //第一趟就是把最大的数组排在最后
            //临时变量
        int temp = 0;
            //标识变量，表示是否进行过交换
        boolean flag = false;
      /*  for (int j = 0; j < arr.length-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]){
@@ -69,13 +71,22 @@ public class BubbleSort {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            } 
            System.out.println("第"+(i+1)+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));

            //在一趟排序中，一次交换都没有发生过
            if (!flag){
                break;
            }else {
                //重置flag，进行下次判断
                flag = false;
            }
        }

    }

将前面的冒泡排序算法，封装成一个方法

//将前面的冒泡排序算法，封装成一个方法
    public static void bubbleSort(int[] arr){

        //为了容器理解，我们把冒泡排序的演变过程，给大家展示出来
        //第一趟就是把最大的数组排在最后
        //临时变量
        int temp = 0;
        //标识变量，表示是否进行过交换
        boolean flag = false;
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            //System.out.println("第"+(i+1)+"趟排序后的数组");
            //System.out.println(Arrays.toString(arr));

            //在一趟排序中，一次交换都没有发生过
            if (!flag){
                break;
            }else {
                //重置flag，进行下次判断
                flag = false;
            }

  System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        //测试冒泡排序
        bubbleSort(arr);
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));

测试一下冒泡的速度O(n^2),给八万个数据，测试

创建要给8个的随机数组

//测试一下冒泡的速度O(n^2),给八万个数据，测试
        //创建要给80000个的随机数组
        int[] arr =new int[8];
        for (int i = 0; i < 8; i++) {
            //生成一个[0，80000]数
            arr[i] = (int)(Math.random()*80000);
        }

测试这个数组是否是随机的

//测试这个数组是否是随机的
        System.out.println(Arrays.toString(arr));

测试排序前后的时间

//测试排序前的时间
        Date date1 = new Date();
        //输出时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-mm-dd HH:mm:ss");
        //有了这些我们可以拿到一个字符串
        String deta = simpleDateFormat.format(date1);
        System.out.println("排序前的时间"+deta);

        //测试排序后的时间
        Date date2 = new Date();
        //有了这些我们可以拿到一个字符串
        String deta2 = simpleDateFormat.format(date2);
        System.out.println("排序后的时间"+deta2);

完整代码

package com.sort;

import javax.xml.crypto.Data;
import java.sql.Array;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.logging.SimpleFormatter;

/**
 * 冒泡排序
 * DuanXS
 */
public class BubbleSort {
    public static void main(String[] args) {
/*        //确定数组
        int arr[] = {3,9,-1,10,-2};

        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));*/

        //测试一下冒泡的速度O(n^2),给八万个数据，测试
        //创建要给80000个的随机数组
        int[] arr =new int[80000];
        for (int i = 0; i < 80000; i++) {
            //生成一个[0，80000]数
            arr[i] = (int)(Math.random()*80000);
        }
        //测试这个数组是否是随机的
       // System.out.println(Arrays.toString(arr));

        //测试排序前的时间
        Date date1 = new Date();
        //输出时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-mm-dd HH:mm:ss");
        //有了这些我们可以拿到一个字符串
        String deta = simpleDateFormat.format(date1);
        System.out.println("排序前的时间"+deta);

        //测试冒泡排序
        bubbleSort(arr);
        //测试排序后的时间
        Date date2 = new Date();
        //有了这些我们可以拿到一个字符串
        String deta2 = simpleDateFormat.format(date2);
        System.out.println("排序后的时间"+deta2);

        /*System.out.println("排序后");
        System.out.println(Arrays.toString(arr));*/

        //为了容器理解，我们把冒泡排序的演变过程，给大家展示出来
        //第一趟就是把最大的数组排在最后
            //临时变量
        int temp = 0;
            //标识变量，表示是否进行过交换
        boolean flag = false;
      /*  for (int j = 0; j < arr.length-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第一趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第二趟排序，就是将第二大的数排在倒数第二位
        for (int j = 0; j < arr.length-1-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第二趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第三趟排序，就是将第三大的数排在倒数第三位
        for (int j = 0; j<arr.length-1-2; j++){
            //如果卡面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第三趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第四趟排序，就是将第四大的数排在倒数第四位
        for (int j = 0; j<arr.length-1-3; j++){
            //如果卡面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第四趟排序后的数组");
        System.out.println(Arrays.toString(arr));*/


      /*  //找到规律 简化代码
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));

            //在一趟排序中，一次交换都没有发生过
            if (!flag){
                break;
            }else {
                //重置flag，进行下次判断
                flag = false;
            }
        }*/
    }
    //将前面的冒泡排序算法，封装成一个方法
    public static void bubbleSort(int[] arr){

        //为了容器理解，我们把冒泡排序的演变过程，给大家展示出来
        //第一趟就是把最大的数组排在最后
        //临时变量
        int temp = 0;
        //标识变量，表示是否进行过交换
        boolean flag = false;
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            //System.out.println("第"+(i+1)+"趟排序后的数组");
            //System.out.println(Arrays.toString(arr));

            //在一趟排序中，一次交换都没有发生过
            if (!flag){
                break;
            }else {
                //重置flag，进行下次判断
                flag = false;
            }
        }

    }
}

选择排序

基本介绍

排序思想

选择排序思路分析图

思路图解

原始数据：101，34，119，1
第一轮排序：1，34，119，101
第二轮排序：1，34，119，101
第三轮排序：1，34，101，119

1.（说明：一共有几个数，就是几个数-1轮排序）
2.每一轮得循环得，又是一个循环得规则（代码）
2.1先假定当前找个数是最小数
2.2然后和后面得每个数进行比较，如果发现有比当前更小得数，就重新确定最小数，并得到下标
2.3当遍历到数组得最后时，就得到本轮最小数和下标
2.4交换【代码】

代码实现

问题

思路分析

package com.sort;

public class SelectSort {
    public static void main(String[] args) {

    }

    /**
     * 选择排序
     *  使用逐步推导得方式来讲解选择排序
     *  第一轮
     *  原始的数组：101，34，119，1
     *  第一轮排序：1，34，119，101
     *  算法的思想  先简单———》再复杂，就是可以把一个复杂算法，拆分成简单的问题——》逐步解决
     *  DuanXS
     */
    public static void selectSort(int [] arr){

    }
}

定义原始数组数据

public class SelectSort {
    public static void main(String[] args) {
        int [] arr = {101,34,119,1};
    }

第一轮

    public static void selectSort(int [] arr){

        //第一轮
        int minIndex = 0;
        int min = arr[0];
        for (int j = 0+1; j <arr.length ; j++) {
            //如果min》arr[j]  说明假定的最小值，并不是最小的
            if (min > arr[j]){
                //重置min
                min = arr[j];
                //重置minIndex
                minIndex = j;
            }
        }
    }

交换

   //将最小值，放到arr[0],及交换
        arr[minIndex] = arr[0];
        arr[0] = min;

实现

        //将最小值，放到arr[0],及交换
        arr[minIndex] = arr[0];
        arr[0] = min;
        
        System.out.println("第一轮后~~");
        System.out.println(Arrays.toString(arr));

    public static void main(String[] args) {
        int [] arr = {101,34,119,1};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
    }

第二轮

        //第二轮
         minIndex = 1;
         min = arr[1];
        for (int j = 1+1; j <arr.length ; j++) {
            //如果min》arr[j]  说明假定的最小值，并不是最小的
            if (min > arr[j]){
                //重置min
                min = arr[j];
                //重置minIndex
                minIndex = j;
            }
        }
        //将最小值，放到arr[0],及交换
        arr[minIndex] = arr[1];
        arr[1] = min;

        System.out.println("第二轮后~~");
        System.out.println(Arrays.toString(arr));

把第一轮和第二轮进行简单优化（原因是第二轮的排序刚好是第一轮的排序没有发生改变）

        //将最小值，放到arr[0],及交换
        arr[minIndex] = arr[0];
        arr[0] = min;

        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第一轮后~~");
        System.out.println(Arrays.toString(arr));

        //将最小值，放到arr[0],及交换
        arr[minIndex] = arr[1];
        arr[1] = min;

        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第二轮后~~");
        System.out.println(Arrays.toString(arr));
    }

第三轮

 //第三轮
        minIndex = 2;
        min = arr[2];
        for (int j = 2+1; j <arr.length ; j++) {
            //如果min》arr[j]  说明假定的最小值，并不是最小的
            if (min > arr[j]){
                //重置min
                min = arr[j];
                //重置minIndex
                minIndex = j;
            }
        }
        //将最小值，放到arr[0],及交换
        if (minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第三轮后~~");
        System.out.println(Arrays.toString(arr));

代码优化

        //在推到过程中，发现规律，因此用一个for循环来解决
        for (int i = 0; i <arr.length-1 ; i++) {
            //第i轮
            int minIndex = i;
            int min = arr[i];
            for (int j = i+1; j <arr.length ; j++) {
                //如果min》arr[j]  说明假定的最小值，并不是最小的
                if (min > arr[j]){
                    //重置min
                    min = arr[j];
                    //重置minIndex
                    minIndex = j;
                }
            }
            //将最小值，放到arr[0],及交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.println("第"+(i+1)+"轮后~~");
            System.out.println(Arrays.toString(arr));
        }

这里是从小到大的 如果想从大到小 这里只需要把 min > arr[j] 大于号换成小于号

              //这里是从小到大的  如果想从大到小  这里只需要把 min > arr[j]  大于号换成小于号
                if (min > arr[j]){
                    //重置min
                    min = arr[j];

测试下排序前和排序后的时间

 //int [] arr = {101,34,119,1};

        //测试一下冒泡的速度O(n^2),给八万个数据，测试
        //创建要给80000个的随机数组
        int[] arr =new int[80000];
        for (int i = 0; i < 80000; i++) {
            //生成一个[0，80000]数
            arr[i] = (int)(Math.random()*80000);
        }

        //System.out.println("排序前");
        //System.out.println(Arrays.toString(arr));

        //测试排序前的时间
        Date date2 = new Date();
        //输出时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-mm-dd HH:mm:ss");
        //有了这些我们可以拿到一个字符串
        String deta2 = simpleDateFormat.format(date2);
        System.out.println("排序前的时间"+deta2);

        selectSort(arr);
        //System.out.println("排序后");
        //System.out.println(Arrays.toString(arr));

        Date date3 = new Date();
        //有了这些我们可以拿到一个字符串
        String deta3 = simpleDateFormat.format(date3);
        System.out.println("排序后的时间"+deta3);

完整代码

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class SelectSort {
    public static void main(String[] args) {
        //int [] arr = {101,34,119,1};

        //测试一下冒泡的速度O(n^2),给八万个数据，测试
        //创建要给80000个的随机数组
        int[] arr =new int[80000];
        for (int i = 0; i < 80000; i++) {
            //生成一个[0，80000]数
            arr[i] = (int)(Math.random()*80000);
        }

        //System.out.println("排序前");
        //System.out.println(Arrays.toString(arr));

        //测试排序前的时间
        Date date2 = new Date();
        //输出时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-mm-dd HH:mm:ss");
        //有了这些我们可以拿到一个字符串
        String deta2 = simpleDateFormat.format(date2);
        System.out.println("排序前的时间"+deta2);

        selectSort(arr);
        //System.out.println("排序后");
        //System.out.println(Arrays.toString(arr));

        Date date3 = new Date();
        //有了这些我们可以拿到一个字符串
        String deta3 = simpleDateFormat.format(date3);
        System.out.println("排序后的时间"+deta3);
    }

    /**
     * 选择排序
     *  使用逐步推导得方式来讲解选择排序
     *  第一轮
     *  原始的数组：101，34，119，1
     *  第一轮排序：1，34，119，101
     *  算法的思想  先简单———》再复杂，就是可以把一个复杂算法，拆分成简单的问题——》逐步解决
     *
     *  DuanXS
     */
    public static void selectSort(int [] arr){

        //在推到过程中，发现规律，因此用一个for循环来解决
        //选择排序时间复杂度是0（n^2）
        for (int i = 0; i <arr.length-1 ; i++) {
            //第i轮
            int minIndex = i;
            int min = arr[i];
            for (int j = i+1; j <arr.length ; j++) {
                //如果min》arr[j]  说明假定的最小值，并不是最小的
                //这里是从小到大的  如果想从大到小  这里只需要把 min > arr[j]  大于号换成小于号
                if (min > arr[j]){
                    //重置min
                    min = arr[j];
                    //重置minIndex
                    minIndex = j;
                }
            }
            //将最小值，放到arr[0],及交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
           // System.out.println("第"+(i+1)+"轮后~~");
           // System.out.println(Arrays.toString(arr));
        }
        
/*
        //第一轮
        int minIndex = 0;
        int min = arr[0];
        for (int j = 0+1; j <arr.length ; j++) {
            //如果min》arr[j]  说明假定的最小值，并不是最小的
            if (min > arr[j]){
                //重置min
                min = arr[j];
                //重置minIndex
                minIndex = j;
            }
        }
        //将最小值，放到arr[0],及交换
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第一轮后~~");
        System.out.println(Arrays.toString(arr));

        //第二轮
         minIndex = 1;
         min = arr[1];
        for (int j = 1+1; j <arr.length ; j++) {
            //如果min》arr[j]  说明假定的最小值，并不是最小的
            if (min > arr[j]){
                //重置min
                min = arr[j];
                //重置minIndex
                minIndex = j;
            }
        }
        //将最小值，放到arr[0],及交换
        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第二轮后~~");
        System.out.println(Arrays.toString(arr));

        //第三轮
        minIndex = 2;
        min = arr[2];
        for (int j = 2+1; j <arr.length ; j++) {
            //如果min》arr[j]  说明假定的最小值，并不是最小的
            if (min > arr[j]){
                //重置min
                min = arr[j];
                //重置minIndex
                minIndex = j;
            }
        }
        //将最小值，放到arr[0],及交换
        if (minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第三轮后~~");
        System.out.println(Arrays.toString(arr));
 */
    }
}