日撸 Java 三百行学习笔记day48 50

第 48 天: 堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

算法步骤：首先将n个元素建成初始堆，由于堆本身的特点（以大顶堆为例），堆顶元素就是最大值。输出堆顶元素后，通常将堆底元素送上堆顶，此时根节点已不满足大顶堆的性质。堆被破坏， 将堆顶元素向下调整使其继续保持大顶堆的性质，再输出堆项元素。如此重复，直到堆中仅剩一个元素为止。

初看了一下代码感觉很抽象，挺难的，需要对二叉树有一定的了解，同时需要分为几步来理解，特别是在调整树的时候，最为核心。

/**
	 *********************
	 * Heap sort. Maybe the most difficult sorting algorithm.
	 *********************
	 */
	public void heapSort() {
		DataNode tempNode;
		// Step 1. Construct the initial heap.
		for (int i = length / 2 - 1; i >= 0; i--) {
			adjustHeap(i, length);
		} // Of for i
		System.out.println("The initial heap: " + this + "\r\n");

		// Step 2. Swap and reconstruct.
		for (int i = length - 1; i > 0; i--) {
			tempNode = data[0];
			data[0] = data[i];
			data[i] = tempNode;

			adjustHeap(0, i);
			System.out.println("Round " + (length - i) + ": " + this);
		} // Of for i
	}// Of heapSort

	/**
	 *********************
	 * Adjust the heap.
	 * 
	 * @param paraStart  The start of the index.
	 * @param paraLength The length of the adjusted sequence.
	 *********************
	 */
	public void adjustHeap(int paraStart, int paraLength) {
		DataNode tempNode = data[paraStart];
		int tempParent = paraStart;
		int tempKey = data[paraStart].key;

		for (int tempChild = paraStart * 2 + 1; tempChild < paraLength; tempChild = tempChild * 2 + 1) {
			// The right child is bigger.
			if (tempChild + 1 < paraLength) {
				if (data[tempChild].key < data[tempChild + 1].key) {
					tempChild++;
				} // Of if
			} // Of if

			System.out.println("The parent position is " + tempParent + " and the child is " + tempChild);
			if (tempKey < data[tempChild].key) {
				// The child is bigger.
				data[tempParent] = data[tempChild];
				System.out.println("Move " + data[tempChild].key + " to position " + tempParent);
				tempParent = tempChild;
			} else {
				break;
			} // Of if
		} // Of for tempChild

		data[tempParent] = tempNode;

		System.out.println("Adjust " + paraStart + " to " + paraLength + ": " + this);
	}// Of adjustHeap

主要核心还是在adjustHeap里面，从第一个非叶节点开始，逆向判断它与它的孩子节点的大小，然后进行换位（先孩子比，然后大的与其父节点比）。每次把根节点和最后一个叶子节点交换，即每次只排好根节点一个数。

第49天的还没怎么看明白，先放一下。

第 50 天: 小结

查找算法总结：

​一、顺序查找
　　条件：无序或有序队列。
　　原理：按顺序比较每个元素，直到找到关键字为止。
　　时间复杂度：O(n)

二、二分查找（折半查找）
　　条件：有序数组
　　原理：查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；
　　　　　如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
　　　　　如果在某一步骤数组为空，则代表找不到。
　　　　　这种搜索算法每一次比较都使搜索范围缩小一半。
　　时间复杂度：O(logn)

三、哈希表（散列表）
　　条件：先创建哈希表（散列表）
　　原理：根据键值方式(Key value)进行查找，通过散列函数，定位数据元素。
　　时间复杂度：几乎是O(1)，取决于产生冲突的多少。

排序算法总结：

1.快排

（1）算法思想

选择一个基准元素，将比基准元素小的元素放在其前面，比基准元素大的元素放在其后面，然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序，直到整个序列有序;

（2）优缺点

优点：极快数据移动少；

缺点：不稳定；

（3）效率分析

此排序算法的效率在序列越乱的时候，效率越高。在数据有序时，会退化成冒泡排序；

2.冒泡排序

（1）基本原理

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现他们的排序与排序要求相反时，就将他们互换。

（2）优缺点

优点：稳定

缺点：慢，每次只能移动两个相邻的数据；

3.插入排序

（1）基本思想

将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。即先将序列的第一个记录看成是一个有序的子序列，然后从第二个记录逐个进行插入，直至整个序列有序为止。

（2）优缺点

优点：稳定，快

缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是数据量庞大的时候

4.堆排序

二叉堆定义：

二叉堆是完全二叉树或近似完全二叉树。二叉堆满足两个特性:

（1）父结点的键值总是大于或者等于（小于或者等于）任何一个子节点的键值；

（2）每个结点的左子树和右子树都是一个二叉堆；

当父结点的键值总是大于或者等于任何一个子节点的键值时为大根堆。当父结点的键值总是小于或等于任何一个子节点的键值时为小根堆；

5.希尔排序

（1）基本思想

先将整个待排序元素序列分割成若干子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序（因为直接插入排序在元素基本有序的情况下，效率很高）；

（2）适用场景

比较在希尔排序中是最主要的操作，而不是交换。用已知最好的步长序列的希尔排序比直接插入排序要快，甚至在小数组中比快速排序和堆排序还快，但在涉及大量数据时希尔排序还是不如快排；

6.归并排序

（1）基本思想

首先将初始序列的n个记录看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2的有序子序列，在此基础上，再对长度为2的有序子序列进行两两归并，得到若干个长度为4的有序子序列，以此类推，直到得到一个长度为n的有序序列为止；

（2）适用场景

若n较大，并且要求排序稳定，则可以选择归并排序；

7.简单选择排序

（1）基本思想

第一趟：从第一个记录开始，将后面n-1个记录进行比较，找到其中最小的记录和第一个记录进行交换；

第二趟：从第二个记录开始，将后面n-2个记录进行比较，找到其中最小的记录和第2个记录进行交换；

...........

第i趟：从第i个记录开始，将后面n-i个记录进行比较，找到其中最小的记录和第i个记录进行交换；

以此类推，经过n-1趟比较，将n-1个记录排到位，剩下一个最大记录直接排在最后。
 

最后设计一个自己的 Hash 函数和一个冲突解决机制：

我用的平方探测：

public DataArray(int[] paraKeyArray, String[] paraContentArray, int paraLength) {
		// Step 1. Initialize.
		length = paraLength;
		data = new DataNode[length];

		for (int i = 0; i < length; i++) {
			data[i] = null;
		} // Of for i

		// Step 2. Fill the data.
		int tempPosition;
		int k = 0;
		for (int i = 0; i < paraKeyArray.length; i++) {
			// Hash.
			tempPosition = paraKeyArray[i] % paraLength;
			int pos = tempPosition;
			// Find an empty position
			while (data[tempPosition] != null) {
				k += 1;
				tempPosition = pos;
				tempPosition = (pos + k * k) % paraLength;
				System.out.println("Collision, move forward for key " + paraKeyArray[i]);

			} // Of while
			k = 0;
			data[tempPosition] = new DataNode(paraKeyArray[i], paraContentArray[i]);
		} // Of for i
	}// Of the second constructor

	/**
	 *********************
	 * Hash search.
	 * 
	 * @param paraKey The given key.
	 * @return The content of the key.
	 *********************
	 */
	public String hashSearch(int paraKey) {
		int tempPosition = paraKey % length;
		int i = 0;
		while (data[tempPosition] != null) {

			if (data[tempPosition].key == paraKey) {

				return data[tempPosition].content;

			} // Of if

			System.out.println("Not this one for " + paraKey);
			i += 1;
			tempPosition = paraKey % length;
			tempPosition = (tempPosition + i * i) % length;

		} // Of while

		return "null";
	}// Of hashSearch

看着可能比较简单，但是还是改了我很久，中间的各种调试错误，死循环都来了，控制台一直在不停输出。对于如何实现1²，2²，3²....我从多加一个循环改到变为累加。中间还有很多小细节。还好最后改出来并且运行成功了。
​