快速排序，选择排序，冒泡排序

三种排序算法是在数组排序中用到比较多的，下面来具体说明各种排序方法以及区别

 快速排序法

使用快速排序方法对a[n]排序
从a[n]中选择一个元素作为基准，一般选a[0]，设定low指向a[0](队首),high指向a[n-1](队尾)，
先从队尾开始向前扫描,若a[high]>a[0]，则high++，否则将a[high]赋值给a[low]，即a[low]=a[high]
然后从队首开始向前扫描,若a[low]<a[0]，则low++，否则a[high]=a[low]
这样，会将所有小于基准数a[0]的元素放到a[0]左边，把大于a[0]的元素都放到a[0]右边
再使用递归分别对左边、右边的子数组进行排序，最终完成排序

//快速排序算法
static void quicksort(int arr[], int low, int high){
    int length = high;
    if(low < high){
        int temp = arr[low];//temp是作为比较的基数
        while(low < high){
            // 当队尾的元素大于等于基准数据时,向前挪动high指针
            while(low < high && arr[high] >= temp){
                high--;
            }
            //此时是arr[high] < temp,将arr[high]赋值给arr[low]
            arr[low] = arr[high];
            
            // 当队首的元素大于等于基准数据时,向后挪动low指针
            while(low < high && arr[low] <= temp){
                low++;
            }
            //此时是arr[low] > temp, 将arr[low]赋值给arr[high]
            arr[high] = arr[low];
        }
        //当一轮循环过后，low = high时,此时的low或high就是temp的正确索引位置
        //此时low位置的值并不是tmp,所以需要将temp赋值给arr[low]
        arr[low] = temp;
        int index = low;//返回temp的索引位置
        
        // 递归调用，按照上述方法流程继续对index位置两端的子数组进行排序
        quicksort(arr, 0, index-1);
        quicksort(arr, index+1, length);
    }
}

//冒泡排序，小到大
@Test
public void bubbleSort(){
    Scanner sc = new Scanner(System.in);
    int temp, arr[];
    while(sc.hasNext()){//可循环进行测试
        //输入数组长度和数组，比如：输入5回车后，再输入 1 3 4 2 6
        int n = sc.nextInt();
        arr = new int[n];
        for(int i =0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        //数组中相临两数比较，前面的大于后者就交换位置
        //冒泡排序：每一轮将依次出现一个最大数（最右边），次大数...
        for(int i=0;i<n-1;i++){
            for(int j=0;j<n-1-i;j++){
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }                
        }
        //排序后
        for(int i=0;i<n;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

//选择排序，小到大
@Test
public void selectSort(){
    Scanner sc = new Scanner(System.in);
    int temp, arr[];
    while(sc.hasNext()){//可循环进行测试
        int n = sc.nextInt();                
        arr = new int[n];
        for(int i =0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        //数组中每个数依次与它后面的数进行比较，若前者大于后者，交换二者位置
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                if(arr[i]>arr[j]){
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }                
        }
        //排序后
        for(int i=0;i<n;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

另外，冒泡排序和选择排序相似，时间复杂度也相同。

下面是各种排序算法的复杂度比较：

以上就是三种排序法的介绍，如有不足指出！

快速排序可参考：https://blog.csdn.net/nrsc272420199/article/details/82587933

int length = high;