七种排序算法---Java实现

排序是程序设计中经常遇到的问题，因此是算法中的重要内容。

常见的排序算法包括：冒泡排序，简单选择排序，直接插入排序，希尔排序，堆排序，归并排序，快速排序等。

排序算法各有各的优缺点，下表总结了各种排序的性质，主要包括时间复杂度、空间复杂度和稳定性。

具体的Java实现代码如下：

1. 冒泡排序

package com.wl.test;/** * 冒泡排序提供了三种方式 * 第一种不能算是真正的冒泡排序，因为他并不是连续的两个值进行比较 * 第三种对第二种进行了优化，考虑到当序列本来就基本有序时，就不需要那么多次的循环了 * @author WangLiang *@version v1.0 */public class BubbleSort {public static void sort(int[] array, int type) {if(type == 1) {for(int i=0; i<array.length; i++) {for(int j=i; j<array.length; j++) {if(array[i] > array[j]) {swap(array, i, j);}}}} else if(type == 2) {for(int i=0; i<array.length; i++) {for(int j=array.length-1; j>i; j--) {if(array[j] < array[j-1])swap(array, j, j-1);}}} else if(type == 3) {boolean flag = true;for(int i=0; flag && i<array.length; i++) {flag = false;for(int j=array.length-1; j>i; j--) {if(array[j] < array[j-1])swap(array, j, j-1);flag = true;}}}}private static void swap(int[]array, int i, int j) {int x = array[i];array[i] = array[j];array[j] = x;}}

2. 简单选择排序

package com.wl.test;/** * 选择排序实现过程如下： * 首先遍历第i（i从第一个值循环到最后一个值）个节点后的所有值，找出最小（大）的值，与第i个值交换位置， * 循环完成后，排序就已经完成了 * @author Administrator *@version v1.0 */public class SelectSort {public static void sort(int[] array) {int min;for(int i=0; i<array.length-1; i++) {min = i;for(int j=i+1; j<array.length; j++) {if(array[j] < array[min]) {min = j;}}if(min != i) {swap(array, i, min);}}}private static void swap(int[]array, int i, int j) {int x = array[i];array[i] = array[j];array[j] = x;}}

3. 直接插入排序

package com.wl.test;/** * 插入排序实现过程如下： * 从第i（i从第2个值到最后一个值）个节点值开始，每个值都在前面已经排好序的队列中找到自己的位置并插入 * 整个过程就像我们玩扑克牌时接牌（起和插）一样 * @author Administrator *@version v1.0 */public class InsertSort {public static void sort(int[] array) {int i, j, sentry;for(i=1; i<array.length; i++) {if(array[i] < array[i-1]) {sentry = array[i];for(j=i-1; j>=0&&sentry < array[j]; j--) {array[j+1] = array[j];}array[j+1] = sentry;}}}}

4. 希尔排序

package com.wl.test;/** * 希尔排序实现过程如下： * 将整个待排序序列分组，分别进行插入排序 * @author Administrator *@version v1.0 */public class ShellSort {public static void sort(int[] array) {int i, j, sentry;int increment = array.length;do {increment = increment/2;for(i=increment; i<array.length; i++) {if(array[i] < array[i-increment]) {sentry = array[i];for(j=i-increment; j>=0&&sentry<array[j]; j-=increment) {array[j+increment] = array[j];}array[j+increment] = sentry;}}} while (increment > 1);}public static void shellSort(int[] arr) {int j;int len = arr.length;for(int val=len>>1; val>0; val>>=1) {for(int i=val; i<len; i++) {int temp = arr[i];for(j=i; j>=val&&temp<arr[j-val]; j-=val) {arr[j] = arr[j-val];}arr[j] = temp;}}}}

5. 堆排序

package com.wl.test;/** * 程序利用大根堆的性质，每次都可以找到最大的那个值 * 程序运行过程中需要维护堆的性质 * @author Administrator *@version v1.0 */public class HeapSort {public static void sort(int[] array) {for(int i=array.length/2-1; i>=0; i--) {heapAdjust(array, i, array.length-1);}for(int i=array.length-1; i>0; i--) {swap(array, 0, i);heapAdjust(array, 0, i-1);}}private static void heapAdjust(int[] array, int s, int m) {int temp = array[s];for(int j=2*s+1; j<=m; j=2*j+1) {if(j<m && array[j] < array[j+1]) { // array[j]为左孩子，array[j+1]为右孩子j++;}if(temp > array[j]) { // 如果array[s]比左右孩子都大，则退出break;}array[s] = array[j]; // 否则，将最大的那个孩子提升为父节点，循环继续s = j;}array[s] = temp;}private static void swap(int[]array, int i, int j) {int x = array[i];array[i] = array[j];array[j] = x;}}

6. 归并排序

package com.wl.test;/** * 排序使用归并的思想，将排序数组分成若干个只包含1个值的n个部分，然后对他们进行归并排序 * 排序发生在归并的过程中 * @author Administrator *@version v1.0 */public class MergeSort {public static void sort(int[] array) {mSort(array, 0, array.length-1);}private static void mSort(int[] array, int s, int t) {int m;if(s != t) {m = (s + t) / 2;mSort(array, s, m);mSort(array, m+1, t);merge(array, s, m, t);}}private static void merge(int[] array, int s, int m, int t) {int i, j, k;int[] temp = new int[t-s+1];for(i = s, j = m+1, k=0; i<=m&&j<=t; k++) {if(array[i] < array[j]) {temp[k] = array[i++];} else {temp[k] = array[j++];}}if(i<=m) {for(; i<=m; i++, k++) {temp[k] = array[i];}}if(j<=t) {for(; j<=t; j++, k++) {temp[k] = array[j];}}for(k=s; k<=t; k++) {array[k] = temp[k-s];}}}

7. 快速排序

package com.wl.test;public class QuickSort {public static void sort(int[] array) {qSort(array, 0, array.length-1);}private static void qSort(int[] array, int low, int high) {if(low<high) {int pivot = partition(array, low, high);qSort(array, low, pivot-1);qSort(array, pivot+1, high);}}private static int partition(int[] array, int low, int high) {int pivotkey = array[low];while(low < high) {while(low<high && array[high] >= pivotkey)high--;swap(array, low, high);while(low<high && array[low] <= pivotkey)low++;swap(array, low, high);}return low;}private static void swap(int[]array, int i, int j) {int x = array[i];array[i] = array[j];array[j] = x;}}