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)
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)
![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)
树的定义与二叉树的性质
![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)
二叉树遍历的过程
先序遍历:中 左 右
中序遍历:左 中 右
后序遍历:左 右 中
二叉树遍历的递归算法
![img](file:///D:\qq消息记录\2844938982\nt_qq\nt_data\Pic\2024-05\Ori\5dbcb49ed8a09e587b3d49d4d531a0ab.png)
二叉树遍历的非递归算法
层次遍历二叉树
二叉树的建立
对于完全二叉树,可以把树存储在一个数组中
但是对于大多数的二叉树,需要用链的形式来储存来减少空间的浪费
节点类型的定义
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];
}
根据广义表构建二叉树
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;
}
根据先根和中根次序建立二叉树
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);
}
课后习题
9.1
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
排序算法稳定性:
算法 | 平均时间复杂度 | 空间复杂度 | 是否稳定 |
---|---|---|---|
直接插入排序 | \(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)\) | 稳定 |
排序算法的形式
直接插入排序
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;
}
}
冒泡排序
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;
}
}
选择排序
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)
哈希表的实现(散列链法)
![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)
顺序查找
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;
}
二分查找
前提:序列已经成为有序状态
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\) 的值