Java 冒泡排序和快速排序

1.冒泡排序

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

public class BubbleSort {

    public static void bubbleSort(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;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        System.out.println(Arrays.toString(array));
        bubbleSort(array);
        System.out.println("===================冒泡排序==================");
        System.out.println(Arrays.toString(array));
    }
}

• 稳定性：稳定
• 时间复杂度：
  • 最好：O(n)
  • 最坏：O(n^2)
  • 平均：O(n^2)
• 空间复杂度：O(1)

2.快速排序

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

public class QuickSort {

    public static void quick(int[] array,int low,int high){
        if (low >= high){
            return;
        }

        int par = partion(array,low,high);

        quick(array,low,par-1);

        quick(array,par+1,high);
    }

    public static int partion(int[] array,int low,int high){
        int tmp = array[low];
        while (low < high){
            while (array[high]>=tmp && low<high){
                high--;
            }
            if (low >= high){
                array[low] = tmp;
                break;
            } else {
                array[low] = array[high];
            }
            while (array[high]<=tmp && low<high){
                low++;
            }
            if (low >= high){
                array[high] = tmp;
                break;
            } else {
                array[high] = array[low];
            }
        }
        return low;
    }

    public static void quickSort(int[] array){
        quick(array,0,array.length-1);
    }

    public static void main(String[] args) {
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        System.out.println(Arrays.toString(array));
        quickSort(array);
        System.out.println("===================快速排序==================");
        System.out.println(Arrays.toString(array));
    }
}

• 稳定性：不稳定
• 时间复杂度：
  • 最好：O(n * log(n))
  • 平均：O(n * log(n))
  • 最坏：O(n^2)
• 空间复杂度：O(log(n)) （二叉树的深度）

非递归版本：

public class QuickSortNor {

    public static void quick(int[] array,int low,int high){
        Stack<Integer> stack = new Stack<>();
        int par = partion(array,low,high);

        if(par > low+1) {
            stack.push(low);
            stack.push(par-1);
        }

        if(par < high-1) {
            stack.push(par+1);
            stack.push(high);
        }

        while (!stack.empty()) {
            int end = stack.pop();
            int start = stack.pop();
            par = partion(array,start,end);
            if(par > start+1) {
                stack.push(start);
                stack.push(par-1);
            }

            if(par < end-1) {
                stack.push(par+1);
                stack.push(end);
            }
        }
    }

    public static int partion(int[] array,int low,int high){
        int tmp = array[low];
        while (low < high){
            while (array[high]>=tmp && low<high){
                high--;
            }
            if (low >= high){
                array[low] = tmp;
                break;
            } else {
                array[low] = array[high];
            }
            while (array[high]<=tmp && low<high){
                low++;
            }
            if (low >= high){
                array[high] = tmp;
                break;
            } else {
                array[high] = array[low];
            }
        }
        return low;
    }

    public static void quickSortNor(int[] array){
        quick(array,0,array.length-1);
    }

    public static void main(String[] args) {
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        System.out.println(Arrays.toString(array));
        quickSortNor(array);
        System.out.println("===================快速排序==================");
        System.out.println(Arrays.toString(array));
    }
}