冒泡排序和快速排序

冒泡排序

思路：
左边大于右边交换一趟排下来最大的在右边

时间复杂度：最坏 O(N^2)，最好 O(N)

空间复杂度：O(1)

    public static void bubbleSort(int[] arr){
        //用于记录数组长度
        int len = arr.length;
        for(int i =0;i<len;i++){
            //内层for循环会选出最大的放在数组最后
            for(int j =0;j<len - i - 1;j++){//每选一个最大的出来后下一轮循环要循环的次数就减一
                if(arr[j] > arr[j+1]){
                    //元素交换
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

快速排序(交换法)：

思路：

取数组中最左边或最右边的元素，然后通过这个数将整个数组分为左右两部分，左边的数字全部小于num，右边的数字全部大于num，然后再按照这个方法对这2部分代码进行排序，则最终可以达到将整个数据变成有序序列

时间复杂度：最坏 O(N^2)，最好 O(nlogn)

空间复杂度：快速排序没有开辟新的空间，而是用了递归的方式，递归会开辟栈帧

    public static void main(String[] args) {
        int[] arr = {1,2,2,1,7,8,3,2,1,5,0,10,16,11,13,20,21,19,15};
        quickSort(arr,0,arr.length-1);
        for(int n = 0; n <arr.length;n++){
            System.out.print(arr[n] +",");
        }
    }

    public static void quickSort(int[] arr,int left,int right){
        if(left < right){
            int pi = partition(arr,left,right);//pi是分区索引
            quickSort(arr,left,pi-1);
            quickSort(arr,pi+1,right);
        }
    }


private static int partition(int[] arr, int left, int right) {
        int index = left;//基数位置
        int targetKey = arr[index];//获取最左边元素的值
        while (left < right){//左右没相遇时
            while (left < right && arr[right] >= targetKey){
                //右指针一直向左移动，一直到 右指针的值小于基数值
                right--;
            }
            while (left < right && arr[left] <= targetKey){
                //左指针一直向右移动，一直到 左指针的值大于基数值
                left++;
            }
            //交换左右指针的值
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //当left == right 指针相遇后
        //交换当前相遇指针的值和基数的值
        int temp = arr[index];
        arr[index] = arr[left];
        arr[left] = temp;
        return left;
    }