各种排序算法模板

冒泡排序

// 冒泡排序，a表示数组，n表示数组大小
	public void bubbleSort(int[] a, int n) {
		if (n <= 1)
			return;
		for (int i = 0; i < n; ++i) {
			// 提前退出冒泡循环的标志位
			boolean flag = false;
			for (int j = 0; j < n - i - 1; ++j) {
				if (a[j] > a[j + 1]) { // 交换
					int tmp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = tmp;
					flag = true; // 表示有数据交换
				}
			}
			if (!flag)
				break; // 没有数据交换，提前退出
		}
	}

---

快速排序

public static void quickSort(int[] array, int begin, int end) {
		if (end <= begin)
			return;
		int pivot = partition(array, begin, end);
		quickSort(array, begin, pivot - 1);
		quickSort(array, pivot + 1, end);
	}

	static int partition(int[] a, int begin, int end) {
		// pivot: 标杆位置，counter: 小于pivot的元素的个数
		int pivot = end, counter = begin;
		for (int i = begin; i < end; i++) {
			if (a[i] < a[pivot]) {
				int temp = a[counter];
				a[counter] = a[i];
				a[i] = temp;
				counter++;
			}
		}
		int temp = a[pivot];
		a[pivot] = a[counter];
		a[counter] = temp;
		return counter;
	}

---

插入排序

	// 插入排序，a表示数组，n表示数组大小
	public void insertionSort(int[] a, int n) {
		if (n <= 1)
			return;

		for (int i = 1; i < n; ++i) {
			int value = a[i];
			int j = i - 1;
			// 查找插入的位置
			for (; j >= 0; --j) {
				if (a[j] > value) {
					a[j + 1] = a[j]; // 数据移动
				} else {
					break;
				}
			}
			a[j + 1] = value; // 插入数据
		}
	}

	int[] insertionSort(int[] arr) {
		int len = arr.length;
		int preIndex, current;
		for (int i = 1; i < len; i++) {
			preIndex = i - 1;
			current = arr[i];
			while (preIndex >= 0 && arr[preIndex] > current) {
				arr[preIndex + 1] = arr[preIndex];
				preIndex--;
			}
			arr[preIndex + 1] = current;
		}
		return arr;
	}

---

选择排序

	public int[] selectionSort(int[] arr, int n) {

		int minIndex, temp;
		for (int i = 0; i < n - 1; i++) {
			minIndex = i;
			for (int j = i + 1; j < n; j++) {
				if (arr[j] < arr[minIndex]) { // 寻找最小的数
					minIndex = j; // 将最小数的索引保存
				}
			}
			temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
		}
		return arr;
	}

---

堆排序

	public static void heapSort(int[] array) {
		if (array.length == 0)
			return;

		int length = array.length;
		for (int i = length / 2 - 1; i >= 0; i--)
			heapify(array, length, i);

		for (int i = length - 1; i >= 0; i--) {
			int temp = array[0];
			array[0] = array[i];
			array[i] = temp;
			heapify(array, i, 0);
		}
	}

	static void heapify(int[] array, int length, int i) {
		int left = 2 * i + 1, right = 2 * i + 2;
		int largest = i;

		if (left < length && array[left] > array[largest]) {
			largest = left;
		}
		if (right < length && array[right] > array[largest]) {
			largest = right;
		}

		if (largest != i) {
			int temp = array[i];
			array[i] = array[largest];
			array[largest] = temp;
			heapify(array, length, largest);
		}
	}

---

归并排序

	public static void mergeSort(int[] array, int left, int right) {

		if (right <= left)
			return;
		int mid = (left + right) >> 1; // (left + right) / 2

		mergeSort(array, left, mid);
		mergeSort(array, mid + 1, right);
		merge(array, left, mid, right);

	}

	public static void merge(int[] arr, int left, int mid, int right) {

		int[] temp = new int[right - left + 1]; // 中间数组
		int i = left, j = mid + 1, k = 0;

		while (i <= mid && j <= right) {
			temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
		}

		while (i <= mid)
			temp[k++] = arr[i++];
		while (j <= right)
			temp[k++] = arr[j++];

		for (int p = 0; p < temp.length; p++) {
			arr[left + p] = temp[p];
		}
		// 也可以用 System.arraycopy(a, start1, b, start2, length)
	}

---

计数排序

	// 计数排序，a是数组，n是数组大小。假设数组中存储的都是非负整数。
	public static void countingSort(int[] a, int n) {
		if (n <= 1)
			return;

		// 查找数组中数据的范围
		int max = a[0];
		for (int i = 1; i < n; ++i) {
			if (max < a[i]) {
				max = a[i];
			}
		}

		int[] c = new int[max + 1]; // 申请一个计数数组c，下标大小[0,max]
		for (int i = 0; i <= max; ++i) {
			c[i] = 0;
		}

		// 计算每个元素的个数，放入c中
		for (int i = 0; i < n; ++i) {
			c[a[i]]++;
		}

		// 依次累加
		for (int i = 1; i <= max; ++i) {
			c[i] = c[i - 1] + c[i];
		}

		// 临时数组r，存储排序之后的结果
		int[] r = new int[n];
		// 计算排序的关键步骤，有点难理解
		for (int i = n - 1; i >= 0; --i) {
			int index = c[a[i]] - 1;
			r[index] = a[i];
			c[a[i]]--;
		}

		// 将结果拷贝给a数组
		for (int i = 0; i < n; ++i) {
			a[i] = r[i];
		}
	}