根据输入序列建立二叉树
链表
回顾一下二分面积最小
一些性质题回顾
哈夫曼树构建
第十一周——哈夫曼树
5
1 2 2 5 9
37
桶排序
#include <iostream>
#include <vector>
#include <algorithm>
#include<stack>
#include<queue>
#include <unordered_set>
#include<string>
using namespace std;
//const int N = 10000;
//int arr[N];
//int search(int begin, int end, int target) {
// if (begin > end) { return -1; }
// int left = begin, right = end, mid = (left + right) >> 1;
// while (left <= right) {
// if (arr[mid] == target) {
// return mid;
// }
// else if (arr[mid] < target) {
// right = mid - 1;
// }
// else {
// left = mid + 1;
// }
// mid = (left + right) >> 1;
// }
// return 0;
//}
//typedef struct node {
// int data;
// node* lchild, * rchild;
//}*tree;
//int high(tree root) {
// if (root) {
// return max(high(root->lchild), high(root->rchild)) + 1;
// }
// return 0;
//}
//int arr[100];
//int siz = 0;
//void shiftup(int child) {
// int parent = (child - 1) / 2;
// while (child > 0) {
// if (arr[parent] >= arr[child]) {
// break;//判断顶堆，就从堆顶到叶子结点走，如果任意一条路是递增的，那么就是小顶堆；
// //如果任意一条路都是递减的，那么就是大顶堆。
// }//如果父母结点比孩子结点大，就停止调整，这里是向上调整，所以向上是更大的，也就是顶上是最大的，所以是大顶堆
// else {
// swap(arr[parent], arr[child]);
// child = parent;
// parent = (child - 1) / 2;
// }
// }
//}
//void insert(int num) {
// arr[siz++] = num;
// shiftup(siz - 1);
//}
//
//void shiftdown(int parent) {
// int child = parent * 2 + 1;
// while (child <= size - 1) {
// if (child + 1 <= size - 1 && arr[child + 1] > arr[child]) {
// child++;
// }
// if (arr[parent] > arr[child]) {
//
// }
// }
//}
//int popheal() {
// int num = arr[0];
// swap(arr[0], arr[size - 1]);
// size--;
// shiftdown(0);
// return num;
//}
//14 21 10 8 5 2
//12 10 8 7 6 3
//10 8 2 1 1 1
//const int N = 1e5 + 5;
//int arr[N];
//int n, m;
//bool check(int d) {
// int num = 1, target = a[0] + d;
// for (int i = 1; i < n; i++) {
// if (arr[i] < target) {
// continue;//这里不能放牛
// }
// num++;
// target = arr[i] + d;
// }
// if (num >= m) {
// return true;
// }
// else {
// return false;
// }
//}
//优先特点值小的那个，不能超过
//会产生不满意度
//目的是要输出不满意度
const int N = 10000 + 5, mod = 1e6;
typedef struct node {
int ch[2], id;
long long val;
}tree[N];
void rotate(int& cur, int f) {
int son = tree[cur].ch[f];
tree[cur].ch[f] = tree[son].ch[f ^ 1];
tree[son].ch[f ^ 1] = cur;
cur = son;
}
int tot;
void insert(int& cur, int val) {
if (!cur) {
cur = ++tot;
tree[cur].val = val;
tree[cur].id = rand();
return;
}
int d = val > tree[cur].val;
insert(tree[cur].ch[d], val);
if (tree[tree[cur].ch[d]].id < tree[cur].id) {
rotate(cur, d);
}
}
int ls = tree[cur].ch[0], rs = tree[cur].ch[1];
void del(int& cur, int val) {
if (!cur) { return; }
if (val == tree[cur].val) {
if (!tree[cur].ch[0] || !tree[cur].ch[1]) {
cur = tree[cur].ch[0] + tree[cur].ch[1];
return;
}
int d = tree[ls].id > tree[rs].val;
rotate(cur, d);
del(cur, val);
}
del(tree[cur].ch[val > tree[cur].val], val);
}
long long pred(int cur, int val) {
if (!cur) {
return 0;
}
if (val <= tree[cur].val) {
return pred(ls, val);
}
return max(tree[cur].val, pred(rs, val));
}
long long nex(int cur, int val) {
if (!cur) {
return 0;
}
if (val >= tree[cur].val) {
return nex(rs, val);
}
return min(tree[cur].val, nex(ls, val));
}
int s;
long long ans;
int main() {
int n, rt = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int bz, x;
cin >> bz >> x;
if (bz == 0) {
if (s <= 0) {
insert(rt, x);
}
else {
int k1 = pred(rt, x), k2 = nex(rt, x);
int dele = k1;
if (k2 - x < x - k1) {
dele = k2;
}
ans += abs(dele - x);
ans %= mod;
del(rt, dele);
}
s--;
}
else {
if (s >= 0) {
insert(rt, x);
}
else {
int k1 = pred(rt, x), k2 = nex(rt, x);
int dele = k1;
if (k2 - x < x - k1) {
dele = k2;
}
ans += abs(dele - x);
ans %= mod;
del(rt, dele);
}
s++;
}
}
cout << ans << endl;
return 0;
}
之前的数据结构
第一次实验——模拟队列
第一次实验——括弧匹配
第一次实验——胡同
第一次实验——列车重拍
第六周习题——字符串匹配
第六周习题——后缀表达式
第三周习题——顺序表删除
第三周习题——寻找链表前驱节点
数据结构性质
队列，计算空满
复习之前做过的题
第一次实验——倍数对
第六周习题——7-3
第二周习题——冰雹猜想
第一周习题——全排列
第一周习题——数雷，复习bfs
第二次实验——BFS
求叶子节点个数
new的时候这样即可，这里调用的就是结构体自身的构造函数；如果要传入值进行初始化，就需要重载一个带参的构造函数
递归建树的另一种写法
tree creat() {
char ch;
cin >> ch;
tree root = new node;
if (ch == '#') {
root = nullptr;
}
else {
root->data = ch;
root->lchild = creat();
root->rchild = creat();
}
return root;
}tree root = create();
总代码
typedef struct node {
char data;
node* lchild, * rchild;
//node(char x) :data(x), lchild(nullptr), rchild(nullptr) {}
//node() :data(), lchild(nullptr), rchild(nullptr) {}
}*tree;
tree creat() {
char ch;
cin >> ch;
tree root = new node;
if (ch == '#') {
root = nullptr;
}
else {
root->data = ch;
root->lchild = creat();
root->rchild = creat();
}
return root;
}
int cntleaf(tree root) {//这里就直接传入tree,就表明是node的指针型
if (root) {
if (root->lchild || root->rchild) {
return cntleaf(root->lchild) + cntleaf(root->rchild);
}
return 1;
}
return 0;
}
void pre(tree root) {
if (root) {
cout << root->data;
pre(root->lchild);
pre(root->rchild);
}
}
int main() {
tree root = create();
pre(root);
cout << endl;
cout << cntleaf(root);
return 0;
}求树的高度
int high(tree root) {
if (root) {
if (root->lchild || root->rchild) {
return 1 + max(high(root->lchild), high(root->rchild));
}
else {
return 1;
}
}
return 0;
}牛客网题复习
牛客网选择题
二叉树的一些定义，真、满、完全，还有一些计算公式
