数据结构与算法——查找与排序

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

概述

以前看到这样一句话，语言只是工具，算法才是程序设计的灵魂。的确，算法在计算机科学中的地位真的很重要，在很多大公司的笔试面试中，算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升，花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。

算法简介
算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决，可能会存在着不同的算法，为了衡量一个算法的优劣，提出了空间复杂度与时间复杂度这两个概念。

• 时间复杂度

一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，算法的时间度量记为 ** T(n) = O(f(n)) **，它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度。这里需要重点理解这个增长率。

• 空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

一、查找算法

查找和排序是最基础也是最重要的两类算法，熟练地掌握这两类算法，并能对这些算法的性能进行分析很重要，这两类算法中主要包括二分查找、快速排序、归并排序等等。

顺序存储结构的查找

顺序查找又称线性查找。它的过程为：从查找表的第一个或最后一个元素开始逐个与给定关键字比较，若某个记录的关键字和给定值比较相等，则查找成功，否则，若直至第一个（最后一个）记录，其关键字和给定值比较都不等，则表明表中没有所查记录查找不成功，它的缺点是效率低下。

/**
 * 顺序查找
 * 
 * @param a
 *            数组
 * @param key
 *            待查找关键字
 * @return 关键字下标
 */
public static int sequentialSearch(int[] a, int key) {
   
   
	for (int i = 0; i < a.length; i++) {
   
   
		if (a[i] == key)
			return i;
	}
	return -1;
}

这段代码非常简单，就是在数组a中查看有没有关键字key，当你需要查找复杂表结构的记录时，只需要把数组a与关键字key定义成你需要的表结构和数据类型即可。

顺序表查找优化

/**
 * 顺序查找
 * 
 * @param a
 *            数组
 * @param key
 *            待查找关键字
 * @return 关键字下标
 */
public static int sequentialSearch(int[] a, int key) {
   
   
	for (int i = 0; i < a.length; i++) {
   
   
		if (a[i] == key)
			return i;
	}
	return -1;
}

这种在查找方向的尽头放置"哨兵"免去了在查找过程中每一次比较后都要判断查找位置是否越界的小技巧，看似与原先差别不大，但在总数据较多时，效率提高很大，是非常好的编码技巧。当然，"哨兵"也不一定就一定要在数组开始，也可以在末端。

链式存储结构的查找

链表遍历

折半查找（二分查找）

折半查找(Binary Search)技术，又称为二分查找。它的前提是线性表中的记录必须是关键码有序(通常从小到大有序) ，线性表必须采用顺序存储。折半查找的基本思想是:在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功;若给定值小于中间记录的关键字，则在中间记录的左半区继续查找;若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上 述过程，直到查找成功，或所有查找区域无记录，查找失败为止。

/**
 * 折半查找
 * 
 * @param a
 *            数组
 * @param key
 *            待查找关键字
 * @return 返回折半下标， -1表示不存在该关键字
 */
public static int binarySearch(int[] a, int key) {
   
   
	int low, mid, high;
	low = 0;// 最小下标
	high = a.length - 1;// 最大小标
	while (low <= high) {
   
   
		mid = (high + low) / 2;// 折半下标
		if (key > a[mid]) {
   
   
			low = mid + 1; // 关键字比 折半值 大，则最小下标 调成 折半下标的下一位
		} else if (key < a[mid]) {
   
   
			high = mid - 1;// 关键字比 折半值 小，则最大下标 调成 折半下标的前一位
		} else {
   
   
			return mid; // 当 key == a[mid] 返回 折半下标
		}
	}
	return -1;

该算法还是比较容易理解的，同时我们也能感觉到它的效率非常高。但到底高多少?关键在于此算法的时间复杂度分析。

首先，我们将数组的查找过程绘制成一棵二叉树，如果查找的关键字不是中间记录的话，折半查找等于是把静态有序查找表分成了两棵子树，即查找结果只需要找其中的一半数据记录即可，等于工作量少了一半，然后继续折半查找，效率当然是非常高了。

根据二叉树的性质4，具有n个结点的完全二叉树的深度为[log2n]+1。在这里尽管折半查找判定二叉树并不是完全二叉树，但同样相同的推导可以得出，最坏情况是查找到关键字或查找失败的次数为[log2n]+1，最好的情况是1次。
因此最终我们折半算法的时间复杂度为O(logn)，它显然远远好于顺序查找的O(n)时间复杂度了。
不过由于折主查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，这样的算法已经比较好了。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。

其他查找算法

java实现常见查找算法

二、排序算法

排序时空复杂稳定性汇总

简单选择排序

选择排序的基本思想是每一趟在n-i+1(i=1,2,……,n-1)个记录中选取关键字最小的记录作为有序序列的第i个记录。我们这里先介绍的是简单选择排序法。
简单选择排序法 (Simple Selection Sort) 就是通过 n - i 次关键字间的比较，从n-i + 1 个记录中选出关键字最小的记录，并和第 i ( 1 <= i <=n) 个记录交换之。
选择排序将数组分成已排序区间和未排序区间。初始已排序区间为空。每次从未排序区间中选出最小的元素插入已排序区间的末尾，直到未排序区间为空。

public class SelectionSort {
   
   

	public static void selectionSort(int[] arr) {
   
   
		if (arr == null || arr.length < 2) {
   
   
			return;
		}
		for (int i = 0; i < arr.length - 1; i++) {
   
   
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
   
   
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}

	public static void swap(int[] arr, int i, int j) {
   
   
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}
}

冒泡排序

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让它俩互换。

public class BubbleSort {
   
   

	public static void bubbleSort(int[] arr) {
   
   
		if (arr == null || arr.length < 2) {
   
   
			return;
		}
		for (int e = arr.length - 1; e > 0; e--) {
   
   
			for (int i = 0; i < e; i++) {
   
   
				if (arr[i] > arr[i + 1]) {
   
   
					swap(arr, i, i