常用排序算法

1、选择排序(时间复杂度为O(n²))

选择排序的思想是在线性表中找到最小数，并将其放在表头，然后在剩下的数中找到最小数，放在第一个数之后，直到线性表中仅剩下一个数为止。

Java实现：

　　public static void choiceSort(Integer[] a) {
		if (a == null || a.length <= 0) {
			return;
		}
		for (int i = 0; i < a.length; i++) {
			int min = i; /* 将当前下标定义为最小值下标 */
			for (int j = i + 1; j < a.length; j++) {
				if (a[min] > a[j]) { /* 如果有小于当前最小值的关键字 */
					min = j; /* 将此关键字的下标赋值给min */
				}
			}
			if (i != min) {/* 若min不等于i，说明找到最小值，交换 */
				int tmp = a[min];
				a[min] = a[i];
				a[i] = tmp;
			}
		}
	}

　　

2、插入排序(时间复杂度为O(n²))

插入排序的思想是在已经排好的子数组中反复插入一个新的元素，直到整个数组全部排好序。

Java实现:

　　public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			if (arr[i - 1] > arr[i]) {
				int temp = arr[i];// 待插入的元素
				int j = i;
				while (j > 0 && arr[j - 1] > temp) {// 将大于temp的往后移一位
					arr[j] = arr[j - 1];
					j--;
				}
				arr[j] = temp;
			}
		}
	}

　　

3、冒泡排序(时间复杂度O(n²))

冒泡排序的思想是在每次遍历中，比较连续相邻的元素，如果某一对元素是降序，则互换它们的值；否则保持不变。第一次遍历后，最后一个元素成为数组中的最大数。第二次遍历之后，倒数第二个元素成为数组中的第二大数。整个过程持续到所有元素都已排序好。

注意：如果在某次遍历中没有发生变换，那么就不必进行下一次遍历，因为所有的元素都已经排好序了。

Java实现：

　　public static void bubbleSort(int[] list){
		boolean needNextPass = true;
		
		for(int k = 1; k < list.length && needNextPass; k++){
			needNextPass = false;
			for(int i = 0; i < list.length - k; i++){
				if(list[i] > list[i+1]){
					int temp = list[i];
					list[i] = list[i + 1];
					list[i + 1] = temp;
					needNextPass = true;
				}
			}
		}
	}

　　

4、快速排序(时间复杂度O(nlogn))

快速排序的思想是在数组中选择一个主元的元素，将数组分为两个部分，使得第一部分中的所有元素都小于或者等于主元，而第二部分中的所有元素都大于主元。对第一部分递归地应用快速排序算法，然后对第二部分递归地应用快速排序算法。

Java实现：

/*
 * 调用划分函数，使得子数组顺序重排
 */
void quick_sort(int A[], int p, int r){
    if(p < r){
        int q = partition(A, p, r);
        quick_sort(A, p, q-1);
        quick_sort(A, q+1, r);
    }
}

/*
 * 对于比x值小的元素通过交换放置到小于x值的区域。
 * 最后将大于x值的区域的第一个元素与x值，即原A[r]，交换
 * 该下标即为q，形成两个符合要求的数组（A[p..q-1]的元素都不大于A[q]，A[q+1..r]都不小于A[q]）
 */
int partition(int A[], int p, int r){
    int x = A[r];
    int i = p - 1;
    int j;
    for(j = p; j <= r-1; j++){
        if(A[j] <= x){
            i++;
            int temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
    }
    int temp = A[i+1];
    A[i+1] = A[r];
    A[r] = temp;
    return i+1;
}

　　

　　

　　

5、归并排序(时间复杂度O(nlogn))

归并排序的思想是将数组分为两半，对每部分递归地应用归并排序。在两个部分都拍好序后，对它们进行归并。

Java实现:

　　public static void mergeSort(int[] list) {
		if (list.length > 1) {
			int[] firstHalf = new int[list.length / 2];
			System.arraycopy(list, 0, firstHalf, 0, list.length / 2);
			mergeSort(firstHalf);

			int secondHalfLength = list.length - list.length / 2;
			int[] secondHalf = new int[secondHalfLength];
			System.arraycopy(list, list.length / 2, secondHalf, 0,
					secondHalfLength);
			mergeSort(secondHalf);

			int[] temp = merge(firstHalf, secondHalf);
			System.arraycopy(temp, 0, list, 0, temp.length);
		}
	}

	public static int[] merge(int[] list1, int[] list2) {
		int[] temp = new int[list1.length + list2.length];

		int pos1 = 0;
		int pos2 = 0;
		int pos3 = 0;

		while (pos1 < list1.length && pos2 < list2.length) {
			if (list1[pos1] < list2[pos2])
				temp[pos3++] = list1[pos1++];
			else
				temp[pos3++] = list2[pos2++];
		}

		while (pos1 < list1.length)
			temp[pos3++] = list1[pos1++];

		while (pos2 < list2.length)
			temp[pos3++] = list2[pos2++];

		return temp;
	}

6、堆排序(时间复杂度O(nlogn))　

堆排序是将数据存储在堆中，其中堆是一棵具有如下属性的二叉树：

1.它是一棵完全二叉树

2.每个节点大于或者等于它的任意一个孩子

Java实现：

public class Heap<E extends Comparable> {
	private ArrayList<E> list = new ArrayList<E>();

	public Heap() {
	}

	public Heap(E[] object) {
		for (int i = 0; i < object.length; i++) {
			add(object[i]);
		}
	}

	public void add(E newObject) {
		list.add(newObject);
		int currentIndex = list.size() - 1;

		while (currentIndex > 0) {
			int parentIndex = (currentIndex - 1) / 2;
			if (list.get(currentIndex).compareTo(list.get(parentIndex)) > 0) {
				E temp = list.get(currentIndex);
				list.set(currentIndex, list.get(parentIndex));
				list.set(parentIndex, temp);
			} else {
				break;
			}
			currentIndex = parentIndex;
		}
	}

	public E remove() {
		if (list.size() == 0)
			return null;

		E removedObject = list.get(0);
		list.set(0, list.get(list.size() - 1));
		list.remove(list.size() - 1);

		int currentIndex = 0;
		while (currentIndex < list.size()) {
			int leftChildIndex = 2 * currentIndex + 1;
			int rightChildIndex = 2 * currentIndex + 2;

			if (leftChildIndex >= list.size())
				break;
			int maxIndex = leftChildIndex;
			if (rightChildIndex < list.size()) {
				if (list.get(maxIndex).compareTo(list.get(rightChildIndex)) < 0) {
					maxIndex = rightChildIndex;
				}
			}

			if (list.get(currentIndex).compareTo(list.get(maxIndex)) < 0) {
				E temp = list.get(maxIndex);
				list.set(maxIndex, list.get(currentIndex));
				list.set(currentIndex, temp);
				currentIndex = maxIndex;
			} else
				break;
		}

		return removedObject;
	}

	public int getSize() {
		return list.size();
	}
}

    public static <E extends Comparable> void heapSort(E[] list) {
		Heap<E> heap = new Heap<E>();

		for (int i = 0; i < list.length; i++)
			heap.add(list[i]);
		for (int i = list.length - 1; i >= 0; i--) {
			list[i] = heap.remove();
		}
	}

7、桶排序和基数排序(时间复杂度O(dn), n为元素个数，d是所有键值中基数位置的最大值)

一般排序算法的下限是O(nlogn)。因此，基于比较的的排序算法中没有完成得好过O(nlogn)的算法。但是，如果键值是小整数，那么可以使用桶排序，而无需比较这些键值。

桶排序算法的工作方式如下。假设键值的范围是从0到N-1。我们需要N个标记为0,1,...,N-1的桶。如果元素的键值是i，那么就将该元素放入桶i中。每个桶中都存在和键值具有相同值的元素。可以使用ArrayList来实现一个桶。

桶排序算法对一个线性表中元素的排序，可以描述如下：

    public void bucketSort(E[] list) {
		E[] buckets = (E[]) new java.util.ArrayList[N];

		for (int i = 0; i < list.length; i++) {
			int key = list[i].getKey();

			if (buckets[key] == null)
				buckets[key] = new java.util.ArrayList();
			
				buckets[key].add(list[i]);
		}

		int k = 0;
		for (int i = 0; i < buckets.length; i++) {
			if (buckets[i] != null) {
				for (int j = 0; j < buckets[i].size(); j++) {
					list[k++] = buckets[i].get(j);
				}
			}
		}
	}

基数排序的思想是将这些键值基于它们的基数位置分为小组，然后重复地从最显著的基数开始，对其应用基数排序。