快速排序的核心思想(升序）：从一个数组里面随意选取一个数作为基准数，将比基准数小的放在基准数的左边、比基准数大的放在基准数的右边，然后再对分成的左右两边进行同样的递归处理，最终达到数组有序

package sort;

import java.util.Arrays;

public class QuickSort { 
    public static void main(String[] args) { 
        int[] arr = { 3, -1, 6, 24, -13, 9, 42};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) { 
        int l = left, r = right, temp; // 定义左索引、右索引与临时变量temp
        int pivot = arr[(left + right) / 2]; // 定义基准值
        // l索引向右找出大于基准值的数，直到基准值本身
        // r索引向左找出小于基准值的数，直到基准值本身，因此定义该while循环用于控制程序的结束
        while (l < r) { 
            // 内循环（1）
            while (arr[l] < pivot) { 
                l++;
            }
            // 内循环（2）
            while (arr[r] > pivot) { 
                r--;
            }
            // l向右寻找，r向左寻找，可能最多可能找到pivot值本身，那时也直接说明
            // 以基准值为中心，左边的值都是小于pivot，右边的值都是大于pivot，那么两边已经满足条件，可以直接退出
            if (l == r) { 
                break;
            }
            // 找到之后交换彼此的值
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            // 数值交换后，l索引的值可能会和pivot的值相等，那么一遇到内循环（1）便会结束
            // 但是r索引的值可能最多只是找到pivot本身，那么r便一直大于l，外层循环永不结束
            // 因此定义该if条件，结束外层循环
            if (arr[l] == pivot) { 
                r--;
            }
            // 同上r索引也是如此
            if (arr[r] == pivot) { 
                l++;
            }
        }
        // 防止栈溢出
        if (l == r) { 
            l++;
            r--;
        }
        // 向左递归，使左半部分有序
        if (left < r) { 
            quickSort(arr, left, r);
        }
        // 向右递归，使右半部分有序
        if (right > l) { 
            quickSort(arr, l, right);
        }
    }
}

效果如图：

若想实现降序，将内循环1、2的判断条件取反即可（不包括等于）