java排序算法汇总

这段时间正在找工作，研究了一下算法。我是做web开发的，但是比较喜欢算法的，所以就总结了一下，觉得仍有很多不足，请大家多多指教。如果有合适的工作也挺推荐推荐的。我做开发已经三年了。我的邮箱：zlljsf@gmail.com 

排序算法超类：

/** * 排序算法超类 * 所有排序序列中元素必须实现java.lang.Comparable接口 * @author Liangliang Zhang * * @param <E> */ public abstract class Sort<E extends Comparable<E>> { /** * 排序类中均要实现的排序方法 * @param array 排序序列 * @param from 排序序列开始位置 * @param len 排序序列长度 */ public abstract void sort(E[] array, int from, int len); public final void sort(E[] array){ sort(array, 0, array.length); } /** * 经典调换 * @param array * @param from * @param to */ protected final void swap(E[] array, int from, int to){ E temp = array[from]; array[from] = array[to]; array[to] = temp; } }

折半插入排序：

/** * 算法名称：折半插入排序(Binary Insert Sort) * 折半插入排序的核心思想是：1、找出插入位置在低半区还是高半区，以顺序为例，假如 * 序列有8个元素，则是找出插入位置是前四个还是后四个而非全部 * 2、找到插入位置后，顺序移动，前提前面元素是有序的 * @author Liangliang Zhang * */ public class BinaryInsertSort<E extends Comparable<E>> extends Sort<E>{ @Override public void sort(E[] array, int from, int len) { for(int i = from + 1; i < len; i++){ E temp = array[i]; int low = from + 1; int high = i - from + 1; while(low <= high){ int mid = (high + low)/2; if(temp.compareTo(array[mid]) < 0){ high = mid -1; }else{ low = mid + 1; } } int j = i - 1; //这样移动保持序列一直是有序的 for(; j >= high && temp.compareTo(array[j]) == -1; j--){ array[j + 1] = array[j]; } array[j + 1] = temp;//抵充j-- } } }

希尔排序：

import java.util.ArrayList; import java.util.List; /** * 算法名称：希尔排序(Shell's Sort) * 希尔排序思想的核心是构造一个动态递减的间隔，让序列在间隔中进行插入排序，然后当 * 间隔递减为1时，序列已经基本有序，此时再进行的希尔排序其实就是插入排序。 * Shell排序其实就是改进了的插入排序，这样减少了序列中每个元素的移动次数。 * @author Liangliang Zhang * * @param <E> */ public class ShellSort<E extends Comparable<E>> extends Sort<E> { @Override public void sort(E[] array, int from, int len) { Integer[] deltaArray = buildDeltaArray(len); shellSort(array, deltaArray, deltaArray.length); } /** * 对间隔为dk的序列进行插入排序 */ private void shellInsert(E[] array, int dk){ for(int i = dk; i < array.length; i++){ //array[i]比array[i-dk]小时，将array[i-dk]移动到合适的位置 if(array[i].compareTo(array[i - dk]) == -1){ E temp = array[i]; int j = i - dk; //这里是选择合适的位置 for(; j >= 0 && temp.compareTo(array[j]) == -1; j -= dk){ array[j + dk] = array[j]; } //其实仍为j，只是循环时最后一次循环后j=j-dk，则j+dk-dk即为j //不能简单理解为互相调换位置 array[j + dk] = temp; } } } /** * 对应每个delta进行插入排序，注意这一块k一定是递减的，要么delta始终从1开始，相当于 * 第一次已经排好序了，即完全用插入排序与Shell排序无关 * @param array 排序序列 * @param delta delta序列 * @param t delta序列长度 */ private void shellSort(E[] array, Integer delta[], int t){ for(int k = t - 1; k >= 0; k--){ shellInsert(array, delta[k]); } } /** * 构造增量序列delta * @param len 排序序列长度 * @return 增量序列 */ private Integer[] buildDeltaArray(int len){ int value = 0; //delta = 2∧(t - k + 1) - 1 List<Integer> deltaList = new ArrayList<Integer>(); while((value + 1)*2 < len){ value = (value + 1) * 2 - 1; deltaList.add(value); } Integer[] deltaArray = new Integer[deltaList.size()]; deltaArray = deltaList.toArray(deltaArray); return deltaArray; } }

冒泡排序：

/** * 算法名称：冒泡排序(Bubble sort) * 冒泡排序的核心思想是枪打出头鸟(顺序时为最小的鸟)，最小的鸟先被干掉， * 然后再找序列中次小的鸟干掉，依次往后推，整个序列便有序了 * * @author Liangliang Zhang * * @param <E> */ public class BubbleSort<E extends Comparable<E>> extends Sort<E> { @Override public void sort(E[] array, int from, int len) { for(int i = from; i < len; i++){ for(int j = from + 1; j < len; j++){ if(array[j].compareTo(array[j - 1]) < 0){ super.swap(array, j - 1, j); } } } } }

快速排序：

/** * 算法名称：快速排序(Quick Sort) * 快速排序的核心思想是在要排序列中找到一个枢轴，将序列分成两个子序列，一个子序列 * 记录均比枢轴小，一个子序列记录均被枢轴大，再对子序列施以同样的思想进行递归便可 * @author Liangliang Zhang * * @param <E> */ public class QuickSort<E extends Comparable<E>> extends Sort<E> { @Override public void sort(E[] array, int from, int len) { int low = from; int high = len - 1; quickSort(array, low, high); } /** * 递归序列进行快速排序 * @param array * @param low * @param high */ private void quickSort(E[] array, int low, int high) { if (high - low < 1) return; //此地return很神奇，我至今未弄懂其道理，但是可以防止程序 //进入死循环 int pivot = partition(array, low, high); quickSort(array, low, pivot - 1); quickSort(array, pivot + 1, high); } /** * 以array[low]为枢轴对每个array子序列进行分割，使其实现快速排序思想， * 并返回所选枢轴调整后所对应的下标，为下次递归准备 * @param array array子序列 * @param low 子序列开始下标 * @param high 子序列末尾值下标 * @return 返回所选枢轴调整后所对应的下标 */ private int partition(E[] array, int low, int high) { //此算法中很微妙的一点有点占位的感觉，而且每个数只能占一个位， //比如先前A占a位置，过了几天他觉得枢轴的位置好，就到枢轴位置上去，此时 //便会紧跟着有个叫B的占上a位置，如此以往，大家调整以后，最后一个被调整 //的人不坐的位置只能让经常被换的枢轴坐上去，感觉这个算法微妙就在这一块 E pivotKey = array[low]; while (low < high) { while (low < high && array[high].compareTo(pivotKey) >= 0) { high--; } //比枢轴小的往前移 array[low] = array[high]; while (low < high && array[low].compareTo(pivotKey) <= 0) { low++; } //比枢轴大的往后移 array[high] = array[low]; } array[low] = pivotKey; return low; } }

堆排序：

/** * 算法名称：堆排序(Heap Sort) * 要明白堆排序，首先要明白堆的定义，比如对于array[0...2n]， * 有array[i]<=array[2i] 并且 array[i]<=array[2i+1] 或者有 * array[i]>=array[2i] 并且 array[i]>=array[2i+1]，称此数组构成一个堆。 * 堆排序的核心思想就是：1、将无序序列构造成一个堆 * 2、去掉堆顶元素后，调整剩余元素为一个新堆 * @author Liangliang Zhang * * @param <E> 要排序的序列 */ public class HeapSort<E extends Comparable<E>> extends Sort<E> { @Override public void sort(E[] array, int from, int len) { int i = len / 2; //使整个array为大顶堆 for(; i >= from; i--){ this.heapAdjust(array, i, len - 1); } for(i = len - 1; i > from; i--){ //将大顶堆array[0...i]的最大值与array[0]互换，使最大值再最后一位 super.swap(array, from, i); //保证互换后，array[0...i-1]仍为大顶堆 this.heapAdjust(array, from, i - 1); } } /** * 已知array[s]到array[t]之间，除array[s]外均满足堆的定义，本函数调整array[s]， * 使整个array变成大顶堆 * @param array 要调整的数组 * @param s 要调整的数组开始位置 * @param m 要调整的数组的结束位置 */ private void heapAdjust(E[] array, int s, int m){ E rc = array[s]; for(int j = 2 * s; j <= m; j *= 2){//沿值较大的孩子节点向下筛选 //j为值较大的记录的下标，这样才能保证array[s]>=array[2*s] && array[s] >= array[2*s+1] //这正是大顶堆的定义 if(j < m && array[j].compareTo(array[j + 1]) == -1){ j++; } //此时已经满足堆的定义，无需再调整 if(rc.compareTo(array[j]) >= 0){ break; }else{//rc应插入到位置s上 array[s] = array[j]; s = j; } } array[s] = rc; } }

可参看：http://www.blogjava.net/javacap/archive/2007/12/14/167618.html