数据结构：常见排序算法(3) -- 交换排序（冒泡排序、快速排序）

（1）冒泡排序

①原理：

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

②代码实现：

import java.util.Arrays;
//冒泡排序：  时间复杂度O(n^2)  空间复杂度：O(1)
public class bubbleSort {
    public static void main(String[] args) {
        int[] array={5,8,1,2,5,22,44,15,3,0,48};
        System.out.println(Arrays.toString(array));
        bubble(array);
        System.out.println(Arrays.toString(array));
    }
    public static void bubble(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            boolean isSorted = true;
            for (int j = 0; j < array.length - i - 1; j++) {
                // 相等不交换，保证稳定性
                if (array[j] > array[j + 1]) {
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }
        }
    }
}

运行截图：

③性能分析

**稳定性：**稳定

（2）快速排序

①原理–partition：

1.从待排序区间选择一个数，作为基准值(pivot)；
2.Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3.采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

②代码实现：

import java.util.Arrays;

/**
 * 快速排序  时间复杂度：O(n*log2n)~O(n^2)    空间复杂度：O(log2n)~O(n)
 *稳定性：不稳定
 */
public class quickSort {
  
   //非递归实现
    public static void quSort(int[] array){
        Stack<Integer> stack=new Stack<>();
        int low=0;
        int high=array.length-1;
        int piv=pivot(array,low,high);
        if(piv>low+1){
            stack.push(low);
            stack.push(piv-1);
        }
        if(piv<high-1){
            stack.push(piv+1);
            stack.push(high);
        }
        while(!stack.empty()){
            high=stack.pop();
            low=stack.pop();
            piv=pivot(array,low,high);
            if(piv>low+1){
                stack.push(low);
                stack.push(piv-1);
            }
            if(piv<high-1){
                stack.push(piv+1);
                stack.push(high);
            }
        }
    }
   
    public static void main(String[] args) {
        int[] arr={5,4,1,40,82,12,45,20,0,1};
        System.out.println(Arrays.toString(arr));
        quSort(arr);
        System.out.println(Arrays.toString(arr));

        int[] array=new int[1_0000];
        for (int i = 0; i < array.length; i++) {
            array[i]=i;
        }
        quickSort1(array);
    }
   
    //递归实现快速排序函数
    public static void quickSort1(int[] array){
        quick(array,0,array.length-1);  //接口
    }
    public static void quick(int[] array,int low,int high){
        if(low<high){
            int piv=pivot(array,low,high);
            quick(array,low,piv-1);   //递归实现
            quick(array,piv+1,high); //递归实现
        }
    }
    //找基准的函数
    public static int  pivot(int[] array,int start,int end){
        int tmp=array[start];
        while(start<end){
            while(start<end && array[end]>=tmp){
                end--;
            }
            //把数值赋值给start
            array[start]=array[end];
            while(start<end && array[start]<=tmp){
                start++;
            }
            //把start下标的值给end
            if(start>=end){
                break;
            }else{
                array[end]=array[start];
            }
        }
        array[start]=tmp;
        return start;
    }
}

运行截图：

优化后代码实现（三数取中法）：

/**
 * @Author: XiShanShan
 * @Description:
 * @Date:Created in 20:21 2021/3/30
 * @Modified By:xss666
 */

import java.util.Arrays;

/**
 * 快速排序  时间复杂度：O(n*log2n)~O(n^2)    空间复杂度：O(log2n)~O(n)
 *稳定性：不稳定
 */
public class quickSort {
    public static void main(String[] args) {
        int[] array=new int[1_0000];
        for (int i = 0; i < array.length; i++) {
            array[i]=i;
        }
        quickSort1(array);
    }
    //快速排序函数
    public static void quickSort1(int[] array){
        long startTime=System.currentTimeMillis();
        quick(array,0,array.length-1);  //接口
        long endTime=System.currentTimeMillis();
        System.out.println(endTime-startTime); //输出排序所需要的时间
    }

    public static void swap(int[] array,int k,int i){
        int tmp=array[k];
        array[k]=array[i];
        array[i]=tmp;
    }

    //三数取中法优化
    public static void medianOfThree(int[] array,int low,int high){
        int mid=(low+high)/2;

        if(array[low]<=array[mid]){
            swap(array,low,mid);
        }//mid<=low

        if(array[low]>array[high]){
            swap(array,low,high);
                }//array[low]<=array[high]

        if(array[mid]>array[high]){
            swap(array,mid,high);
        }  //array[mid]<array[high]
    }
    public static void quick(int[] array,int low,int high){
        if(low<high){

            //优化后
            medianOfThree(array,low,high);
            int piv=pivot(array,low,high);
            quick(array,low,piv-1);   //递归实现
            quick(array,piv+1,high);
        }
    }
    //找基准的函数
    public static int  pivot(int[] array,int start,int end){
        int tmp=array[start];
        while(start<end){
            while(start<end && array[end]>=tmp){
                end--;
            }
            //把数值赋值给start
            array[start]=array[end];
            while(start<end && array[start]<=tmp){
                start++;
            }
            //把start下标的值给end
            if(start>=end){
                break;
            }else{
                array[end]=array[start];
            }
        }
        array[start]=tmp;
        return start;
    }
}

优化后的代码排序的速度会大大提高：

将1_0000个数据大小的数组排序后，时间节省了26ms左右

③性能分析

稳定性： 不稳定