简单易懂 快速排序Java实现

其实快速排序并不难，只要理解原理 完整走一遍就可以了

简要过程

先定义一个基准数，一般取数组第一个数为基准，然后不断从右向左找从左向右找，把小于基准数的数放在他的左边，大于基准数的数放在他的右边，再把基准数的左右两边作为单独部分重复上述步骤，直到全部排列完毕

完整过程详解

定义测试数组 int[ ] arr = {2, 7, 1, 3, 5, 4};
1. 第一轮：
每一轮都 令变量 i 为 0，j 为数组长度减1，temp为数组第一个数
定义变量 i = 0， j = arr.length-1， temp = arr[0]

• 在 j>=i 的情况下，从右向左寻找第一个小于temp的值，j不断自减，直到找到数组中的1时满足条件，此时j=2,令arr[i] = arr[j] , 这时数组为{1, 7, 1, 3, 5, 4}
• 在 i<=j 的情况下，再从左向右寻找第一个大temp的值，i不断自增，直到找到数组中的7时满足条件，此时i=1，令arr[j] = arr[i],这时数组为{1, 7, 7, 3, 5, 4} , i与j不相等，继续从右向左寻找
• 在 j>=i 的情况下，从右向左寻找第一个小于temp的值, j=1时j与i相等，第一轮结束，令arr[i] = temp，此时数组为{1, 2, 7, 3, 5, 4}
• 把数组分为arr[0] ~ arr[j-1] 和 arr[j+1]~arr[length-1] , 即{1} 和 {7, 3, 5, 4}两个数组，再分别进行上述步骤

2. 第二轮
由于第一个数组只有一个成员不用进行排列，因此对第二的数组 {7, 3, 5, 4}重复上述步骤进行排列

• 在 j>=i 的情况下，从右向左寻找第一个小于temp的数，即4，令arr[i] = arr[j]，这时数组为{4, 3, 5, 4}
• 在 i<=j 的情况下，再从左向右寻找第一个大于temp的值，即第二个4，令arr[j] = arr[i], 这时数组为{4, 3, 5, 4}，此时j=3，j与i相等，令arr[i] = temp，此时数组为{4, 3, 5, 7}
• 这时数组只有arr[0] ~ arr[j-1]一部分即{4, 3, 5}，这一部分再进行上述步骤

3. 第三轮

• 在 j>=i 的情况下，从右向左寻找第一个小于temp的数，即3，令arr[i] = arr[j]，这时数组为{3, 3, 5}
• 在 i<=j 的情况下，再从左向右寻找第一个大于temp的值，即第二个3，令arr[j] = arr[i], 这时数组为{3, 3, 5}，此时j=1，j与i相等，令arr[i] = temp，此时数组为{3, 4, 5}
• 这时arr[0] ~ arr[j-1] 和 arr[j+1]~arr[length-1]分别为{3}和{5}, 每一部分都排列完毕不再进行下一轮
• 数组排列完毕，为{1, 2, 3, 4, 5, 7}

完整代码

public class Test2 {
 public static void main(String[] args) {
 //测试数组
  int[] arr = {2,7,1,3,5,4};
//  int[] arr = {10,7,2,62,3,4,2,1,8,9,19};
//  int[] arr = {10,7,2,62,3,4,2,1,7,8,9,19};
//  int[] arr = {3,1,5,4,7};

  quickSort(arr,0,arr.length-1);

  for(int i:arr) {
     System.out.println(i);
  }
}

static void quickSort(int[] arr,int low,int high) {
  if(low<high) {
   int i = low;
   int j = high;
   int temp = arr[low];
   while(i<j) { 
    while(i<j && arr[j]>=temp) j--;
    arr[i] = arr[j];
    
    while(i<j && arr[i]<=temp) i++;
    arr[j] = arr[i]; 
   }
   arr[i] = temp;
   
   quickSort(arr,low,j-1);
   quickSort(arr,j+1,high);
  } 
 }
}

输出结果：

1
2
3
4
5
7