数据结构与算法-排序(冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序，堆排序)

排序

定义

• 对一序列对象根据某个关键字进行排序。

术语

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
• 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
• 内排序：所有排序操作都在内存中完成；
• 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
• 时间复杂度： 一个算法执行所耗费的时间。
• 空间复杂度：运行完一个程序所需内存的大小。

时间复杂度总结

• n: 数据规模
• k: “桶”的个数
• In-place: 占用常数内存，不占用额外内存
• Out-place: 占用额外内存

1.冒泡排序

• 时间复杂度：O(n^2)
  

• 基本思想
  1）通过对待排序序列从前到后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素从前移向后部，就像水底下的气泡一样逐渐上冒。
  2) 因为排序过程中，各元素不断接近自己的位置，如果下一趟比较下来没有进行交换，就说明序列有序，因此在排列过程中设置一个flag判断元素是否进行过交换，从而减少不必要的比较。

• 代码实现

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

2.插入排序

• 时间复杂度：O(n^2)
  
• 基本思想
  1）插入排序是对预排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的
  2）把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把他的排序码与有序表元素的排序码j进行比较，将他插入到有序表中的适当位置，使之称为新的有序表。
• 代码实现

public static void insertSort(int[] arr) {
		
	for (int i = 1; i < arr.length; i++) {		
		int j = i;
		int temp = arr[i];
		while (j >= 1 && temp < arr[j - 1]) {
			arr[j] = arr[j - 1];
			j--;
		}
		//当循环退出的时候就找到了插入的位置
		arr[j] = temp;
	}
}

选择排序

• 时间复杂度：O(n^2)
  
• 基本思想
  1）选择排序一共有数组大小-1轮排序
  2）每一轮排序，又是一个循环，先假定当前在这个数是最小的数然后和后面的每个数比较，如果发现有比当前数更小的数，就从新确定最小数，并得到下标
  3）当遍历到数组最后时，就得到本轮最小数和下标
• 代码实现

public static void selectSort(int[] arr) {

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

希尔排序

• 时间复杂度：O(n log n)
  

• 希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序，他是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

• 基本思想
  1）希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含额关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

• 代码实现

// 1) 希尔排序时，对有序序列在插入时采用交换法
public static void shellSortBySwop(int[] arr) {
	
	int temp = 0;
	int gap = arr.length / 2;
	while (gap >= 1) {
		for (int i = gap; i < arr.length; i++) {
			
			//遍历各组中所有的元素(共5组，每组有2个元素)，步长5
			for (int j = i - gap; j >= 0; j -= gap) {
				//如果当前元素大于加上步长后的那个元素，说明交换
				if (arr[j] > arr[j+gap]) {
					//这里类似于逆向冒泡排序
					//因为从步长gap开始遍历，随着i的增加，每组包含额关键词越来越多，
					//仔细发现每次都是加1个关键词，并且前面的关键词已经进行了排序完成，
					//我们每次只需要增加的那一个关键词与其前面一个关键词的排序即可，
					//如果发生交换就继续判断，未发生交换，由于前面的数据已经排序完成，
					//所以无需进行下次比较，break即可
					temp = arr[j];
					arr[j] = arr[j+gap];
					arr[j+gap] = temp;
					continue;
				}
				break;
			}
		}
		gap /= 2;
	}
}

// 2) 希尔排序时，对有序序列在插入时采用移动法
public static void shellSortByMove(int[] arr) {
	int gap = arr.length / 2;
	
	while (gap > 0) {
		
		//从第gap个元素，逐个对其所在的数组进行插入排序
		for (int i = gap; i < arr.length; i++) {
			int j = i;
			int temp  = arr[j];
			if (arr[j] < arr[j-gap]) {
				while (j - gap >= 0 && temp < arr[j - gap]) {
					//移动
					arr[j] = arr[j-gap];
					j -= gap;
				}
			}
			//当退出while循环即找到位置
			arr[j] = temp;
		}
		gap /= 2;
	}
}

快速排序

• 时间复杂度：O(n log n)
  

• 快速排序(Quicksort)是对冒泡排序的一种改进

• 基本思想
  1）通过一趟排序将排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以达到整个数据变成有序序列

• 代码实现

public static void quickSort(int[] arr, int left, int right) {
	int l = left;  //左下标
	int r = right;  //右下标
	
	//pivot 中轴
	int pivot = arr[(left + right) / 2];
	
	int temp = 0;  //临时变量，交换时使用
	
	//while循环的目的是让我们比pivot小的值放在左边，比pivot大的值放在右边
	while (l < r) {
		
		//在pivot左边一直找，找到大于等于pivot的值才去处理
		while (arr[l] < pivot) {
			l += 1;
		}
		//在pivot右边一直找，找到小于等于pivot的值，才退出
		while (arr[r] > pivot) {
			r -= 1;
		}
		
		//如果 l >= r成立，说明pivot左右两边的值已经按照左边全部小于等于pivot
		//而右边大于等于pivot
		if (l >= r) break;
		temp = arr[l];
		arr[l] = arr[r];
		arr[r]= temp;
		
		//如果交换完后发现arr[l] == pivot, r--,前移
		//左边为pivot，说明pivot原来是右边的，原来的左边是>=pivot的数，
		//交换过后，左边的肯定为pivot，右边的此时一定大于等于pivot，所以r--
		//先写arr[l] == pivot，保证了右边的值肯定大于等于pivot
		if (arr[l] == pivot) {
			r--;
			//flag = false;
		}
		//如果交换完后，发现这个arr[r] == pivot, l++,后移
		if (arr[r] == pivot) {
			l++;
		}
	}
	
	//如果l == r，必须l++,r--，否则出现栈溢出
	//极端情况例如0-n需要进行排序，此时arr[0]==arr[mid]，且 arr[0]在 0 - n中是最小的
	//最后while完成后l = r = 0，此时0-n无限循环向右递归，栈溢出
	if (l == r) {
		l += 1;
		r -= 1;
	}
	
	//向左递归
	if (left < r) {
		quickSort(arr, left, r);
	}
	
	//向右递归
	if (right > l) {
		quickSort(arr, l, right);
	}
}

基数排序

• 时间复杂度：O(n*k)
  
• 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin
  sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
• 基数排序属于稳定性排序，技术排序是效率高的稳定性排序法
• 基数排序（radix sort）是桶排序的扩展
• 基数排序是1887年赫尔曼·何乐发明的，他是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较
• 基本思想
  1）将所有待比较数值统一为同样的数位长度，数位短的数前面补0，然后，从低位开始，依次进行一次排序。这样从低位排序一直到最高位排序完成以后，数列就变成一个有序序列
• 代码实现

public static void radixSort(int arr[]) {
		
	//定义一个二维数组，表示10个桶，每个桶就是一个一维数组
	//为了防止极端情况下放入数的时候数据溢出，每个一维数组(桶)大小定位arr.length
	//由此看出基数排序空间换时间的经典算法
	int[][] bucket = new int[10][arr.length];
	
	//为了记录每个桶中，实际存放了多少数据，定义一个一维数组来记录各个桶每次放入的个数
	int[] bucketEmelentCounts = new int[10];
	
	//得到数组中最大的数的位数
	int max = arr[0];  //假设第一个数就是最大
	for (int i = 1; i < arr.length; i++) {
		if (arr[i] > max) max = arr[i];
	}
	int maxLength = (max + "").length();
	
	for (int i = 0; i < maxLength; i++) {
		
		for	(int j = 0; j < arr.length; j++) {
			//取出每个元素的个位
			int digitOfElement = (arr[j] / (int) Math.pow(10, i)) % 10;
			//放入到对应的桶中
			bucket[digitOfElement][bucketEmelentCounts[digitOfElement]] = arr[j];
			bucketEmelentCounts[digitOfElement]++;
		}
		
		//按照桶的顺序（一维数组下标依次取出数据）
		int index = 0;
		//遍历每一个桶，并将桶的数据放入到原数组
		for (int k = 0; k < bucketEmelentCounts.length; k++) {
			//如果桶中有数据，我们才放入到原数组
			//第k个一维数组
			for (int l = 0; l < bucketEmelentCounts[k]; l++) {
				//取出元素放入到arr中
				arr[index] = bucket[k][l];
				index++;
			}
			//将bucketEmelentCounts[k]记录的个数置0
			bucketEmelentCounts[k] = 0;
		}	
	}
}

堆排序

• 时间复杂度：O(nlogn)
  
• 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn),它也是不稳定排序
• 堆是具有以下性质的完全二叉树，每个节点的值都大于等于其左右孩子节点的值，称为大顶堆，注意：没有要求节点的左孩子值和右孩子值的大小关系
• 每个节点的值都小于等于左右孩子节点的值，称为小顶堆
• 大顶堆特点：arr[i] >= arr[2i + 2] && arr[i] >= arr[2i +2]
• 小顶堆特点：arr[i] <= arr[2i + 2] && arr[i] <= arr[2i +2]
• 一般升序采用小顶堆，降序采用大顶堆
• 基本思想
  1）将待排序序列构成一个大顶堆
  2）此时，整个序列的最大值就是顶堆的根节点
  3）将其与末尾元素进行交换，此时末尾元素就是最大值
  4）然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
• 代码实现

//堆排序
public static void heapSort(int[] arr) {
	
	int temp = 0;
	
	/*
	  *  拿到最后一个非叶子节点
	 * arr.length  = (i * 2) + 2, 故 => i = arr.length / 2 - 1
	 *   因为数组的length为最后的下标+1，所以无论是否是完全二叉树，完全二叉树length为单数
	 * length为单数时，length / 2 和 (length - 1) / 2相同，故能找到最后一个非叶子节点
	 */
	for (int i = arr.length / 2 - 1; i >= 0; i--) {
		//找到最后一个非叶子节点，前面所有的节点都是非叶子节点，依次进行大顶堆
		adjustHeap(arr, i, arr.length);
	}
	
	for (int j = arr.length - 1; j > 0; j--) {
		temp = arr[j];
		arr[j] = arr[0];
		arr[0] = temp;
		
		adjustHeap(arr, 0, j);
	}
}

//将一个数组（二叉树调整成一个大顶堆）
/**
 *    功能：完成将以i对应的非叶子节点的树调整成大顶堆
 *    	 int[] arr = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => arr = {4, 9, 8, 5, 6};
 * @param arr待调整的数组
 * @param i 表示非叶子节点在数组中的索引
 * @param length 表示对多少个元素进行调整，length在逐渐减少
 */
public static void adjustHeap(int[] arr, int i, int length) {
	
	int temp = arr[i]; //先取出当前元素的值，保存在临时变量
	//开始调整
	for (int k = i * 2 + 1; k <length; k = k * 2 + 1) {
		if (k + 1 < length && arr[k] < arr[k+1]) {  //说明i左子节点的值小于右子节点的值
			k++;
		}
		
		if (arr[k] > temp) {  //如果子节点大于父节点
			arr[i] = arr[k];  //把较大的值赋给当前节点
			i = k;  //i指向k，继续循环比较
		} else {
			break;
		}
	}
	//当for结束后，我们已经将以i为父节点的树的最大值，放在了最顶上
	arr[i] = temp; //将temp值放到调整过后的位置
}

------此文章总结改造来自韩顺平老师讲解的java数据结构与算法