快速、冒泡排序

一.快速排序

原理：

1. 将数组最左边的元素作为基数，从数组两边开始遍历；
2. 先从数组最右边往左遍历比基数小的数，称为left， 停下来
3. 接着从数组最左边往右遍历比基数大的数（不包括基数本身），称为right,停下来
4. 交换left和right的位置，第一次循环结束
5. 第二次循环两边的遍历分别往前递进一位，重复上述过程，直到左边和右边撞在一起，也就是left和right的下标相等，此时这个下标的元素和基数交换位置
6. 此时，基数左边的元素全是比它小的，基数右边的元素全是比它大的
7. 接着循环基数左边的数，基数变为最左边的元素，和上述遍历方式一样，这里采用递归函数的方式重复遍历
8. 然后循环基数右边的数，基数变为第一次的基数下标减1的元素，和上述遍历方式一样，依然是调用递归函数
9. 到此时，排序完成

public class QuickSortDemo {
    public static void main(String[] args) {
        int[] arr={5,6,9,8,73,1,5,2,4,2,54};
        quickSort(arr,0,arr.length-1);
        for (int i:arr
             ) {
            System.out.print(i+" ");
        }
    }
    public static void quickSort(int[] arr,int left,int right){
        if (left>right){
            return;
        }
        int index=arr[left];
        int i=left;
        int j=right;
        while(i != j){
            while(index<=arr[j] && i<j){
                j--;
            }
            while(index>=arr[i] && i<j){
                i++;
            }
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        arr[left]=arr[i];
        arr[i]=index;
        quickSort(arr,left,i-1);
        quickSort(arr,j+1,right);


    }

}

二.冒泡排序

原理：

1. 冒泡排序：每个位置的元素与它后面位置上面的元素比较，如果后数比前数小，就调换二者的位置
2. 外层循环：有几个数就循环几次
3. 内存循环：每次循环完一遍，就从第一个数继续比较

public class MaoPaoSort {

    public static void main(String[] args) {
        int[] arr={6,5,9,2,3,1,4,-6,-4};
        maopaoSort(arr);
        for (int a:arr
             ) {
            System.out.print(a+" ");
        }
    }
    public static void maopaoSort(int[] arr){
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr.length-1-i ; j++) {
                if (arr[j]>arr[j+1]) {
                    int index = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = index;

                }

            }
        }
    }
}