java排序-冒泡排序、快速排序

冒泡排序

正如名称这样，类似于一个气泡，从下往上升，比较当前这个值和下一个值，决定是否交换。

过程如下(升序)：

1.从0开始，比较length(数组长度)轮，每一轮比较如下。

   1）比较arr[i](从0开始，小于当前轮数)个元素和arr[i+1]个元素，如果arr[i]>arr[i+1],则交换两个元素。

   2）i=i+1。重复这两个步骤。

2.开始第二轮，第三轮，以此类推，每一轮比较的此时是length-当前轮数，并逐步得到最终结果。

部分步骤如图：

实现：

public static void main(String[] args){
        int[] a= new int[]{5,4,22, 2, 9, 15, 23, 17};
        bubbleSort(a);
        System.out.print("最终排序结果：");
        for(int i=0; i< a.length; i++){
            System.out.print(a[i] + " ");
        }
    }

    public static void bubbleSort(int [] arr){
        int times = 0;
        for(int i = 1; i < arr.length-1; i++){
            //从小到大，从0开始，从大到小，从末尾开始
            for(int j=0; j<arr.length-i; j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                times++;
            }
            System.out.println("第" + i + "排序：");
            for(int k=0; k< arr.length; k++){
                System.out.print(arr[k] + " ");
            }
            System.out.println();
        }
        System.out.println("次数：" + times);
    }

快速排序

       快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的）， 比基准值大的都在右边（一般是无序的）。

        一般选择序列的第一个元素。 一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有 继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比 较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的 值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值 来说，左右两边就是有序的了。

示例图：

代码如下：

public static void main(String[] args){
        int[] a= new int[]{5,4,22, 2, 9, 15, 23, 17};
        quickSort(a, 0, a.length-1);
        System.out.print("最终排序结果：");
        for(int i=0; i< a.length; i++){
            System.out.print(a[i] + " ");
        }
    }

    public static void quickSort(int [] arr, int start, int end){
        int times = 0;
        int low = start;
        int high = end;

        int x = arr[start];
        while(low < high){
            //从右往左找一个比x小的数据
            while (low < high && x < arr[high]){
                high--;
            }
            //找到则low++；
            if(low<high){
                arr[low] = arr[high];
                low++;
                times++;
            }

            //从又往左往右找一个比x大的数据
            while (low < high && x > arr[low]){
                low++;
                times++;
            }
            //找到则high--；
            if(low<high){
                arr[high] = arr[low];
                high--;
            }
            arr[low] = x;
            for(int k=0; k< arr.length; k++){
                System.out.print(arr[k] + " ");
            }
            System.out.print("次数:" + times + " 分段结束：" + low+  " 分段开始：" +high);
            System.out.println();
        }
        if(low > start){
            quickSort(arr, start, low-1);
        }
        if(high < end){
            quickSort(arr, high+1, end);
        }
    }