经验证，快速排序是速度最快的排序方式！比冒泡快的不是一点点！
/**冒泡排序
* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
* 针对所有的元素重复以上的步骤，除了最后一个。
* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
*/快速排序的基本思想：
通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。
升序排列：
package com.hczk.controller;
import java.util.Arrays;
/**
* Created by Administrator on 2018/12/11 0011.
*/
public class QuickSort {
public static void main(String args[]) {
int[] arrays ={1, 12, 2, 13, 3, -14, 4, 15, 5, 16, 17, 17, 177, 18, 8, 8, 19};
System.out.println(Arrays.toString(subQuickSort(arrays, 0, arrays.length - 1)));
}
public static int[] subQuickSort(int[] arrays, int start, int end) {
if (start < end) {
int middleIndex = subQuickSortCore(arrays, start, end);//将numbers数组进行一分为二
subQuickSort(arrays, start, middleIndex - 1);//对低字段表进行递归排序
subQuickSort(arrays, middleIndex + 1, end);//对高字段表进行递归排序
}
return arrays;
}
public static int subQuickSortCore(int[] arrays, int start, int end) {
int middleValue = arrays[start];
while (start < end) {
while (arrays[end] >= middleValue && start < end) {//
end--;
}
arrays[start] = arrays[end];
while (arrays[start] <= middleValue && start < end) {//
start++;
}
arrays[end] = arrays[start];
}
arrays[start] = middleValue;
return start;
}
}
把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它大不做任何处理；交换了以后再和小的那端比，比它小不交换，比他大交换。这样循环往复，一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，然后再用分治法，分别对这两个独立的数组进行排序。
package com.hczk.controller;
import java.util.Arrays;
/**
* Created by Administrator on 2018/12/11 0011.
*/
public class QuickSort {
public static void main(String args[]) {
int[] arrays ={1, 12, 2, 13, 3, -14, 4, 15, 5, 16, 17, 17, 177, 18, 8, 8, 19};
System.out.println(Arrays.toString(subQuickSort(arrays, 0, arrays.length - 1)));
}
public static int[] subQuickSort(int[] arrays, int start, int end) {
if (start < end) {
int middleIndex = subQuickSortCore(arrays, start, end);//将numbers数组进行一分为二
subQuickSort(arrays, start, middleIndex - 1);//对低字段表进行递归排序
subQuickSort(arrays, middleIndex + 1, end);//对高字段表进行递归排序
}
return arrays;
}
public static int subQuickSortCore(int[] arrays, int start, int end) {
int middleValue = arrays[start];
while (start < end) {
while (arrays[end] <= middleValue && start < end) {//
end--;
}
arrays[start] = arrays[end];
while (arrays[start] >= middleValue && start < end) {//
start++;
}
arrays[end] = arrays[start];
}
arrays[start] = middleValue;
return start;
}
}
降序
时代不断进步！主要提倡上面的方式，下面的只做参考
package com.hczk.controller;
import java.util.Arrays;
/**
* Created by Administrator on 2018/12/11 0011.
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {60, 55, 48, 37, 10, 90, -84, 36};
System.out.println("升序快排后----->" + Arrays.toString(quickSort(arr, 0, arr.length - 1)));
}
public static int[] quickSort(int[] arr, int low, int high) {
int i, j, temp;
i = low;//低端下标
j = high;//高端下标
temp = arr[i];//取第一个元素为标准元素。
while (i < j) {//递归出口是 low>=high
while (i < j && temp <= arr[j]) //在数组的后端扫描
j--;//移动后j再减了一个，即在temp前一个咯
if (i < j) {
arr[i] = arr[j];
i++;
}
while (i < j && arr[i] < temp) //在数组的左端扫描
i++;
if (i < j) {
arr[j] = arr[i];
j--;
}
}//while完，即第一盘排序
arr[i] = temp;//把temp值放到它该在的位置
// System.out.println("第 次排序----->"+Arrays.toString(arr));
if (low < i) {
quickSort(arr, low, i - 1);//对左端子数组递归
}
if (i < high) {
quickSort(arr, j + 1, high);//对右端子数组递归
}
return arr;
}
}
相比于上面一个，似乎做了一点改变。
package com.hczk.controller;
import java.util.Arrays;
/**
* Created by Administrator on 2018/12/11 0011.
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {60, 55, 48, 37, 10, 90, -84, 36};
System.out.println("降序快排后----->" + Arrays.toString(quickSort(arr, 0, arr.length - 1)));
}
public static int[] quickSort(int[] arr, int high, int low) {
int i, j, temp;
i = high;//高端下标
j = low;//低端下标
temp = arr[i];//取第一个元素为标准元素。
while (i < j) {//递归出口是 low>=high
while (i < j && temp > arr[j])//后端比temp小，符合降序，不管它，low下标前移
j--;//while完后指比temp大的那个
if (i < j) {
arr[i] = arr[j];
i++;
}
while (i < j && temp < arr[i])
i++;
if (i < j) {
arr[j] = arr[i];
j--;
}
}//while完，即第一盘排序
arr[i] = temp;//把temp值放到它该在的位置。
if (high < i) {//注意，下标值
quickSort(arr, high, i - 1);//对左端子数组递归
}
if (i < low) { //注意，下标值
quickSort(arr, i + 1, low);//对右端子数组递归 ；对比上面例子，其实此时i和j是同一下标!!!!!!!!!!!!!
}
return arr;
}
}
降序排列