java 快速排序及代码示例

快速排序是一种高效的排序算法，它使用分治策略来对一个数组进行排序。它是由冒泡排序演变而来，比冒泡排序更快的排序算法。之所以快，是因为快速排序用了分治法。

相同的是，与冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换来排序。

不同的是，冒泡排序每一轮只把一个元素冒泡到数列的一端，而快速排序每轮挑选一个基准元素，让比它小的元素移动到一端，让比它大的元素移动到另一端，从而把数列拆解成两个部分。

快速排序的主要步骤如下：

1. 选择一个枢纽值（通常选择数组的最后一个元素）。

2. 重新排列数组中的元素，将所有小于枢纽值的元素放到枢纽左边，大于枢纽值的元素放到枢纽右边。

3. 对枢纽左右两边的子数组进行递归排序。递归到最底结束时，每个子数组只包含一个元素，最后完成排序

package test;

import java.util.Arrays;

/**
 * java快速排序
 * @author Administrator
 *
 */
public class QuickSort {

    public static void main(String[] args) {
          int[] arr = {13, 7, 6, 9, 1, 5};
            quickSort(arr, 0, arr.length - 1);
//            // 输出排序后的数组
//            for (int val : arr) {
//                System.out.print(val + " ");
//            }
            System.out.println("排序后的数组："+Arrays.toString(arr)); 
    }
    
    /**
     * 递归排序：自定义快速排序
     * @param arr 数组大小
     * @param low 最小值
     * @param high
     */
     public static void quickSort(int[] arr, int low, int high) {
            if (low < high) {
                // 获取分区后的枢纽位置
                int pivotIndex = partition(arr, low, high);
                
                // 分别对枢纽左右两边的子数组进行递归排序
                quickSort(arr, low, pivotIndex - 1);
                quickSort(arr, pivotIndex + 1, high);
            }
        }
     
        private static int partition(int[] arr, int low, int high) {
            // 选择数组的最后一个元素作为枢纽值
            int pivot = arr[high];
            int i = (low - 1);
            
            // 遍历数组，将小于枢纽值的元素放到左边，大于枢纽值的元素放到右边
            for (int j = low; j < high; j++) {
                if (arr[j] < pivot) {
                    i++;
     
                    // 交换 arr[i] 和 arr[j]
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
     
            // 将枢纽元素放到正确的位置
            int temp = arr[i + 1];
            arr[i + 1] = arr[high];
            arr[high] = temp;
     
            // 返回枢纽位置
            return i + 1;
        }
     
}