主要排序算法的Java实现

package com.chrischeng.hacker;

import java.util.*;

/**
* Created by Yexin on 2016/11/4.
*/

//Complete the code
public class Solution
{
private final static int ARRAYSIZE = 50;
private final static int ARRAYRANGE = ARRAYSIZE * 2;

// 通过随机数发生器生成一个指定大小的随机数组
public static int[] createArray(int size){
int []retArray = new int [size];
Random random = new Random();
for(int i = 0;i < size;i++)
retArray[i] = random.nextInt(ARRAYRANGE);
return retArray;
}

// 打印指定数组
public static void printArray(int []arr){
for(int a : arr)
System.out.print(a + " ");
System.out.println();
}

// 交换数组中指定序号的元素值
public static void swap(int[] arr, int i, int j ){
if(i >= arr.length || j >= arr.length)
return;
else{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

// 使用带有标志位的冒泡排序
public static void bubbleSort(int []arr){
int len = arr.length;
boolean flag = false;
for(int i = 0; i < len - 1; i++){
for(int j = i + 1; j < len;j++){
if(arr[i] > arr[j]) {
swap(arr, i, j);
flag = true;
}
}
if(flag == false)
break;
}
}

// 直接插入排序
public static void insertionSort(int []arr){
int len = arr.length, i = 1, j;
for(; i < len; i++){
int temp = arr[i];
if(arr[i - 1] > arr[i]){
j = i - 1;
while(j >= 0 && arr[j] > temp) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = temp;
}
}
}

// Shell排序（本质上就是分治法的直接插入排序）
public static void shellSort(int []arr){
int len = arr.length, gap, i, j;
for(gap = len/2; gap > 0; gap /= 2){
for(i = gap;i < len; i++){
if(arr[i] < arr[i -gap]){
int temp = arr[i];
j = i - gap;
while(j >= 0 && arr[j] > temp){
arr[j+gap] = arr[j];
j -= gap;
}
arr[j+gap] = temp;
}
}
}
}

// 快速排序
public static void quickSort(int []arr, int l, int r){
if(l < r) {
int i = l, j = r, base = arr[r];
while (i < j) {
// 由左至右遍历，找到第一个大于中轴的元素
while (i < j && arr[i] < base)
i++;
// 如果i和j没有交叉且找到了第一个大于中轴的元素（index为i），则将它的值存放在j的位置，而j位置的值存放在base中
if (i < j)
arr[j--] = arr[i];
// 从右到左遍历，找到第一个小于中轴的元素
while (i < j && arr[j] > base)
j--;
// 如果i和j没有交叉且找到了第一个小于中轴的元素，则将他的值存放在上一步中index-i的位置上
if (i < j)
arr[i++] = arr[j];
}
// 上面的遍历完成后，i左侧都是小于base的元素，右侧都是大于base的元素，base作为中值存放在index=i的位置上，并不参与下次排序
arr[i] = base;
// 分别对数组左右侧进行递归排序
quickSort(arr,l,i-1);
quickSort(arr,i+1,r);
}
}

// 桶排序
// 本质上其实就是彻底的牺牲空间换取时间的做法
// 适用于数字范围在一定区间内的随机数组
public static void bucketSort(int arr[]){
// 此处之所以使用对象数组，是因为实际情况中存在多个同值元素存在的可能性
ArrayList<Integer> buckets[] = new ArrayList[ARRAYRANGE + 1];
for(int i : arr) {
if (buckets[i] == null)
buckets[i] = new ArrayList<Integer>();
buckets[i].add(new Integer(i));
}
int index = 0;
for(ArrayList<Integer> al : buckets){
if(null != al && al.size() > 0){
for(Integer i : al)
arr[index++] = i;
}
}
}

// 基数排序
// 本质上就是按照从低位到高位的桶排序，所以无论随机数组的长度为多大，永远只需要十个桶
public static void radixSort(int arr[]){
}

public static void main(String[] args){
int [] arr = createArray(ARRAYSIZE);
printArray(arr);
bucketSort(arr);
printArray(arr);
}
}