数据结构和算法——排序算法（上）

1、冒泡排序

冒泡排序：冒泡排序是依次比较待排序序列中相邻的俩个元素大小，将较大的元素和较小的元素交换位置，这样一轮比较下来，序列中最大值的数就会置于序列最后，然后重复第二轮比较将第二大的数放在倒数第二位以此类推，最终会得到一个有序序列。冒泡排序是使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒，因此得名。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 6, 84, 2, 46, 7};
        BubbleSort(arr);
        System.out.println("冒泡排序之后的结果：" + Arrays.toString(arr));
    }

    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 = false;
            }
        }
    }
}

 2、选择排序

选择排序：选择排序是从一个待排序序列中，在一轮排序中选择出一个最小的数将其置于第一位，第二轮排序选择一个第二小的数置于第二位，以此类推，最后就会产生一个有序序列。

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 6, 84, 2, 46, 7};
        selectSort(arr);
        System.out.println("选择排序结果为：" + Arrays.toString(arr));
    }

    public static void selectSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int minVal = arr[i];
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < minVal) {
                    minIndex = j;
                    minVal = arr[j];
                }

            }
            //第一轮结束后，将找到的最小值与第一位置的元素进行交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = minVal;
            }
        }
    }
}

 3、插入排序

插入排序：将一个待排序序列看成一个有序列表和一个无序列表，有序列表只有一个数，无序列表是剩余的数，每次从无序列表中拿出一个数插入到有序列表进行比较，将较小的数排在有序列表的前面，以此类推就可以达到排序的目的。

public class InsertSort {
    static int count = 0;
    public static void main(String[] args) {

        int[] arr = {3,1,0};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println("插入排序一共排了："+count+"次");
    }


    public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];
            //定义索引。即开始时有序表的位置，待插入得数需要加入到有序表中
            int insertIndex = i-1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]){
                arr[insertIndex+1] = arr[insertIndex];
                insertIndex--;
            }

            count++;
            if (insertIndex+1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
    }

4、快速排序

快速排序：快速排序是对冒泡排序的一种改进，先计算出数列的中间值，经过排序将中间值的左边为的集合比中间值小的，右边为集合比中间值大的，然后依次这样在两边分别递归排序，结束后就得到一个有序序列。

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

        int[] arr = {5, 2, 0, -1, 6, 3};
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int left, int right) {
        int l = left;//左下标
        int r = right;//右下标
        int pivot = arr[(left + right) / 2];
        int temp = 0;

        while (l < r) {
            //在pivot的左边一直找，找到大于等于pivot值才退出
            while (arr[l] < pivot) {
                l += 1;
            }
            //在pivot的右边一直找，找到小于等于pivot值才退出
            while (arr[r] > pivot) {
                r -= 1;
            }
            //如果l >= r 说明pivot的左右俩个值，已经按照左边全是小于等于pivot的
            //右边全是大于等于pivot值
            if (l >= r) {
                break;
            }
            //开始交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //如果交换完后，发现这个arr[l]== pivot 相等， r--前移
            if (arr[l] == pivot) {
                r -= 1;
            }
            //如果交换完后，发现这个arr[r]== pivot 相等， l++后移
            if (arr[r] == pivot) {
                l += 1;
            }

        }
        //如果 l == r 必须l++，r--；否则会出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }
        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }
        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
    }
}