1.7数算PPT选择汇总，PTA选择汇总，计算后缀表达式，中缀转后缀、前缀、快速排序

PTA选择汇总

在第一个位置后插入，注意是在后面插入，而不是前面；要移动49，为50-I，第25个的话，移25个

如果是插在前面，就移动50，N-I+1，注意是插在前面还是后面

删第一个，要移49，即N-I，删第30个，移50-30=20

就是除8取余

数组大小为50，10+50-35

F实指，R虚指，R+20-F=R+5=13

F实指，那么为R+30-F%30=11 ,R虚指，即FR不都是实指，如果都是实指，就是R+M-F+1%M

如果有一个虚指，就是R+M-F%M

归并趟数是LOGN

后序与中序相反，后序为左右根，中序为左根右，那么都没有左孩子

根节点的中序前驱，前驱指的就是这个结点的左孩子的子树结点，然后最右边就一定没孩子了，不然的话不会访问到根节点

后序为左右根，中序为左根右，如果相同的话，就都没有右孩子

初始有N个叶子结点，那么构建出N-1个非叶子结点，总数量为2*N-1=1999，N=1000，即1000个叶子节点

堆一定是完全二叉树，哈夫曼树不一定是完全二叉树，堆中可能存在度为1的结点

树转为二叉树，那么后序遍历和中序遍历相同；先序遍历和先序遍历相同

树不存在中序遍历

对于AVL树的高度，只有一个结点高1，2个高2，

FN=FN-1+FN-2+1，F3=4,F4=7,F5=12,F6=20.N代表的是高度，意思是要达到这个高度，所需要的最少的结点数

先右旋再左旋

是有序的，不过顺序是从小到大

最后是2022，12，0，0，D

第一个查找失败的次数为3，2，1，1，2，然后即9/5=1.8

G 可以是互相独立的点，

拓扑排序要求不能存在回路

考虑，即回路上的边并不一定必须要去构造生成树

最小生成树中任意两点间距并不一定是最短的，但总权和是最小的

计算后缀表达式

class Solution {
public:int tod(string s){int sum=0;for(int i=0;i<s.size();i++){if('0'<=s[i]&&s[i]<='9'){sum=sum*10+(s[i]-'0');}}return s[0]=='-'?-1*sum:sum;}int evalRPN(vector<string>& tokens) {stack<int>st;for(int i=0;i<tokens.size();i++){if(tokens[i].size()==1){char c=tokens[i][0];if('0'<=c&&'9'>=c){st.push(c-'0');}else{int a=st.top();st.pop();int b=st.top();st.pop();switch(c){case'+':st.push(a+b);break;case'-':st.push(b-a);break;case'*':st.push(a*b);break;case'/':st.push(b/a);break;}}}else{st.push(tod(tokens[i]));}}return st.top();}
};

中缀转前缀

中缀转后缀

然后转后缀是要两个栈，一个输出栈，一个辅助栈，输出栈里的元素就是最后要输出的后缀表达式，

如果遇到数字，就直接加到输出栈里，如果遇到括号，就先放到辅助栈里

遇到运算符，首先判断辅助栈是不是空，是空的话就加到辅助栈里，表示做的第一个运算

就是一个是操作符栈，一个是数字栈，最后都给整到数字栈里去，遇到数字直接往数字栈里放，遇到操作符就往操作符栈里放，放的时候注意，第一要判断操作符栈是否为空，第二判断是否遇到了括号，其次判断优先级，

遇到优先级大的（指栈顶优先级比目前大），就栈顶元素先操作，把它加到操作数栈里去，遇到小的或同级的，就入操作符栈，最后再统一加入到数字栈里去

左括号只有遇到右括号才能消掉

这个用来得到优先级，

遍历中缀表达式，保证操作栈的栈顶是当前运算级最高的

class Solution {
public:struct Data {bool is_number {false};long long number {0};char op {'\0'};Data(bool set_is_number, long long set_number, char set_op) : is_number(set_is_number), number(set_number), op(set_op) {};};int calculate(string s) {// 去除所有空格std::string new_s1;for (char c : s) {if (c != ' ') {new_s1 += c;}}// (-n) -> (0-n)// (+n) -> (0+n) (本题没有，忽略)// 开头的-n -> 0-n// 开头的+n -> 0+n (本题没有，忽略)std::string new_s2;int n = new_s1.length();for (int i = 0; i < n; ++i) {if (new_s1[i] == '-' && (i == 0 || new_s1[i - 1] == '(')) {new_s2 += "0-";} else {new_s2 += new_s1[i];}}// 中缀表达式 -> 后缀表达式// 操作符优先级:：^（本题没有，忽略） > *、/（本题没有，忽略） > +、-// 左括号、右括号的优先级单独计算，因为无论定义左括号优先级最高，右括号优先级最低，还是左括号优先级最低，右括号优先级最高，在具体计算的不同逻辑中都无法统一处理// 相同优先级条件下，先出现的优先级更高(即，均是+、-，则先出现的比后出现的优先级级高，即相同优先级的运算符，先出现的先计算)// 转换过程：// 中缀表达式从前向后遍历过程中，保证op_stack的栈顶是当前操作符优先级最高的// 即，如果栈为空，或者当前操作符比栈顶操作符优先级高，则入栈// 遇到(，则认为优先级最高，无脑入栈// 遇到)，则认为优先级最低，不断弹栈到后缀表达式结果datas中，直到遇到(，操作符)不会入栈// 如果栈不为空，且当前操作符比栈顶操作符优先级低或相同(优先级相同时，先出现的优先级更高，需要先进行计算)，则不断弹栈到后缀表达式结果datas中，直到弹到栈为空，或当前操作符优先级比栈顶操作符元素的优先级高，或遇到(，弹栈后，将当前操作符压栈，即，该操作符入栈前，一定要保证所有优先级大于等于该操作符(实际等于时，先出现的优先级也要更高，要先计算)的操作符，都要先输出到后缀表达式结果datas中// 存储后缀表达式std::vector<Data> datas;// 存储操作符op的栈std::stack<char> op_stack;// 中缀表达式 -> 后缀表达式// has_number是为了知道最后是否还有数字元素没有加入到datas中，因为每次遇到操作符才将cur_number写入，但是最后结尾有可能是数字，有可能是操作符)，而且数字可能为0，可能非0，无法判断，所以只能引入额外变量标记bool has_number = false;long long cur_number = 0;for (char c : new_s2) {if (c >= '0' && c <= '9') {// 数字has_number = true;cur_number = cur_number * 10 + c - '0';} else {// 操作符if (has_number) {// 将上一个数字输出到后缀表达式结果datas中datas.emplace_back(true, cur_number, '\0');cur_number = 0;has_number = false;}if (c == '(') {// 遇到(，无脑入栈op_stack.emplace(c);} else if (c == ')') {// 遇到)，不断弹栈到后缀表达式结果datas中，直到遇到(，操作符)不会入栈while (!op_stack.empty() && op_stack.top() != '(') {char op = op_stack.top();op_stack.pop();datas.emplace_back(false, 0, op);}// 将'('弹栈op_stack.pop();} else if (c == '+' || c == '-') {if (op_stack.empty() || op_stack.top() == '(') {// 如果栈为空，或者当前操作符比栈顶操作符优先级高，则入栈op_stack.emplace(c);} else {// 如果栈不为空，且当前操作符比栈顶操作符优先级低或相同(优先级相同时，先出现的优先级更高，需要先进行计算)，则不断弹栈到后缀表达式结果datas中，直到弹到栈为空，或当前操作符优先级比栈顶操作符元素的优先级高，或遇到(，弹栈后，将当前操作符压栈，即，该操作符入栈前，一定要保证所有优先级大于等于该操作符(实际等于时，先出现的优先级也要更高，要先计算)的操作符，都要先输出到后缀表达式结果datas中while (!op_stack.empty() && (op_stack.top() == '+' || op_stack.top() == '-')) {// 这里如果遇到(就不要再弹了，说明这些都是在一组()内处理的部分char op = op_stack.top();op_stack.pop();datas.emplace_back(false, 0, op);}// 将当前操作符压栈op_stack.emplace(c);}}}}if (has_number) {// 如果原中缀表达式最后一个字符不是)，则最后一个数字还没有输出到后缀表达式结果datas中datas.emplace_back(true, cur_number, '\0');}while (!op_stack.empty()) {// 将栈中剩余操作符依次弹栈到后缀表达式结果datas中char op = op_stack.top();op_stack.pop();datas.emplace_back(false, 0, op);}// 计算后缀表达式// 此时后缀表达式结果datas中，只包括数字、+、-，不会再存在括号// 存储操作数num的栈std::stack<long long> num_stack;for (const Data& data : datas) {if (data.is_number) {// 如果是数字，就压栈num_stack.emplace(data.number);} else {// 如果是操作符，就进行相应计算// 先弹栈的是右操作数，后弹栈的是左操作数long long a = num_stack.top();num_stack.pop();long long b = num_stack.top();num_stack.pop();if (data.op == '+') {num_stack.emplace(b + a);} else if (data.op == '-') {num_stack.emplace(b - a);}}}return num_stack.top();}
};

快速排序

、定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）

就是说如果基值是左边第一个，最后就要用右指针；是右边第一个，就用左指针为最后的

//快速排序   hoare版本(左右指针法)
void QuickSort(int* arr, int begin, int end)
{//只有一个数或区间不存在if (begin >= end)return;int left = begin;int right = end;//选左边为keyint keyi = begin;while (begin < end){//右边选小   等号防止和key值相等    防止顺序begin和end越界while (arr[end] >= arr[keyi] && begin < end){--end;}//左边选大while (arr[begin] <= arr[keyi] && begin < end){++begin;}//小的换到右边，大的换到左边swap(&arr[begin], &arr[end]);}swap(&arr[keyi], &arr[end]);keyi = end;//[left,keyi-1]keyi[keyi+1,right]QuickSort(arr, left, keyi - 1);QuickSort(arr,keyi + 1,right);
}

#include<iostream>
using namespace std;
const int maxn = 1e5 + 5;
int n, arr[maxn];
void swap(int i, int j) {int temp = arr[j];arr[j] = arr[i];arr[i] = temp;
}
void quick(int begin, int end) {if (begin >= end)return;int i = begin, j = end, key = arr[begin];while (i!=j) {while (i != j && arr[j] >= key) {j--;}while (i != j && arr[i] <= key) {i++;//必须得带上等号，不然的话，如果有重复元素在这里，那么左右都不会动，就形成了死循环}if(i!=j)swap(i, j);}swap(begin, j);quick(begin, j - 1);quick(j + 1, end);
}
int main() {cin >> n;for (int i = 1; i <= n; i++) {cin >> arr[i];}quick(1, n);for (int i = 1; i <= n; i++) {cout << arr[i] << " ";}return 0;
}

就是注意，快排一定一定一定一定要带上=号，不带等于快排一定会出错

PPT

C生成树有N-1条边，再加上任意一条边后就一定会产生回路

C在回路上删去任意一条边都会使其再变回生成树

P可以接受图中有负边

只有可以缩短距离才会入队，然后dis数组始终保存的是当下距离最短的路径长度

ACD对。对于B,如果第一次入队的时候就是最小的距离，那么后续的所有入度都不会再入队

ABD

首先要访问根节点才能去访问子节点，所以是先序遍历，以及层序遍历AD

C也可以

因为后序颠倒的话，是根右左，同样满足是先访问父节点，再访问子节点的，所以可以满足是拓扑排序

对于B，对于结点1，在下一层时不是第一个被访问到的，因为6不连接1，下一层的第一个应该是3，然后才是1

ABD

对于能够一笔画的图，应该满足：
1.图连通，有且只有两个奇点（度为奇数的点），则存在欧拉路（不一定回到原点）。
2.图连通，且没有奇点，则存在欧拉回路（回原点）。

ACBD点都是度为奇数的结点，添一条边可以使两个结点的度增加1，所以加一条边后可以形成欧拉路，再加一条变可以构成欧拉回路

C，如果要是邻居，那么必定可以到达

D，边数最大的话，是每个结点都和其它N-1个结点有一条边，那么共有N(N-1)，这里是有向图，所以不用除以2，如果是无向图的话，就要除以2；然后最小的话，由于是强连通图，所以最少就是一个环，共N条边；N-1条边可以构成一个树，树再加任意一边可构成回路

AD，对于E，删除一个结点，要遍历这个结点所有的边，所以不是O1

ABC ，对于B的，添加的话是O1复杂度，删除的话是ON，计算出度是ON,计算入度的话，就需要遍历所有的结点，是一个OEV的复杂度

对于查找成功的，就是从指数位置到存储位置的区间里的元素个数（不是步长），

对于查找失败的，是从指数位置到空端点的元素个数，包含空端点

平均查找成功，就是计算出哈希值后到存储位置的元素个数，要除以存储元素个数

平均失败，是是每个哈希值到失败，第一个空端点的元素个数，要除以所有可能哈希值的总数

#include<iostream>
using namespace std;
int n, m, p, arr[10000], num, ts = 0, tf = 0;
int main() {cin >> n >> m >> p;for (int i = 1; i <= n; i++) {cin >> num;int index = num % p, cnt = 1;while (arr[index]&&arr[index]!=num) {index = (index + 1) % m;cnt++;}arr[index] = num;ts += cnt;}cout << ts << "/" << n;for (int i = 0; i < p; i++) {int cnt = 1, index = i;while (arr[index]) {index = (index + 1) % m;cnt++;}tf += cnt;}cout << tf << "/" << p;return 0;
}