常用排序算法解析-冒泡排序 插入排序 快速排序

一 冒泡排序

冒泡排序是最简单的排序算法之一，也是面试中常考的算法。其实现的基本思路是：
（1）使用一前一后两个指针，i， j
（2）j一直往前走，i从每次从0开始扫描到j
（3）i位置的元素与j位置的元素交换，确保0-j位置的数字都按序排列

时间复杂度：O(n2)

代码如下：

  @Test
    public void testBubbleSort(){
        int[] nums = {5,1,4,7,2};
        bubbleSort(nums);
        System.out.println(new Gson().toJson(nums));
    }
    private void bubbleSort(int[] nums){
        for(int j = 1; j <nums.length; j++){
            for(int i =0;i<j; i++){
                if( nums[i] > nums[j]){
                    swap(nums, i, j);
                }
            }
        }
    }

    public void swap(int[] nums, int i, int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

二 插入排序

插入排序的基本思路：
（1）从第一个元素开始，该元素可以认为已经被排序
（2）取出下一个元素A，在已经排序的元素序列中从后向前扫描
（3）如果该元素（已排序）大于A，将该元素移到下一位置,A填充到该位置
（4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
确保0-i的位置一直处于排序好的状态

时间复杂度：在数组已经排序好的情况下，时间复杂度是O(n)，最坏情况下，数组完全逆序，时间复杂度是O(n^2)

代码如下：

@Test
    public void test(){
        int[] nums = {6,5,3,1,8,7,2,4};
        insertSort(nums);
        System.out.println(new Gson().toJson(nums));
    }

    public void insertSort(int[] nums) {
        int i, j, key;
        for (i = 1; i < nums.length; ++i) {
            key = nums[i];
            for (j = i - 1; j >= 0; --j) {
                if (nums[j] > key){
                    nums[j + 1] = nums[j];
                }else{
                    break;
                }
            }
            nums[j] = key;
        }
    }

三 快速排序

快速排序的基本思路：
（1）在数据集中选择一个元素作为基准pivot
（2）所有小于基准的元素都挪到基准的左边，所有大于基准的元素都挪到基准的右边，这个操作称为分区。分区操作结束后，基准元素所处的位置就是它的最终位置
（3）对基准左边和右边两个子集重复（1）和（2），直到所有子集只剩下一个元素为止

具体操作步骤
（1）把基准元素移到尾部，或者选择最后一个元素作为基准
（2）定义变量i和storeIndex,从左到右循环
（3）如果a[i] < pivotValue; 交换位于storeIndex和位置i的元素

时间复杂度O(nlogn)

代码如下：

    @Test
    public void test() {
        int[] array = {3, 7, 8, 5, 2, 1, 9, 5, 4};
        quickSort(array, 0, array.length-1);
    }


    private void quickSort(int[] array, int left, int right) {
        if (right <= left) {
            return;
        }
        int pivotNewIndex = partition(array, left, right, right);
        quickSort(array, left, pivotNewIndex - 1);
        quickSort(array, pivotNewIndex + 1, right);
    }

    //pivotIndex 初始为任意选择的数组index
    //初始left=0；right=length
    private int partition(int[] array, int leftIndex, int rightIndex, int pivotIndex) {
        int pivotValue = array[pivotIndex];

        //交换pivotIndex与rightIndex
        swap(array, rightIndex, pivotIndex);
        int storeIndex = leftIndex;

        for (int i = leftIndex; i <= rightIndex; i++) {
            if (array[i] < pivotValue) {
                swap(array, storeIndex, i);
                storeIndex++;
            }
        }
        swap(array, rightIndex, storeIndex);
        return storeIndex;
    }
    private void swap(int[] array, int index1, int index2) {
        int tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
    }