第一种快速排序算法：
/**
* created by pc-fengc on 2018-06-06 09:31.
*
*Java 代码的快速排序算法
* 快速排序的原理 ：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的，都放在右边（一般是无序的）。一般基准值选择序列的第一个元素。
*/
public class FastSorting {
public static void main(String[] args) {
int[] arr = {11,67,98,35,9,43,2,1,6,34,89,32,33,65,76,80,88,89};
int start = 0;
int end = arr.length - 1; //数组是从0下标开始的
sort(arr,start,end);
for (int a :arr) System.out.print(a + " ");
System.out.println("");
}
public static void sort(int[] a, int low,int high) {
int start = low;
int end = high;
int key = a[start];
while (end > start) {
/*从后往前比较大小，遇到比基数小，交换位置*/
while (end > start && a[end] >= key) end -- ; //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
if (a[end] < key) swapArr(a,start,end); //基数与比基数小的交换位置
/*从前往后比较大小，遇见比基数大的，交换位置*/
while (end > start && a[start] <= key) start ++; ///如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
if (a[start] > key) swapArr(a,start,end);//基数与比基数大的交换位置
} //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
/*进行递归*/
if (start > low) sort(a,low,start - 1); /*左边的值都比基数小，所以递归比较基数左边的数组*/
if (end < high) sort(a,end + 1,high); /*右边的值都比此基数大，所以递归比较基数右边的数组*/
}
//数组中两个位置交换
private static void swapArr(int[] a,int start,int end){
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
}第二种：冒泡算法：
/**
* created by pc-fengc on 2018-06-06 14:27.
* 冒泡算法..........
*冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
* 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成
* 。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = getIntArr(100);
System.out.println("输出之前的数组：");
for (int a :arr) System.out.print(a + "\t");
System.out.println("");
System.out.println("输出冒泡排序后的数组：");
sortBubble(arr);
for (int a :arr) System.out.print(a + "\t");
System.out.println("");
}
public static int[] getIntArr(int n) {
int[] a = new int[n];
for (int i = 0 ; i < n ; i++) {
a[i] = (int)(Math.random() * 100);
}
return a;
}
public static void sortBubble(int[] a) {
int temp = 0;
int size = a.length;
for (int i = 0 ; i < size - 1 ; i ++) {
for (int j = 0 ; j < size - 1 - i ; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
}第三种：快速排序算法 使用二分法，返回基准值下标
/**
* created by pc-fengc on 2018-06-06 11:23.
*/
public class FastSortMiddle {
public static void main(String[] args) {
int[] arr = getIntArr(50);
sort(arr,0,arr.length - 1);
for (int a : arr) System.out.print(a + " ");
System.out.println("");
}
/**
* 递归排序数组
* @param a
* @param start
* @param end
*/
public static void sort(int[] a,int start,int end) {
if(start < end) {
int middle = getMiddle(a,start,end);
sort(a,start,middle - 1);
sort(a,middle + 1,end);
}
}
/**
* 将数组的某一段元素进行划分，小的在左边，大的在右边
* 返回划分的中间值
* @param a
* @param start
* @param end
* @return
*/
private static int getMiddle(int[] a,int start,int end) {
int key = a[start]; /*以第一个数字作为为基准值*/
while (start < end) { //start一旦等于end，就说明左右两个指针合并到了同一位置，可以结束此轮循环。
while (start < end && a[end] >= key) end --; /*从右边开始往左遍历，比基准数大的继续往前*/
if (a[end] < key) { //上面的while循环结束时，就说明当前的a[end]的值比基准值小，应与基准值进行交换
swapArr(a,start,end);
start ++; //交换后，此时的那个被调换的值也同时调到了正确的位置(基准值左边)，因此左边也要同时向后移动一位
}
while (start < end && a[start] <= key) start ++;
if (a[start] > key) { //上面的while循环结束时，就说明当前的a[start]的值比基准值大，应与基准值进行交换
swapArr(a,start,end);
end --;
}
}
//这里返回start或者end皆可，此时的start和end都为基准值所在的位置
return end;
}
/**
* 得到一串每个数字小于100的数组
* @param n 代表数组多少个
* @return
*/
public static int[] getIntArr(int n) {
int[] a = new int[n];
for (int i = 0 ; i < n ; i++) {
a[i] = (int)(Math.random() * 100);
}
return a;
}
/**
* 数组中两个不同的下表数字交换位置
* @param a
* @param start
* @param end
*/
private static void swapArr(int[] a,int start,int end) {
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
}