欢迎Java爱好者品读其他算法详解:
简单比较排序:http://blog.csdn.net/ysjian_pingcx/article/details/8652091
冒泡排序: http://blog.csdn.net/ysjian_pingcx/article/details/8653732
选择排序: http://blog.csdn.net/ysjian_pingcx/article/details/8656048
直接插入排序:http://blog.csdn.net/ysjian_pingcx/article/details/8674454
快速排序优化:http://blog.csdn.net/ysjian_pingcx/article/details/8687444
![](https://img-my.csdn.net/uploads/201303/18/1363593054_8459.jpg)
/**
* 快速排序的入口
* @param array
*/
public void quickSort(int... array){
quickSort(0, array.length - 1, array);
}
@这个方法是我个人提取出来的公共接口,也可以不这么设计,然后里面调用的quickSort(0, array.length - 1, array);是用到递归的方法:
/**
* 快速排序的递归调用
* @param low
* @param high
* @param array
*/
private void quickSort(int low, int high, int... array) {
if (low < high) {
int pivot = partition(low, high, array); // 找到枢轴记录的下标
quickSort(low, pivot - 1, array); // 对低子表进行递归排序
quickSort(pivot + 1, high, array); // 对高子表进行递归排序
}
}
@int pivot = partition(low, high, array)这个参数是快速排序算法中核心方法的返回值,就是需找一个枢轴的值,再以这个枢轴为分界线,一分为二,进行递归调用
/**
* 快速排序的核心程序
* @param low
* @param high
* @param array
* @return 返回枢轴记录
*/
private int partition(int low, int high, int... array) {
int pivotKey = array[low]; // 将数组的第一个元素作为枢轴记录
while (low < high) {
while (low < high && array[high] >= pivotKey) {
high--;
}
swap(low, high, array);// 把比枢轴记录小的值交换到低端
while (low < high && array[low] <= pivotKey) {
low++;
}
swap(low, high, array);// 把比枢轴记录大的值交换到高端
}
return low; //返回枢轴记录的下标
}
@int povitKey = array[low], 这种方式,是将一个待排序的部分的第一个记录作为一个默认的参照
while (low < high && array[high] >= pivotKey) {
high--;
}
swap(low, high, array);// 把比枢轴记录小的值交换到低端
while (low < high && array[low] <= pivotKey) {
low++;
}
swap(low, high, array);// 把比枢轴记录大的值交换到高端
@第一个循环:while (low < high && array[high] >= pivotKey) {high--;},从右端开始,如果array[high] >= pivotKey,指针直接往前走,当有比参照povitKey小的值时,就终止循环,并交换这个小的值和参照的值;
![](https://img-my.csdn.net/uploads/201303/18/1363596699_3170.jpg)
![](https://img-my.csdn.net/uploads/201303/18/1363596711_3281.jpg)
![](https://img-my.csdn.net/uploads/201303/18/1363596729_2680.jpg)
![](https://img-my.csdn.net/uploads/201303/18/1363596744_4996.jpg)
/**
* 原始的快速排序法
* @author PingCX
*
*/
public class QuickSort {
public static void main(String[] args) {
QuickSort qComplete = new QuickSort();
int[] array = { 25, 36, 21, 45, 13};
System.out.println(Arrays.toString(array));
qComplete.quickSort(array);//调用快速排序的方法
System.out.println(Arrays.toString(array));//打印排序后的数组元素
}
/**
* 快速排序的入口
* @param array
*/
public void quickSort(int... array){
quickSort(0, array.length - 1, array);
}
/**
* 快速排序的递归调用
* @param low
* @param high
* @param array
*/
private void quickSort(int low, int high, int... array) {
if (low < high) {
int pivot = partition(low, high, array); // 找到枢轴记录的下标
quickSort(low, pivot - 1, array); // 对低子表进行递归排序
quickSort(pivot + 1, high, array); // 对高子表进行递归排序
}
}
/**
* 快速排序的核心程序
* @param low
* @param high
* @param array
* @return 返回枢轴记录
*/
private int partition(int low, int high, int... array) {
int pivotKey = array[low]; // 将数组的第一个元素作为枢轴记录
while (low < high) {
while (low < high && array[high] >= pivotKey) {
high--;
}
swap(low, high, array);// 把比枢轴记录小的值交换到低端
while (low < high && array[low] <= pivotKey) {
low++;
}
swap(low, high, array);// 把比枢轴记录大的值交换到高端
}
return low; //返回枢轴记录的下标
}
/**
* 内部实现,用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private void swap(int oneIndex, int anotherIndex, int[] array) {
int temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
/**
* 任意可以比较的类型的快速排序法
* @author PingCX
*
*/
public class QuickSortT {
public static void main(String[] args) {
QuickSortT qComplete = new QuickSortT();
//Integer实现了Comparable接口
Integer[] array = { 25, 36, 21, 45, 13};
System.out.println(Arrays.toString(array));
qComplete.quickSort(array); // 调用快速排序的方法,参数必须是实现Comparable接口
System.out.println(Arrays.toString(array)); // 打印排序后的数组元素
}
/**
* 快速排序的入口
*
* @param array
*/
public <T extends Comparable<T>> void quickSort(T[] array) {
quickSort(0, array.length - 1, array);
}
/**
* 快速排序的递归调用
*
* @param low
* @param high
* @param array
*/
private <T extends Comparable<T>> void quickSort(int low, int high,
T[] array) {
if (low < high) {
int pivot = partition(low, high, array); // 找到枢轴记录的下标
quickSort(low, pivot - 1, array); // 对低子表进行递归排序
quickSort(pivot + 1, high, array); // 对高子表进行递归排序
}
}
/**
* 快速排序的核心程序
*
* @param low
* @param high
* @param array
* @return 返回枢轴记录
*/
private <T extends Comparable<T>> int partition(int low, int high,
T[] array) {
T pivotKey = array[low]; // 将数组的第一个元素作为枢轴记录
while (low < high) {
while (low < high && array[high].compareTo(pivotKey) >= 0) {
high--;
}
swap(low, high, array);// 把比枢轴记录小的值交换到低端
while (low < high && array[low].compareTo(pivotKey) <= 0) {
low++;
}
swap(low, high, array);// 把比枢轴记录大的值交换到高端
}
return low; // 返回枢轴记录的下标
}
/**
* 内部实现,用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private <T extends Comparable<T>> void swap(int oneIndex, int anotherIndex,
T[] array) {
T temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
欢迎Java爱好者品读其他算法详解:
简单比较排序:http://blog.csdn.net/ysjian_pingcx/article/details/8652091
冒泡排序: http://blog.csdn.net/ysjian_pingcx/article/details/8653732
选择排序: http://blog.csdn.net/ysjian_pingcx/article/details/8656048
直接插入排序:http://blog.csdn.net/ysjian_pingcx/article/details/8674454
快速排序优化:http://blog.csdn.net/ysjian_pingcx/article/details/8687444