Java实现四种排序：桶排序，冒泡排序，选择排序，快速排序

下面代码主要是排序算法的java实现，针对不同的算法，程序分别对于实现。

1. 桶排序

很简单，时间复杂度是O（M+N),但是得占用的空间很大。比如1，4，2，9999，那么就需要开辟出10000个大小的数组来，造成空间的浪费。算法很不灵活。

2. 冒泡排序

时间复杂度是O(n^2)。基本思想就是逐趟把最小的数字放到数组的最前端。

3. 快速排序

平均的时间复杂度是O(nlgn)，但是如果遇见最坏得情况，时间复杂度就变成了O(n^2)与冒泡排序的时间复杂度是一样的。虽然不稳定，但是是经常使用的一种排序方法。

4. 选择排序

时间复杂度是O(n^2)，基本思想第一次循环，选出来最小的数字，放到数组的开头，然后第二次循环，选出第二小的数字放到开头。所以时间的复杂度是O(n^2).

package chapter1;

public class CheckExistDemo {
// the main function
public static void main(String[] args) {
// test array
int[] testArray = { 12, 35, 99, 18, 76 };
// using bucket sort and printing the result.
CheckExistDemo.bucketSort(testArray);
// using bubble sort and printing the result.
CheckExistDemo.bubbleSort(testArray);
CheckExistDemo.quickSort(testArray, 1, testArray.length - 1);
// print the quick sort result
System.out.print("The quick sort result is: ");
for (int i = 0; i < testArray.length; i++) {
if (i < testArray.length - 1) {
System.out.print(testArray[i] + ", ");
} else {
System.out.print(testArray[i]);
}
}
System.out.println();
// using select sort
CheckExistDemo.selectionSort(testArray);
}

/*
* Bucket sort: the time complexity is O(M+N); This method works as that:
* the size of the bucket is not depending on the size of t he array. It is
* depending on the value of the items of the array.
*/
public static void bucketSort(int[] array) {
System.out.print("The result of bucket sort is: ");
// initialize the whole array list into 0
// since the value of the arraylist is less than 100, then we must
// allocate 99 seats for the whole values
int[] bucket = new int[100];
for (int i = 0; i < 100; i++) {
bucket[i] = 0;
}
// for certain value, the bucket will add 1;
for (int i = 0; i < array.length; i++) {
bucket[array[i]]++;
}
// print the result
for (int i = 0; i < bucket.length; i++) {
if (bucket[i] != 0) {
if (i < bucket.length - 1) {
System.out.print(i + ", ");
} else {
System.out.print(i);
}
}
}
System.out.println();
}

/*
* Bubble sort: Time complexity is O(n^2). This one is not recommended.
*/
public static void bubbleSort(int[] array) {
System.out.print("The bubble sort result is: ");
// swap two integer values
int dwTemp = 0;
// loop the whole array
for (int i = 0; i < array.length; i++) {
// for each loop, if the first value is greater than the second
// value,
// then, swap those two values.
for (int j = 0; j < array.length - 1; j++) {
if (array[j] > array[j + 1]) {
dwTemp = array[j];
array[j] = array[j + 1];
array[j + 1] = dwTemp;
}
}
}
// Printing the result.
for (int i = 0; i < array.length; i++) {
if (i < array.length - 1) {
System.out.print(array[i] + ", ");
} else {
System.out.print(array[i]);
}
}
System.out.println();
}

/*
* Quick Sort: it is suitable for sorting big data volume. The
* divide-conquer strategy is used in quicksort.
* Three steps: 1. Choose a pivot value: we take the value of the middle
* element as pivot value, which is in range of sorted values,
* even if it doesn't present in the array.
* 2. Partition: left to left, right to right.
* 3. Sort both parts:
* recursively. Time complexity is: the least one is O(N^2), and the average
* is O(nlgn) Two guards, right guard moves first, only if it detects the
* smaller one and stop. Then, left guard starts to move. If it detects
* greater one, then stop. Swap two values. recursively, detect all the
* values. Why does it work? On the partition step, algorithm divides the
* array into two parts and every element a from the left part is less or equal
* than every b from the right part.
* After completion of the recursion calls, both of the parts become sorted.
*
* Complexity analysis:
* Average complexity is O(nlgn), but the worst case is O(n^2).
*/
// partition step
public static int partition(int[] array, int low, int high){
int dwLeftGuard = low;
int dwRightGuard = high;
int dwTemp = 0;
int dwKey = array[(low + high) / 2];
while(dwLeftGuard <= dwRightGuard){
while(array[dwLeftGuard] < dwKey)
dwLeftGuard ++;
while(array[dwRightGuard] > dwKey)
dwRightGuard --;
if (dwLeftGuard <= dwRightGuard) {
dwTemp = array[dwLeftGuard];
array[dwLeftGuard] = array[dwRightGuard];
array[dwRightGuard] = dwTemp;
dwLeftGuard ++;
dwRightGuard --;
}
}
return dwLeftGuard;
}
public static void quickSort(int[] array, int low, int high) {
int index = CheckExistDemo.partition(array, low, high);
if (low < index - 1) {
quickSort(array, low, index - 1);
}
if (index < high) {
quickSort(array, index, high);
}
}
/*
* Selection sort:
* Find the smallest element using a linear scan;
* Then, find the second smallest element, and move it to the front.
* Again, doing linear scan.
* Time complexity is O(n^2)
*
*/
public static void selectionSort(int[] array){
int dwTemp = 0;
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
dwTemp = array[j];
array[j] = array[i];
array[i] = dwTemp;
}
}
}
// print the result
System.out.print("The selection sort result is: ");
for (int i = 0; i < array.length; i++) {
if (i < array.length - 1) {
System.out.print(array[i] + ", ");
} else {
System.out.print(array[i]);
}
}
}
}