常用排序算法

常用排序算法有：冒泡排序、直接插入排序、选择排序、快速排序、归并排序和堆排序。下面给出部分算法的源码：
冒泡排序

/** * 冒泡排序 * 时间复杂度  最坏O(n^2) 最好O(n) 平均o(n^2) 稳定  * @param array * @return */public static int[] bubbleSort(int[] array) {    int len = array.length;    int tmp;    int flag = 0;    for(int i = 0 ; i < len ; i++) {        flag = 0;        for (int j = 0 ; j < len - i - 1 ; j++) {            if (array[j] > array[j+1]){                flag       = 1;                tmp        = array[j];                array[j]   = array[j+1];                array[j+1] = tmp;            }        }        if (flag == 0)            break;    }    return array;}

选择排序

/** * 选择排序 * 时间复杂度  最坏O(n^2) 最好O(n^2) 平均o(n^2) 不稳定 * @param array * @return */public static int[] selectSort(int[] array) {    int len = array.length;    int pos;    int max;            for (int i = 0 ; i < len ; i++) {        max = array[0];        pos = 0;        for (int j = 1 ; j < len - i ; j++) {            if (array[j] > max) {                max = array[j];                pos = j;            }        }        array[pos] = array[len-i-1];        array[len-i-1] = max;    }    return array;}

直接插入排序

/** * 插入排序 * 时间复杂度 最好O(n) 最坏O(n^2) 平均O(n^2) 稳定 * @param array * @return */public static int[] insertionSort(int[] list) {    int p = 0, j = 0, tmp = 0;    for ( p = 1 ; p < list.length ; p++) {        tmp = list[p];        for ( j = p ; j > 0 && list[j-1] > tmp ; j--) {            list[j] = list[j-1];        }        list[j] = tmp;    }    return list;}

快速排序

/** * 快速排序 * 时间复杂度  最好O(nlogn) 最坏O(n2) 平均O(nlogn) 不稳定 * @param array * @param start * @param end */public static void quickSort(int[] array, int start, int end){              if (start < end) {        int low = start, high = end;        int key = array[start];        while(low < high) {            while(low < high && array[high] >= key) high--;            if(low < high) {                array[low++] = array[high];            }            while(low < high && array[low] <= key) low++;            if(low < high) {                array[high--] = array[low];            }        }        array[low] = key;        quickSort(array, start, low-1);        quickSort(array, low+1, end);    }}

快速排序的分割函数

/** * 快速排序的分割函数   * 时间复杂度O(n) * 适用于：求数组中第k个最小值  分割函数+二分  确定k-1位置处的值 *         求数组的k个最小值，确定k-1位置处的值，其左侧的k-1个数都是小于k-1位置的 * @param array * @param start * @param end * @return */public static int partition(int[] array, int start, int end) {    if(start < end) {        int low = start, high = end;        int key = array[start];        while(low < high) {            while(low < high && array[high] >= key) high--;            if(low < high) {                array[low++] = array[high];            }            while(low < high && array[low] <= key) low++;            if(low < high) {                array[high--] = array[low];            }        }        array[low] = key;        return low;    }    return -1;}

归并排序

/** * 归并排序 * 时间复杂度 最好O(nlogn) 最坏O(nlogn) 平均O(nlogn) 稳定   * 空间复杂度O(n)  * @param array * @param start * @param end * @param tmpArray 所有公用tmpArray，避免每个合并时 需要new一个数组 */public static void mergeSort(int[] array, int start, int end, int[] tmpArray) {    if (start < end) {        int middle = ( start + end ) / 2;        mergeSort(array, start, middle, tmpArray);        mergeSort(array, middle+1, end, tmpArray);        //int[] tmpArray = new int[array.length];//新建临时存储数组        int left = start, right = middle+1;        int pos  = left;        while(left <= middle && right <= end) {            if (array[left] <= array[right]){                tmpArray[pos++] = array[left++];            } else {                tmpArray[pos++] = array[right++];            }        }        while(left <= middle)            tmpArray[pos++] = array[left++];        while(right <= end)            tmpArray[pos++] = array[right++];        for(int i = start; i <= end; i++)            array[i] = tmpArray[i];    }}

堆排序相关

/** * 插入堆 * @param array * @param value 即将插入的元素 * @param n  堆中元素总数 */public static void insertHeap(int[] array, int value, int n) {    if (n == 0) { //为空时        array[n] = value;    } else {                int pos = n;        array[pos] = value;//新结点的值        int j = (pos - 1) / 2;//父节点位置        while(j >= 0 && pos != 0) {            if (array[j] <= value) {                break;            }            array[pos] = array[j];            pos = j;            j = (pos - 1)/2;                        }        array[pos] = value;    }}/** * 删除堆顶元素 重新调整最小堆 * 由于是数组，直接覆盖元素即可 * @param array * @param n  堆中元素总数 */public static void deleteHeap(int[] array, int n) {    if (n <= 0)        return ;    array[0] = array[--n];//用最后结点 代替 根节点    int key = array[0];    int pos = 0;    int subNode = 2*pos + 1;    while(subNode < n) {        int minSubNode = 0;        if(subNode + 1 < n) {            if (array[subNode] > array[subNode+1]) {                minSubNode = array[subNode+1];                subNode    = subNode+1;            } else {                minSubNode = array[subNode];                                            }        } else {            minSubNode = array[subNode];        }        if(minSubNode >= key)            break;        array[pos] = minSubNode;        pos = subNode;        subNode = 2*pos + 1;                }    array[pos] = key;}

如有问题，欢迎指正。