数据结构和算法系列（3）排序算法

排序算法

1. 冒泡排序

1. 使用场景

   O（n）= n*(n-1)/2 如果n比较小的话它的时间复杂度就会降级

   数据量比较小，常见于小游戏中10个左右数据的排序场景

2. 具体实现

   	/**
   	 * 冒泡排序算法
   	 * 
   	 * 适用于数据量比较小的场景
   	 * 
   	 * @param array
   	 */
   	public static void bubbleSort(int[] array) {
   		// 3 1 5 8 2 9 4 6 7 n*(n-1)/2 n
   		for (int i = array.length - 1; i > 0; i--) {
   			boolean flag = true;
   			for (int j = 0; j < i; j++) {
   				if (array[j] > array[j + 1]) {
   					// 替换数据
   					int temp = array[j];
   					array[j] = array[j + 1];
   					array[j + 1] = temp;
   					flag = false;
   				}
   			}
   			if (flag) {
   				break;
   			}
   
   		}
   
   	}
   

2. 选择排序

1. 使用场景

   选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

2. 具体实现

   	/**
   	 * 选择排序算法
   	 * 
   	 * 
   	 * @param array
   	 */
   	public static void selectSort(int[] array) {
   		for (int i = 0; i < array.length - 1; i++) {
   			int index = i;
   			for (int j = i + 1; j < array.length; j++) {
   				if (array[j] < array[index]) {
   					index = j;
   				}
   			}
   			if (index != i) {
   				int temp = array[i];
   				array[i] = array[index];
   				array[index] = temp;
   			}
   
   		}
   
   	}
   

3. 快速排序

1. 使用场景
   数据量大并且是线性结构，有一点不好就是出现大量重复数据时候容易性能不好

   前序遍历

2. 具体实现

//这个写起来就有点麻烦了，JDK默认使用就是快速排序算法,这里给出同样功能的实现
/**
	 * 快速排序
	 * 
	 * @param array
	 * @param begin
	 * @param end
	 */
	public static void quickSort(int[] array, int begin, int end) {
		if (end < begin)
			return;
		int x = array[begin];
		int low = begin;
		int high = end;

		boolean direction = true; // 给一个方向，首先从右边到左边
		L1: while (low < high) {
			if (direction) {
				for (int i = high; i > low; i--) {
					if (array[i] <= x) {
						array[low] = array[i];
						low++;
						high = i;
						direction = !direction;
						continue L1;
					}

				}
				high = low;
			} else {
				for (int i = low; i < high; i++) {
					if (array[i] >= x) {
						array[high] = array[i];
						high--;
						low = i;
						direction = !direction;
						continue L1;
					}

				}
				low = high;

			}

		}
		// 第一次循环结束，将左右两边分隔开，左边的全部小于右边的
		array[low] = x;
		// 比较左边的数据
		quickSort(array, begin, low - 1);
		// 比较右边的数据
		quickSort(array, low + 1, end);

	}

4. 归并排序

1. 使用场景

   后序遍历，使用空间比较大

2. 具体实现

   	public static void mergeSort(int array[], int left, int right) {
   		if (left == right) {
   			return;
   		} else {
   			int mid = (left + right) / 2;
   			mergeSort(array, left, mid);
   			mergeSort(array, mid + 1, right);
   			merge(array, left, mid + 1, right);
   		}
   	}
   
   	// 0 4 7
   	// 1 2 5 9 === 3 4 10 11
   	public static void merge(int[] array, int left, int mid, int right) {
           	int leftSize = mid - left;
   		int rightSize = right - mid + 1;
   		// 生成数组
   		int[] leftArray = new int[leftSize];
   		int[] rightArray = new int[rightSize];
   		// 填充数据
   		for (int i = left; i < mid; i++) {
   			leftArray[i - left] = array[i];
   		}
   		for (int i = mid; i <= right; i++) {
   			rightArray[i - mid] = array[i];
   		}
   		// 合并
   		int i = 0;
   		int j = 0;
   		int k = left;
   		while (i < leftSize && j < rightSize) {
   			if (leftArray[i] < rightArray[j]) {
   				array[k] = leftArray[i];
   				k++;
   				i++;
   			} else {
   				array[k] = rightArray[j];
   				k++;
   				j++;
   			}
   		}
   		while (i < leftSize) {
   			array[k] = leftArray[i];
   			k++;
   			i++;
   		}
   		while (j < rightSize) {
   			array[k] = rightArray[j];
   			k++;
   			j++;
   		}
   	}