分享冒泡排序、选择排序、插入排序、希尔排序、快速排序算法代码实现，如有错误请指正。由于描写排序算法的文章比较多，而且都写的不错，这里不再阐述理论部分，这里只分享自己的代码实现，觉得有两篇博客理论写的不错，推荐给大家。
博客地址：http://www.cnblogs.com/ysocean/p/8032632.html
http://www.cnblogs.com/ysocean/p/7896269.html
冒泡排序：
/**
* 冒泡排序（从小到大） ：相邻两个数比较,交换位置，每一轮找到最大的放到最后
*/
public static void bubleSort(int[] array) {
for (int j = 1; j < array.length; j++) {
System.out.println("第【" + j + "】轮排序前：" + Arrays.toString(array));
for (int i = 0; i < array.length - j; i++) {
if (array[i] > array[i + 1]) {
int temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
System.out.println("第【" + j + "】轮排序后：" + Arrays.toString(array));
}
System.out.println("排序完成后：" + Arrays.toString(array));
}
选择排序：
/**
* 选择排序（从小到大）：每一次从待排数组中找到最小的，把最小的排在待排数组的排在起始位置
*
* @param array
*/
public static void selectionSort(int[] array) {
System.out.println("排序前：" + Arrays.toString(array));
for (int i = 1; i < array.length; i++) {
for (int j = i; j < array.length; j++) {
if (array[i - 1] > array[j]) {
int temp = array[i - 1];
array[i - 1] = array[j];
array[j] = temp;
}
}
System.out.println("第【" + i + "】轮排序后：" + Arrays.toString(array));
}
}
插入排序：
/**
* 直接插入排序（从小到大）：每一次将待排序的对象插入到已排好的序列中
*
* @param array
*/
public static void insertionSort(int[] array) {
for (int i = 1; i < array.length; i++) {
// 找到插入的位置
int pos = i;
for (int j = 0; j < i; j++) {
if (array[j] > array[i]) {
pos = j;
break;
}
}
int v = array[i];
if (pos != i) {
for (int p = i; p > pos; p--) {
array[p] = array[p - 1];
}
array[pos] = v;
}
System.out.println("插入位置【" + pos + "】第【" + i + "】轮排序后：" + Arrays.toString(array));
}
} 希尔排序（高级排序）：
/**
* 希尔排序（直接插入排序演化）
*
* @param array
*/
public static void shellSort(int[] array) {
int h = 1;
while (h < array.length / 3) {
h = h * 3 + 1;
}
while (h > 0) {
// 根据间隔h值大小决定每个h值需要做几次步长为h的插入排序
for (int i = 0; i < h; i++) {
System.out.println("间隔h值【" + h + "】第【" + i + "】轮排序前：" + Arrays.toString(array));
for (int j = i + h; j < array.length; j += h) {
// 插入排序，找到插入的位置，默认位置在当前位置
int pos = j;
// 找到插入的位置
for (int q = i; q < j; q += h) {
if (array[q] > array[j]) {
pos = q;
break;
}
}
int temp = array[j];
// 如果不在默认位置，则需要根据步长移动位置
if (pos != j) {
for (int q = j; q > pos; q -= h) {
array[q] = array[q - h];
}
array[pos] = temp;
}
}
System.out.println("间隔h值【" + h + "】第【" + i + "】轮排序后：" + Arrays.toString(array));
System.out.println();
}
h = (h - 1) / 3;
}
}
快速排序（高级排序）：
/**
* 快速排序
*
* @param array
*/
public static void quickSort(int[] array) {
// 左游标从左边第一个开始
int leftP = 0;
// 右游标从右边第一个开始
int rightP = array.length - 1;
quickSortRecursion(array, leftP, rightP);
}
/**
* 快速排序（冒泡排序演化）
*
* @param array
* @param leftP
* @param rightP
*/
private static void quickSortRecursion(int[] array, int leftP, int rightP) {
//记住起始位置
int startLeftP = leftP;
int startRightP = rightP;
// 基准元素一般选择第一个
int pivotValue = array[startLeftP];
// 右游标向左扫描， 跨过所有大于基准元素的数组元素, 直到遇到一个小于或等于基准元素的数组元素，在那个位置停下
// 右游标先移动，因为基准元素选取的在左边
while (rightP > leftP) {
if (array[rightP] <= pivotValue) {
break;
}
rightP--;
}
// 左游标向右扫描， 跨过所有小于基准元素的数组元素, 直到遇到一个大于或等于基准元素的数组元素， 在那个位置停下
while (leftP < rightP) {
if (array[leftP] >= pivotValue) {
break;
}
leftP++;
}
// 如果左游标不等于右游标值互换，互换之后继续递归，直到左游标等于右游标
if (leftP != rightP) {
int temp = array[leftP];
array[leftP] = array[rightP];
array[rightP] = temp;
// 交换位置之后继续递归
quickSortRecursion(array, leftP, rightP);
}
// 如果左游标等于右游标而且不等于开始游标,游标里的元素与基准元素交换位置
if (leftP == rightP && leftP != startLeftP) {
int temp = pivotValue;
// startLeftP 即基准元素位置的值
array[startLeftP] = array[rightP];
array[rightP] = temp;
}
// 走到里左右游标会相等,以基准元素进行左右分割
// 当结束一次探测之后，如果游标大于左游标起始位置，则左侧还需要继续分割
if (leftP > startLeftP) {
quickSortRecursion(array, startLeftP, rightP - 1);
}
// 当结束一次探测之后，如果游标小于右游标起始位置，则右侧还需要继续分割
if (rightP < startRightP) {
quickSortRecursion(array, leftP + 1, startRightP);
}
}