排序

排序 （一）

冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。

package com.yuxi.lesson06;


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

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

//        int arr[] = {3,0,-1,10,20};
//
//        System.out.println("排序前： ");
//        System.out.println(Arrays.toString(arr));
//        bubbleSort(arr);
//        System.out.println("排序后：");
//        System.out.println(Arrays.toString(arr));

        //在测试冒泡排序的速度，给1000000数据
        //创建要给100000个随机数组
        int[] arr = new int[100000];
        for (int i = 0; i < 100000; i++) {
            arr[i] = (int)(Math.random()*100000);//生成一个[0,100000)数
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间：" + date1Str);

        bubbleSort(arr);

        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间：" + date2Str);

    }
    public static void bubbleSort(int[] arr){
        //冒泡排序的时间复杂度O(n^2)
        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 = false;//重置flag,进行下次判断
            }
        }
    }
}

选择排序

选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

选择排序（select sorting）也是一种简单的排序方法。它基本思想是：第一次从arr[0]_{arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]}arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]_{arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]}arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

package com.yuxi.lesson06;

import java.util.Arrays;

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {110,2,6,1,76,3,87,54,0};
        System.out.println(Arrays.toString(arr));
        selectionSort(arr);
        System.out.println("排序后 ： ");
        System.out.println(Arrays.toString(arr));

    }

    //选择排序
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) { //说明假定的最小值 ，并不是最小
                    min = arr[j];//重置 min
                    minIndex = j;//重置 minIndex
                }
            }
            //将最小值放在arr[0],即交换位置
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.println("第" + (i + 1) + "趟排序后的数组");
            System.out.println(Arrays.toString(arr));
        }

    }
}

插入排序

插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

package com.yuxi.lesson06;

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {110,120,119,3,2};
        insertSort(arr);

    }
    //插入排序
    public static void insertSort(int[] arr) {
        int insertVal = 0;
        int insertIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            // {110,120,119,3,2}
            //定义待插入的数
            insertVal = arr[i];
            insertIndex = i - 1; //即arr[1]的前面这个数的下标
            //给 insertVal 找到插入位置
            // 1，insertIndex >= 0 保证给insertVal 找插入位置不越界
            // 2.insertVal < arr[insertIndex] 待插入的数，还没找到插入的位置
            // 3. 就需要将 arr[insertIndex] 后移
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            //当推出while循环时，说明插入的位置找到了 insertIndex + 1
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
            System.out.println("第" + i + "插入");
            System.out.println(Arrays.toString(arr));
        }
    }
}

希尔排序

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

package com.yuxi.lesson06;

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,7,3,5,1,2,6,9,4,0};
        shellSort(arr);
        shellSort2(arr); //交换式
        shellSort3(arr); //移位式 时间更短
        System.out.println("排序后:" + Arrays.toString(arr));


    }
    // 逐步推导
    // 希尔排序时，对有序序列在插入时采用交换法
    public  static void shellSort(int[] arr){
        int temp = 0;
        //第一轮排序 ，将10个数据分成5组
        for (int i = 5; i < arr.length; i++) {
            //遍历各数组中的所有元素(共5组，每组有2个元素)，步长5
            for (int j = i-5; j >= 0 ; j -= 5) {
                //如果前元素大于加上补偿后的那个元素，说明交换
                if (arr[j] > arr[j+5]){
                    temp = arr[j];
                    arr[j] = arr[j+5];
                    arr[j+5] = temp;
                }
            }
        }
        System.out.println("希尔排序一轮后 = " + Arrays.toString(arr));

        //希尔排序第2轮排序
        //是将10个数据分成了5/2 = 2组
        for (int i = 5/2; i < arr.length; i++) {
            for (int j = i - 2; j >= 0 ; j -= 2) {
                if(arr[j] > arr[j+2]){
                    temp = arr[j];
                    arr[j] = arr[j+2];
                    arr[j+2] = temp;
                }
            }
        }
        System.out.println("希尔排序二轮后 = " + Arrays.toString(arr));

        //希尔排序第3轮排序
        //是将10个数据分成了2/2 = 1组
        for (int i = 2/2; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 ; j -= 1) {
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("希尔排序三轮后 = " + Arrays.toString(arr));
    }
    //循环处理
    public  static void shellSort2(int[] arr){
        int temp = 0;
        int count = 0;
        for (int gap = arr.length/2; gap > 0;gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0 ; j -= gap) {
                    if(arr[j] > arr[j+gap]){
                        temp = arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
            System.out.println("希尔排序" + (++count) + "轮后 = " + Arrays.toString(arr));
        }
    }

    //对交换式的希尔排序进行优化 -> 移位法
    public  static void shellSort3(int[] arr){
        //增量 gap ，并逐步的缩小增量
        for (int gap = arr.length/2; gap > 0;gap /= 2) {
            //从第gap个元素，逐个对其所在的组进行直接插入排序
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]){
                    while(j - gap >= 0 && temp < arr[j -gap]){
                        arr[j] = arr[j - gap];
                        j -= gap; //步长
                    }
                    //当退出while后，就给temp找到插入的位置
                    arr[j] = temp;
                }

            }
        }
    }
}