算法学习-排序算法

排序算法

---

排序 平均时间复杂度 冒泡排序 O(n2) 选择排序 O(n2) 插入排序 O(n2) 希尔排序 O(n1.5) 快速排序 O(N*logN) 归并排序 O(N*logN) 堆排序 O(N*logN) 基数排序 O(d(n+r))

一.交换排序（冒泡排序、快速排序）

1.冒泡排序（BubbleSort）

1. 基本思想：

两个数比较大小，小的冒泡出来站前面;冒泡排序就是把小的元素往前调或者把大的元素往后调。

2. 平均时间复杂度： O(n2)、

序列{ 6, 5, 3, 1, 8, 7, 2, 4 }进行冒泡排序的实现过程

3. java代码实现

    /**     * 冒泡排序(BubbleSort)      * /    public static void bubbleSort(int[] arr) {        System.out.println(Arrays.toString(arr) + "<---原始数据");        int temp;// 临时变量        int time = 0;// 次数        for (int i = 0; i < arr.length - 1; i++) {// 表示趟数，一共arr.length-1次。            for (int j = arr.length - 1; j > i; j--) {                if (arr[j] < arr[j - 1]) {                    temp = arr[j];                    arr[j] = arr[j - 1];                    arr[j - 1] = temp;                    flag = true;                }                time++;                System.out.println(Arrays.toString(arr) + "<---第" + time + "遍结果");            }        }        // 输出        System.out.println(Arrays.toString(arr) + "<---排序后");    }

4. 优化：

 1. 针对问题：        数据的顺序排好之后，冒泡算法仍然会继续进行下一轮的比较，直到arr.length-1次，后面的比较没有意义的。 2. 方案：      设置标志位flag，如果发生了交换flag设置为true；如果没有交换就设置为false。    这样当一轮比较结束后如果flag仍为false，即：这一轮没有发生交换，说明数据的顺序已经排好，没有必要继续进行下去

5. java代码实现

/** * 冒泡排序(BubbleSort) 优化 * /public static void bubbleSort(int[] arr) {        System.out.println(Arrays.toString(arr) + "<---原始数据");        int temp;// 临时变量        int time = 0;// 次数        boolean flag;        for (int i = 0; i < arr.length - 1; i++) {// 表示趟数，一共arr.length-1次。            flag = false;            for (int j = arr.length - 1; j > i; j--) {                if (arr[j] < arr[j - 1]) {                    temp = arr[j];                    arr[j] = arr[j - 1];                    arr[j - 1] = temp;                    flag = true;                }                time++;                System.out.println(Arrays.toString(arr) + "<---第" + time + "遍结果");            }            if (!flag)                break;        }        // 输出        System.out.println(Arrays.toString(arr) + "<---排序后");    }

---

2.快速排序(Quick Sort)

1. 思路 quickSort(arr[],left,right)

 1. 从数列中取一个数作为参照key=arr[left];挖出来作为key值，此时出现一个坑 2. 从右边往左寻找，直到找到一个比key小的值，挖出来填到上一个坑中， 3. 从左边往右寻找，直到找到一个比key大的值，挖出来填到上一个坑中， 4. 坑分处了两个数列，继续2、3步，继续挖坑递归 。 5. 

2. 平均时间复杂度： O(N*logN)

3. java代码实现

    /**     * 快速排序     *      * @param arr     * @param left     * @param right     */    public static void quickSort(int[] arr, int left, int right) {        System.out.println(Arrays.toString(arr));        if (left >= right)            return;        int i = left;        int j = right;        int key = arr[left];//挖个坑        while (i < j) {            while (i < j && arr[j] >= key)// 从右往左 找比key小的值                j--;            if (i < j) {                arr[i] = arr[j];//用比key小的值  填坑                i++;//数组下标后移            }            while (i < j && arr[i] < key)                i++;            if (i < j) {                arr[j] = arr[i];//比key大的  填坑                j--;//数组下标前移            }        }        if (i == j)            arr[i] = key;        quickSort(arr, left, i - 1);//坑前面的数列，继续挖坑        quickSort(arr, i + 1, right);//坑后面的数列，继续挖坑    }

---

三 选择排序（直接选择排序、堆排序）

1.直接选择排序（SelctionSort）

1. 基本思想：

遍历找出最小的一个放在最前面

2. 平均时间复杂度：O(n2)

3. java代码实现

/**     * 选择排序     */    public static void selctionSort(int[] arr) {        int temp;//临时变量        for (int i = 0; i < arr.length - 1; i++) {            int min = arr[i];            for (int j = i; j < arr.length - 1; j++) {                if (arr[j + 1] < min) {                    temp = min;                    min = arr[j + 1];                    arr[j + 1] = temp;                }                arr[i] = min;            }        }    }

1.堆排序（HeapSort）

1. 基本思想：

遍历找出最小的一个放在最前面

2. 平均时间复杂度：O(NlogN)

3. java代码实现

---