排序算法

一、概念

    排序分为内部排序和外部排序，通常我们说的排序算法指内部排序，即将数据在内存中进行排序。

    内部排序又分为比较排序和非比较排序。比较排序包括：冒泡排序、快速排序、插入排序、选择排序、归并排序等；

非比较排序包括：计数排序、基数排序、桶排序等。

    算法复杂度：

    注：稳定性指两个相等的元素，排序后这两个元素的位置先后是否一定跟原来一致，一致为稳定。

二、插入排序

1、直接插入排序

概念：构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应的位置并插入。

时间复杂度（平均）：O(n^2)

空间复杂度：O(1)

稳定

public class DirectInsertSort {

	public void sort(int[] arr) {
		int j, insertNode;
		for (int i = 1; i < arr.length; i++) {
			insertNode = arr[i];
			j = i - 1;
			while (j >= 0 && insertNode < arr[j]) {
				arr[j + 1] = arr[j];
				j--;
			}
			arr[j + 1] = insertNode;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
		new DirectInsertSort().sort(arr);
		System.out.println(Arrays.toString(arr));
	}

}

2、希尔排序

概念：设置步长，优先比较距离较远的元素，然后逐渐减小步长，最终通过一次直接插入排序完成。

时间复杂度（平均）：O(n^1.3)

空间复杂度：O(1)

不稳定

public class ShellSort {

	public void sort(int[] arr) {
		int temp;
		int dk = arr.length / 2;
		while (dk > 0) {
			for (int i = dk; i < arr.length; i++) {
				temp = arr[i];
				int j = i - dk;
				while (j >= 0 && arr[j] > temp) {
					arr[j + dk] = arr[j];
					j -= dk;
				}
				arr[j + dk] = temp;
			}
			dk = dk / 2;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
		new ShellSort().sort(arr);
		System.out.println(Arrays.toString(arr));
	}
}

三、选择排序

1、简单选择排序

概念：每次从未排序队列中选择最小的元素放到已排序队列第1个位置，接着从剩下的中找最小的元素放到已排序队列第2个位置，如此重复。

时间复杂度（平均）：O(n^2)

空间复杂度：O(1)

不稳定

public class SimpleSelectSort {

	public void sort(int[] arr) {
		int min;
		for (int i = 0; i < arr.length - 1; i++) {
			// 找到最小元素的下标
			min = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[min])
					min = j;
			}
			// 交换
			int temp = arr[min];
			arr[min] = arr[i];
			arr[i] = temp;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
		new SimpleSelectSort().sort(arr);
		System.out.println(Arrays.toString(arr));
	}
}

2、堆排序

待完成。。。

四、交换排序

1、冒泡排序

概念：相邻两个比较，将最大的元素往后移。

时间复杂度（平均）：O(n^2)

空间复杂度：O(1)

稳定

public class BubbleSort {

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

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
		new BubbleSort().sort(arr);
		System.out.println(Arrays.toString(arr));
	}
}

2、快速排序

概念：找一个元素，所有元素跟这个元素比较，比它小的放左边，比它大的放右边，然后分别再递归左右两边。

时间复杂度（平均）：O(nlogn)

空间复杂度：O(nlogn)

不稳定

public class QuickSort {

	public void sort(int[] arr, int low, int high) {
		if (low < high) {// 递归终止条件
			int mid = qsort(arr, low, high);
			sort(arr, low, mid - 1);
			sort(arr, mid + 1, high);
		}
	}

	/*
	 * 递归函数
	 * 通过arr[low]将数组分成左右两部分
	 */
	private int qsort(int[] arr, int low, int high) {
		int pivot = arr[low];
		while (low < high) {
			while (low < high && pivot <= arr[high])
				high--;
			arr[low] = arr[high];
			while (low < high && pivot >= arr[low])
				low++;
			arr[high] = arr[low];
		}
		arr[low] = pivot;
		return low;
	}

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
		new QuickSort().sort(arr, 0, arr.length - 1);
		System.out.println(Arrays.toString(arr));
	}
}

五、归并排序

概念：从中间劈开，左右两边分别排序，然后再合并。

时间复杂度（平均）：O(nlogn)

空间复杂度：O(n)

稳定

public class MergeSort {

	public void sort(int[] arr) {
		int[] temp = new int[arr.length];
		msort(arr, 0, arr.length - 1, temp);
	}

	private void msort(int[] arr, int low, int high, int[] temp) {
		if (low < high) {// 递归终止条件
			int mid = (low + high) / 2;
			msort(arr, low, mid, temp);
			msort(arr, mid + 1, high, temp);
			merge(arr, low, high, mid, temp);
		}
	}

	// 合并
	private void merge(int[] arr, int low, int high, int mid, int[] temp) {
		int i = low;
		int j = mid + 1;
		int k = 0;
		while (i <= mid && j <= high) {
			if (arr[i] <= arr[j]) {
				temp[k++] = arr[i++];
			} else {
				temp[k++] = arr[j++];
			}
		}
		while (i <= mid)
			temp[k++] = arr[i++];
		while (j <= high)
			temp[k++] = arr[j++];
		k = 0;
		while (low <= high) {
			arr[low++] = temp[k++];
		}
	}

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49 };
		new MergeSort().sort(arr);
		System.out.println(Arrays.toString(arr));
	}
}