2024年武汉大学电信算法与数据结构期末复习随记

期末复习

易错点

叶子结点以外的结点称为分支结点

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\9d5f4aefd34e1d8587152f79b567d05a.jpeg)

时间复杂度

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\4cb6f5297e5f4c3c977d0e0a7b1ba811.jpeg)

5684d07b-3c33-452d-bb6d-178909b82001

00441d72-e306-4a7d-85b0-76a6997978c4fa527eb3-6dd6-4ec7-9991-7097d7bd5917

00441d72-e306-4a7d-85b0-76a6997978c4

46ba104a-e61c-4ef8-9c33-9a3598dfc143

1.4

(1) \(O(nm)\)

(2) \(O(n^2)\)

(3) \(O(n^2)\)

(4) \(O(log_3n)\)

线性表

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\4d76e88acec7cf93e3aa1f078d9dae26.jpeg)

0f3e8886-78e1-47e0-ac8b-0a0e02220bf5

b2e31872-a607-4498-9103-8a8ccbca4198

ec3b2a60-2734-4a8f-822d-ca7c2cf1ef0c

4e3cb146-17b4-44e5-87e9-0e1a0b930405

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\7a84e78d0465dda3d3ae587caf7f35d6.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\1a89bf3dcccc1ab8550a0af1a3b23823.jpeg)

栈与队列

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\c03e31102df4a4c59fa8ea846aa39b00.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\35a6a3f2a22c251866cace88b24f6734.jpeg)

String类

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\382d6c69512ab3b2a98ad6e8ae7bd61a.jpeg)

树与二叉树

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\dc9194c4c4765324f08d84d29b54f53f.jpeg)

树的定义与二叉树的性质

image-20240531210602283

image-20240531210633895

image-20240531210734451

image-20240531210806566

image-20240531210858081

image-20240531210918061

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\f58f19fecfe96568c0e4bdb5aebddeec.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\baef45294f2d67fb7472b09eba058faf.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\bd1c694da0cd89b0a352951ed95ab054.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\2ac4ff01a08375650d45f379410903a4.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\e10ebaeef44d8c6e7636bb9fd7edeaad.jpeg)

二叉树遍历的过程

先序遍历:中 左 右

中序遍历:左 中 右

后序遍历:左 右 中

二叉树遍历的递归算法

image-20240531211337490

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\5dbcb49ed8a09e587b3d49d4d531a0ab.png)

image-20240531211418206

二叉树遍历的非递归算法

image-20240531211556860

层次遍历二叉树

image-20240531211639849

二叉树的建立

image-20240601112036312

对于完全二叉树,可以把树存储在一个数组中

但是对于大多数的二叉树,需要用链的形式来储存来减少空间的浪费

image-20240601112330167

节点类型的定义

template <typename T>
struct BTNode{
  T data;
  BTNode<T> *left;
  BTNode<T> *right;
  BTNode(const T& k):data(k),left(nullptr),right(nullptr){};
  BTNode():data{},left(nullptr),right(nullptr){};
  ~BTNode(){ }
};

二叉树类的定义

template <typename T>
class BTree {
protected:
	BTNode<T>* _root;
public:
	BTree():_root(nullptr){}
	const BTNode<T>* root() const { return _root; }
	BTNode<T>*& root() { return _root; }

	void dispose()//删除二叉树
	{
		if (_root != nullptr)
		{
			dispose(_root);
			_root = nullptr;
		}
	}

	void dispose(BTNode<T>* p)
	{
		if (p != nullptr)
		{
			dispose(p->left);
			dispose(p->right);
		}
		delete p;
	}
};

根据顺序表建立二叉树

template <typename T>
void byArray(const T* pt, int cnt, BTree<T>* bt)
{
	int n = cnt;
	if (n == 0)
		bt->root() = nullptr;
	int i, j;
	BTNode<T>** q = new BTNode<T>*[n];
	for (i = 0; i < n; i++)
		q[i] = new BTNode<T>(pt[i]);

	for (i = 0; i < n; i++)
	{
		j = 2 * i + 1;
		if (j < n)
			q[i]->left = q[j];
		else
			q[i]->left = nullptr;
		j++;
		if (j < n)
			q[i]->right = q[j];
		else
			q[i]->right = nullptr;
	}
	bt->root() = q[0];
}

根据广义表构建二叉树

image-20240601113815678

template <typename T>
struct ListFlags {
	T NullSubtreeFlag;
	T LeftDelimitFlag;
	T RightDelimitFlag;
	T MiddleDelimitFlag;
};
static int idx = 0;
static void* pListFlags = nullptr;


template <typename T>
BTNode<T>* rootByGList(T* sList)
{
	BTNode<T>* p = nullptr;
	T nodeData = sList[idx];
	ListFlags<T>* pFlags = (ListFlags<T>*)pListFlags;
	if (isData(nodeData, pFlags))
	{
		p = new BTNode<T>(nodeData);
		idx++;
		nodeData = sList[idx];
		if (nodeData == pFlags->LeftDelimitFlag)
		{
			idx++;
			p->left = rootByGList(sList);
			idx++;
			p->right = rootByGList(sList);
			idx++;
		}
	}
	if (nodeData == pFlags->NullSubtreeFlag)
		idx++;
	return p;
}

template <typename T>
void byGList(T* sList, int cnt, BTree<T>* bt, const ListFlags<T>* pCustomListFlags = nullptr)
{
	idx = 0;
	ListFlags<T> DefaultFlags{ '^','(',')',',' };

	if (cnt > 0)
	{
		ListFlags<T>* p;
		if (pCustomListFlags != nullptr)
			p = (ListFlags<T>*)pCustomListFlags;
		else
			p = &DefaultFlags;
		pListFlags = p;
		bt->root() = rootByGList(sList);
	}
	else
		bt->root() = nullptr;
	return;
}



template <typename T>
bool isData(const T& nodeValue, const ListFlags<T>* pFlags)
{
	if (nodeValue == pFlags->NullSubtreeFlag) return false;
	if (nodeValue == pFlags->LeftDelimitFlag) return false;
	if (nodeValue == pFlags->RightDelimitFlag) return false;
	if (nodeValue == pFlags->MiddleDelimitFlag) return false;
	else return true;
}

根据先根和中根次序建立二叉树

image-20240601114132379

image-20240601114313667

template <typename T>
BTNode<T>* rootBy2Lists(vector<T>& preList, vector<T>& inList) {
	BTNode<T>* p = nullptr;
	vector<T> presub, insub;
	int n = preList.size();
	if (n > 0) {
		T rootData = preList[0];
		p = new BTNode<T>(rootData);
		int k = 0;
		while (k < n && inList[k] != rootData)
			k++;
		for (int i = 0; i < k; i++)
			presub.push_back(preList[i+1]);
		for (int i = 0; i < k; i++)
			insub.push_back(inList[i]);
		p->left = rootBy2Lists(presub, insub);
		presub.clear();
		insub.clear();

		for (int i = 0; i < n - k - 1; i++)
			presub.push_back(preList[i + k + 1]);
		for (int i = 0; i < n - k - 1; i++)
			insub.push_back(inList[i + k + 1]);
		p->right = rootBy2Lists(presub, insub);
	}
	return p;
}

template <typename T>
void by2Lists(vector<T>& preList, vector<T>& inList, BTree<T>* bt) {
	bt->root() = rootBy2Lists(preList, inList);
}

课后习题

f70e757d-fdcf-4de0-bfc2-7ebe7da6ce56

image-20240601103004218

9.1

1)

\[\sum_{k=0}^5 2^k=2^6-1=63 \\ 2^5=32 \]

\[\lfloor \log_2^{257} \rfloor=8 \]

\[n_0+n_1+n_2=1000 \\ n_0=n_2+1 \]

联立可得

9.2

二叉树有左子树和右子树的区别,度为2的数只是最大有两个子树而已

9.3

先序遍历:1 2 3 4 5 6 7 8 9

中序遍历:2 3 4 1 6 7 9 8 5

后序遍历:4 3 2 9 8 7 6 5 1

9.4

排序

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\023c8a827659d76a00d886aa5c9c48ab.jpeg)

5.1

排序算法稳定性:

image-20240531212205255

算法 平均时间复杂度 空间复杂度 是否稳定
直接插入排序 \(O(n^2)\) \(O(1)\) 稳定
冒泡排序 \(O(n^2)\) \(O(1)\) 稳定
快速排序 \(O(nlog_2n)\) \(O(1)\) 不稳定
选择排序 \(O(n^2)\) \(O(1)\) 不稳定
归并排序 \(O(nlog_2n)\) \(O(n)\) 稳定

排序算法的形式

image-20240531212224332

直接插入排序

image-20240531220411738

void InsertSort(T* items, int cnt) {
	T k;
	int m, n = cnt;
	int i, j;
	for (m = 1; m < n; m++)
	{
		k = items[m];
		for (i = 0; i < m; i++)
		{
			if (k < items[i]) {
				for (int j = m - 1; j >= i; j--)
					items[j + 1] = items[j];
				items[i] = k;
				break;
			}
		}
	}
}

优化过的插入排序

由于前面的m-1个数字已经处于排序状态,所以可以运用查找的方法来进行优化寻找下一个数插入位置的方法,因此经过优化的插入排序的时间复杂度为 \(O(nlog_2n)\)

template <typename T>
inline int BinarySearch(T k, T* items, int cnt, int si = 0, int length = -16) {
	if (length == -16)
		length = cnt;
	int mid = 0, left = si;
	int right = left + length - 1;
	while (left <= right) {
		mid = (left + right) / 2;
		if (k == items[mid])
			return mid;
		else if (k < items[mid]) {
			right = mid - 1;
		}
		else
			left = mid + 1;
	}
	if (k > items[mid])
		mid++;
	return ~mid;
}

template <typename T>
void InsertSortBS(T* items, int cnt) {
	T k;
	int  i, j, m, n = cnt;
	for (m = 1; m < n; m++) {
		k = items[m];
		//i = lower_bound(items, items + m, k) - items;

		i = BinarySearch(k, items, cnt, 0, m);
		if (i < 0)
			i = ~i;
		for (j = m - 1; j >= i; j--) 
			items[j + 1] = items[j];
		items[i] = k;
	}
}

冒泡排序

image-20240531220549287

template <typename T>
void myswap(T& x, T& y) {
	T t;
	t = x;
	x = y;
	y = t;
}

template <typename T>
void BubbleSort(T* items, int cnt) {
	for (int i = cnt-1; i > 0; i--) {
		bool exchanged = false;
		for (int j = 0; j < i; j++)
		{
			if (items[j] > items[j + 1])
			{
				exchanged = true;
				myswap(items[j], items[j+1]);
			}
		}
		if (!exchanged)
			break;
	}
}

选择排序

image-20240531232656497

template <typename T>
void myswap(T& x, T& y) {
	T t;
	t = x;
	x = y;
	y = t;
}

template <typename T>
void SelectSort(T* items, int cnt) {
	for (int i = 0; i < cnt; i++)
	{
		T minidx = i ;
		for (int j = i + 1; j < cnt; j++) {
			if (items[j] < items[minidx])
				minidx = j;
		}
		myswap(items[minidx], items[i]);
	}
}

快速排序的原理

1.首先确定一个基准值 \(pilot\) 一般为第一个元素

2.使用两个地址位,第二个元素的地址位为 \(i\) ,最后一个元素的地址位为 \(j\)

3.对 \(i\) 递增操作,直到找到一个 \(i\) 地址位的元素使得其值大于基准值,对 \(j\) 递减操作,只打找到一个 \(j\) 地址位的元素使得其值小于基准值

4.交换 \(i\)\(j\) 两个地址位的元素,重复3中过程,直到不满足 \(i< j\)

5.\(i++,j--\) 然后交换基准元素与 \(j\) 地址位的元素,并以基准值元素为界来分别对左边的元素和右边的元素进行1到5的操作,直到只剩下一个元素为止

归并排序的原理

1.二分区间,把两边的序列认为是已经有序的序列,并将两个有序的序列合成一个有序的序列

2.对于每个想要其有序的序列,对其进行归并排序再合并

3.递归下去,就得到了一个有序的序列

排序的趟数

初始序列并不是第一趟

冒泡排序的最后一趟要跟倒数第二趟一模一样

哈希查找

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\3c133f0a5fdf0413e89921ee4b4b647c.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\e13068a43d93ef4360a11ff104ddeed5.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\86f091129330f87f534b297e41a5840b.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\d9179f727410fa6ac5c8046cc8adc1ca.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\2679dc1123672baead525e0c8d1de1df.jpeg)

探测定址法

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\b1a15dd9574e152cc639bb0e1c721597.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\bace006c201e38ac122c0851e940b2ce.jpeg)

散列链法

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\0a66ca69d8d15fc77f0e89b595396bdc.jpeg)

哈希表的实现(散列链法)

image-20240601111523879

image-20240601111557115

image-20240601111737485

image-20240601111802923

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\fdda1875299e820a78bfb690d51b6393.jpeg)

![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-06\Ori\ff7f86aa62a5c915a1468a9f3f41923f.jpeg)

顺序查找

image-20240601145308942

template <typename IIT,typename T>
int Index(IIT first, IIT end, const T& k) {
	int i = 0;
	auto pitems = first;
	while (pitems < end && (*pitems) != k) {
		i++;
		pitems++;
	}
	if (pitems == end)
		return -1;
	return i;
}

template <typename IIT,typename Predicate>
int IndexIf(IIT first, IIT end, Predicate pred) {
	int i = 0;
	auto pitems = first;
	while (pitems < end && !pred(*pitems))
	{
		i++;
		pitems++;
	}
	if (pitems == end)
		return -1;
	return i;
}

二分查找

前提:序列已经成为有序状态

image-20240601145915042

template <typename T>
int BinarySearch1(const T& k,T* items, int len) {
	int left = 0;
	int right = len - 1;
	int mid = 0;
	while (left <= right) {
		mid = (left + right) / 2;//最迹在这里打i声明,不然就寄了
		if (k == items[mid])
			return mid;
		else if (k < items[mid])
			right = mid - 1;
		else
			left = mid + 1;
	}
	if (k > items[mid])
		mid++;
	
	return ~mid;
}

如果遇到不存在的数,返回的数字是这个数应该插入的地方取反

例如输出为-6,则是正确的插入位置为 \(6-1=5\)

分块查找

把数据按照某种规律储存在不同的块里面,查找的时候再对应块查找就可以了

二叉查找树、排序树与判定树

二叉查找树和二叉排序树是一样的,只是同一个东西的不同名字

二分判定树则是每次二分查找中 \(mid\) 的值

二叉判定树的画法

image-20240601160426559

二叉查找树的画法

image-20240601160536485

image-20240601160541965

posted @ 2024-06-01 23:04  wweiyi  阅读(33)  评论(0编辑  收藏  举报
js脚本