Sort Algorithm 之 交换排序

交换排序

冒泡排序

基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

        

冒泡代码：

public void sort() {
		for (int i = 0; i < num.length; i++) {
			for (int j = i; j < num.length; j++) {
				if (num[i] > num[j]) {
					temp = num[i];
					num[i] = num[j];
					num[j] = temp;
				}
			}
		}
}

快速排序

基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

算法复杂度：

   在最优的情况下，快速排序算法的时间复杂度为O(nlogn)，在最坏的情况下，待排序的序列为正序或者逆序，其时间复杂度为O(n2)。 

   就空间复杂度来说，主要是递归造成的栈空间的使用，最好情况，递归树的深度为log2n，其空间复杂度也就为O(logn)，最坏情况，需要进行n-1递归调用，其空间复杂度为O(n)，平均情况，空间复杂度也为O(logn)。

   快速排序是一种不稳定的排序方法。

源代码：

static void quicksort(int[] list, int head, int tail) {
		if (head < tail) {
			int k = sort(list, head, tail);
			quicksort(list, head, k - 1);
			quicksort(list, k + 1, tail);
		}
	}

static int sort(int[] list, int top, int end) {
		int key = (top + end) / 2;
		int keyvalue = list[key];
		while (top != end) {
			while (list[end] > keyvalue && top < end)
				end--;
			list[top] = list[end];
			while (list[top] <= keyvalue && top < end)
				top++;
			list[end] = list[top];
		}
		list[top] = keyvalue;
		return top;
	}