算法-快速排序

算法-快速排序

快速排序的核心是:以第一个数为基准，比自己大的放到左边，比自己小的放在右边然后对剩下的两部分同样用快排
一般这个很好理解，但是很多都没有解释放左边和右边需要如何怎么做：双指针方法，[从右往左找比自己小的 A，从左往右找比自己大的B]。AB交换位置，直到两个指针指向同一个数据为止

实例：10,5,11,35,8,9,13
你以为第一次交换后是 5,8,9,10,11,35,13
实际上交换：[10,5,9,35,8,11,13]–>[10,5,9,8,35,11,13]–>[8,5,9,10,35,11,13]
这句：【从右往左找比自己小的 A，从左往右找比自己大的B】顺序是不能交换的，如果交换了就把35与10交换了放到前面

最好是在纸上画一下就能够理解了

测试代码

package com.java.sort;

import java.util.Random;

/**
 * @author dengtiantian
 */
public class TestArraySort {
    public static void main(String[] args) {
        //构造用例数据
        int[] a = new int[10000];
        // 初始化用例
        for (int i = 0;i<a.length;i++){
            a[i] = (new Random()).nextInt(100);
        }
        // 调用排序算法
        long time = System.currentTimeMillis();
        // ArraySort.bubbleSort(a);
         ArraySort.insertSort(a);
        // ArraySort.quickSort(a);
        time = System.currentTimeMillis()-time;
        System.out.println("耗时:"+time);
        //输出结果
        int count=0;
        for (int i : a){
            System.out.print(i + " ");
            count++;
        }
        System.out.println();
        System.out.println(count);
    }
}

排序代码

package com.java.sort;

/**
 * @author dengtiantian
 * 数组排序算法
 */
public class ArraySort {
    /**
     * @author dengtiantian
     * @param {int[] a}
     * 快速排序
     * 核心是：以第一个数为基准值，比自己小的移动到左边，大的移动到右边
     * 如何做： 双指针法，从数组两边分别进行对比。 从右往左找比基准值小的数  A,在从右往左找比基准值大的数，B。AB交换位置。
     * 如果两个指针重叠，交换基准值和指针所指向数（这里决定了为什么要先从右往左找）
     */
    public static void quickSort(int[] a){
        quickSort(a,0,a.length-1);
    }
    public static void quickSort(int[] a,int low, int high){
        // 递归结束语
        if (low >= high){
            return;
        }
        // 第一个数是基准

        // 基准值的下标
        int left = low;
        int right = high;
        while (left<right){
            //从右往左找比基准值小的数 找到了这个循环结束
            while (right > left && a[right]>=a[low]){
                right--;
            }
            //从左往右找比基准值大的数，找到了这个循环结束
            while (left < right && a[left]<=a[low]){
                left++;
            }
            // 两数交换
            if (left < right){
                int temp = a[left];
                a[left] = a[right];
                a[right] = temp;
            }
        }
        //循环能结束说明left=right ,和基准值交换
        int temp = a[low];
        a[low] = a[right];
        a[right] = temp;

        //基准值左边 递归
        quickSort(a,low,left-1);
        //右边
        quickSort(a,right+1,high);

    }

    /**
     * @author dengtiantian
     * 插入排序
     * 将数据插入到一个有序的队列里
     * 将数组分层两个部分，前面部分是有序，将后半部分 插入前半部分，需要移动数组
     */
    public static void insertSort(int[] a){
        int temp;
        for (int i = 1; i< a.length; i++){
            for (int j = i; j>=1;j--){
                //如果比最后一位小，进行交换。也就是插入
                if (a[j]<a[j-1]){
                    temp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = temp;
                 //否则，循环结束，该位置就是排序的位置
                }else {
                    break;
                }
            }
        }

    }
    /**
     * @author dengtiantian
     * 冒泡排序
     * 核心：两两对比，将最大或最小的放到最后(我这个是将最大的放到最后)
     *
     * 改进冒泡排序：如果某一次循环一次交换都没有，后续循环不用走了
     */
    public static void bubbleSort(int[] a){
        //temp放到外面，避免多次new
        int temp;
        for (int i = 0; i< a.length; i++){
            int tag = 0;
            for (int j = 0; j < a.length-i-1; j++){
                temp = a[j];
                if (a[j] > a[j+1]){
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    tag++;
                }
            }
            //如果一次交换都没有，后续不用循环了。但是感觉优化并不是很大
            if (0==tag){
                break;
            }
        }
    }
}

小结

代码包含了快速排序，插入排序和冒泡排序。但是只有快速排序可能有点复杂。注释多一些

总目录：Java进阶之路-目录