常见排序算法的Java实现

一、常见的排序算法

常见的排序包括：插入类（简单插入、希尔排序）、选择类（选择排序、堆排序）、交换类（冒泡排序、快速排序）等，当然还有其它的比如归并排序、桶排序、计数排序等等。

二、Java实现

package com.xiaoliu;

public class Sort {
/**
* 泡在前，依次将第i个与i之后的所有元素进行比较 ,时间复杂度O(n2)，稳定排序
*
* @param arr
* @param n
*/
public void bubbleSort(int[] arr, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[i]) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
}

/**
* 泡在后，相邻比较 ,时间复杂度O(n2)，稳定排序
*
* @param arr
* @param n
*/
public void bubbleSort2(int[] arr, int n) {
for (int i = 1; i < n; i++) {//控制循环次数
for (int j = 0; j < n - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}

/**
* 选择排序，在冒泡的基础上改进了交换的次数, 时间复杂度O(n2)，稳定排序
*
* @param arr
* @param n
*/
public void selectionSort(int[] arr, int n) {
for (int i = 0; i < n - 1; i++) {
int k = i;
for (int j = i + 1; j < n; j++) {
if (arr[k] > arr[j]) {
k = j;
}
}
if (k != i) {
int tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
}
}
}

/**
* 快速排序，时间复杂度为O(nlogn)，不稳定排序
*
* @param arr
* @param left
* @param right
*/
public void quickSort(int[] arr, int left, int right) {
if (left >= right) {
return;
}
int low = left;
int high = right;
int key = arr[low];
while (low < high) {
while (low < high && arr[high] >= key)
high--;
arr[low] = arr[high];
while (low < high && arr[low] <= key)
low++;
arr[high] = arr[low];
}
arr[low] = key;
quickSort(arr, left, low - 1);
quickSort(arr, low + 1, right);
}

/**
* 简单插入排序，时间复杂度O(n2)，稳定排序
*
* @param arr
* @param n
*/
public void insertSort(int[] arr, int n) {
int i, j, tmp;
for (i = 1; i < n; i++) {
j = i - 1;
tmp = arr[i];
while (j >= 0 && tmp < arr[j]) {
arr[j + 1] = arr[j];
j--;
}
if (j + 1 != i) {
arr[j + 1] = tmp;
}
}
}
/**
* 希尔排序，又叫缩小增量排序，本质上是一种优化插入排序，时间复杂度好于O(n2)，不稳定排序
* @param arr
* @param n
*/
public void shellSort(int[] arr, int n) {
int step = n / 2;
while (step >= 1) {
int i, j, tmp;
for (i = step; i < n; i += step) {
tmp = arr[i];
j = i - step;
while (j >= 0 && tmp < arr[j]) {
arr[j + step] = arr[j];
j -= step;
}
if (j + step != i) {
arr[j + step] = tmp;
}
}
step /= 2;
}
}
/**
* 堆排序，先建堆，再排序，充分利用完全二叉树与数组的特点，时间复杂度O(nlgn)，不稳定排序
* @param arr
* @param n
*/
public void heapSort(int[] arr, int n) {
if (arr==null || arr.length<=1) {
return ;
}
buildMaxHeap(arr, n);
for(int i=n-1;i>=1;i--){
//因为只有根节点一定整个堆的是最大值，所以每次交换都是与根节点
int tmp = arr[0];
arr[0] = arr[i];
arr[i] = tmp;
//注意堆的大小变化，交换完成后，数组的最后边的元素已经有序
maxHeap(arr, i, 0);
}
}
/**
* 建立堆的过程，选择起始位置为数组长度的一半，是因为叶子节点不需要考虑
* @param arr
* @param n
*/
private void buildMaxHeap(int[] arr, int n) {
int half = n / 2;
for(int i=half;i>=0;i--){
maxHeap(arr, n, i);
}
}
/**
* 堆调整的过程，如果发生节点的交换，必须递归处理可能产生问题的节点。
* @param arr
* @param heapSize
* @param index
*/
private void maxHeap(int[] arr, int heapSize, int index) {
int lc = index * 2 + 1;
int rc = index * 2 + 2;
int max = index;
if (index> heapSize/2 || lc >= heapSize || rc >= heapSize) {
return ;
}
if (lc<heapSize && arr[lc]>arr[index]) {
max = lc;
}
//注意与上边if条件的差别
if (rc<heapSize && arr[rc]>arr[max]) {
max = rc;
}
if (max != index) {
int tmp = arr[index];
arr[index] = arr[max];
arr[max] = tmp;
maxHeap(arr, heapSize, max);
}
}

public static void main(String[] args) {
int[] arr = { 1, 3, 5, 8, 2, 5, 9, 4, 0 };
Sort instance = new Sort();
// instance.bubbleSort2(arr, arr.length);
// instance.selectionSort(arr, arr.length);
// instance.quickSort(arr, 0, arr.length - 1);
//instance.insertSort(arr, arr.length);
//instance.shellSort(arr, arr.length);
instance.heapSort(arr, arr.length);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}