广义表
广义表相关概念：
◆ a1(表中第一个元素)称为表头；
◆ 其余元素组成的子表称为表尾；(a2，a3，…，an)
◆ 广义表中所包含的元素(包括原子和子表)的个数称为表的长度。
◆ 广义表中括号的最大层数称为表深 (度)。
根据对表头、表尾的定义，任何一个非空广义表的表头可以是原子，也可以是子表， 而表尾必定是广义表。
只要广义表非空，都是由表头和表尾组成，即一个确定的表头和表尾就唯一确定一个广义表。
广义表数据结点定义：
typedef struct GLNode
{
int tag ; /* 标志域，为1：表结点;为0 ：原子结点 */
union
{ elemtype value; /* 原子结点的值域 */
struct
{ struct GLNode *hp , *tp ;
}ptr ; /* ptr和atom两成员共用 */
}Gdata ;
} GLNode ; /* 广义表结点类型 */
二叉树
满二叉树(Full Binary Tree)
一棵深度为k且有2^k-1个结点的二叉树称为满二叉树。
完全二叉树(Complete Binary Tree)
如果深度为k，由n个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应，该二叉树称为完全二叉树。
完全二叉树是满二叉树的一部分，而满二叉树是完全二叉树的特例。
####遍历
- 前序非递归遍历
思路：
1).访问当前结点，用栈暂存当前结点的右结点【如果不为空】；
2).如果当前结点的左结点不为空，则进入继续访问，否则从栈取结点访问，即返回1继续，如果栈为空则结束遍历；
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) return ans;
stack<TreeNode*> stk_tree;
while (1){
ans.push_back(root->val);
if (root->right) stk_tree.push(root->right);
if (root->left) root = root->left;
else if (stk_tree.empty()) break;
else {
root = stk_tree.top(); stk_tree.pop();
}
}
return ans;
}- 中序非递归遍历
思路：
1).若p不为空，p进栈，p=p->Lchild;
2).否则(即p为空)，退栈到p，访问p所指向的结点;【栈为空则结束】
3).如果p的右结点不为空，p=p->Rchild ，转1;
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) return ans;
stack<TreeNode*> s;
while (root) {
s.push(root);
root = root->left;
}
while (!s.empty()) {
TreeNode * t = s.top();
s.pop();
ans.push_back(t->val);
if (t->right) {
t = t->right;
while (t){
s.push(t);
t = t->left;
}
}
}
return ans;
}- 后序非递归遍历
思路：
这里使用flag的栈对应表示结点属性，如果flag=1表示结点为父节点，进栈后再次出栈时可以直接访问；而如果flag=0表示该节点是右子节点，需要将该节点的子节点入栈，同时它本身的flag变为1.
1).若p不为空，p进栈【flag=1】，同时如果p的右结点不为空，右结点进栈【flag=0】，进入p=p->left；
2).从栈中取值，如果flag=1，说明该节点的子节点已经访问结束，该节点可以访问；否则进入1继续。【栈为空结束】
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root) return ans;
stack<TreeNode*> stk_tree;
stack<int> stk_flag;
while (root){
stk_tree.push(root);
stk_flag.push(1);
if (root->right) {
stk_tree.push(root->right); stk_flag.push(0);
}
root = root->left;
}
while (!stk_tree.empty()) {
root = stk_tree.top(); stk_tree.pop();
flag = stk_flag.top(); stk_flag.pop();
if (!flag) {
while (root){
stk_tree.push(root);
stk_flag.push(1);
if (root->right) {
stk_tree.push(root->right); stk_flag.push(0);
}
root = root->left;
}
}
else {
ans.push_back(root->val);
}
}
return ans;
}图
在一条路径中，若没有重复相同的顶点，该路径称为简单路径；
第一个顶点和最后一个顶点相同的路径称为回路(环)；
对无向图G=(V，E)，若任意vi，vj∈V，vi和vj都是连通的，则称图G是连通图，否则称为非连通图。若G是非连通图，则极大的连通子图称为G的连通分量；
对有向图G=(V，E)，若任意vi，vj∈V，都有以vi为起点， vj 为终点以及以vj为起点，vi为终点的有向路径，称图G是强连通图，否则称为非强连通图。若G是非强连通图，则极大的强连通子图称为G的强连通分量。
最小生成树
- 普里姆(Prim)算法
算法思想(算法复杂度O(n^2))：
1). 若从顶点v0出发构造，U={v0}，TE={}；
2). 先找权值最小的边(u，v)，其中u∈U且v∈V-U，并且子图不构成环，则U= U∪{v}，TE=TE∪{(u，v)} ；
3). 重复⑵ ，直到U=V为止。则TE中必有n-1条边， T=(U，TE)就是最小生成树。
定义一维数组保存V-U中各顶点到U中顶点具有权值最小的边【lowcost】：如果lowcost为0表示已加入到U中，否则每轮都要V-U中更新各顶点的lowcost
struct {
int adjvex; /* 边所依附于U中的顶点 */
int lowcost; /* 该边的权值 */
}closedge[N];#include <stdio.h>
#include <string.h>
#define N 1002
#define INFINITY 10005;
struct {
int adjvex; /* 边所依附于U中的顶点 */
int lowcost; /* 该边的权值 */
}closedge[N];
int array[N][N];
int prim(int n){
int i, j, min, v, ans = 0, idx;
//初始化数组【默认从v0开始】
for (i = 0; i < n; i++) {
closedge[i].adjvex = 0;
closedge[i].lowcost = array[i][0];
}
//n-1趟
for (j = 0; j < n - 1; j++) {
min = INFINITY;
//找到到U的最小权值的顶点
for (v = 0; v < n; v++) {
if (closedge[v].lowcost != 0 && closedge[v].lowcost < min) {
min = closedge[v].lowcost;
idx = v;
}
}
ans += min;
closedge[idx].lowcost = 0;//将该顶点加入U中
for (v = 0; v<n; v++)
if (array[v][idx]<closedge[v].lowcost) {
closedge[v].lowcost = array[v][idx];
closedge[v].adjvex = idx;
} /* 修改数组closedge[n]的各个元素的值 */
}
return ans;
}
int main()
{
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
scanf("%d", &array[i][j]);
printf("%d\n", prim(n));
return 0;
}注：prim算法稍加修改即可变为Dijkstra算法。【lowcost表示到各个顶点到给定单点的最短距离。】
- 克鲁斯卡尔(Kruskal)算法
思想：
设G=(V, E)是具有n个顶点的连通网，T=(U, TE)是其最小生成树。初值：U=V，TE={} 。c
对G中的边按权值大小从小到大依次选取。
1). 选取权值最小的边(vi，vj)，若边(vi，vj)加入到TE后形成回路，则舍弃该边(边(vi，vj) ；否则，将该边并入到TE中，即TE=TE∪{(vi，vj)} 。
2). 重复1)，直到TE中包含有n-1条边为止。
先将所有边排序，然后遍历判定是否边的两个顶点是否在一个集合，如果在则会形成回路，舍弃之；否则将改边加入TE。【判定两个点是否在一个集合用并查集算法】
#include<iostream>
#include<algorithm>
using namespace std;
struct edge{
int u;
int v;
int len;
};
int cmp(const edge a, const edge b) {
return a.len < b.len;
}
#define M 1000005
#define N 100005
edge e[M];
int pos[N]; //记录各个节点在哪个集合中。
void init(int n) {
for (int i = 1; i <= n; i++) pos[i] = i;
}
int find(int x) {
if (x == pos[x]) return x;
else {
pos[x] = find(pos[x]);
return pos[x];
}
}
int kruskal(int n, int m) {
int sum = 0,count = 1;
for (int i = 0; i < m; i++) {
int fx = find(e[i].u);
int fy = find(e[i].v);
if (fx != fy) {
sum += e[i].len;
count++;
if (count == n) break;
pos[fx] = fy;
}
}
return sum;
}
int main() {
int n, m;
while (cin >> n >> m) {
init(n); //初始化并查集
for (int i = 0; i < m; i++) cin >> e[i].u >> e[i].v >> e[i].len;
sort(e, e + m, cmp);
cout << kruskal(n, m) << endl;
}
}版权声明：本文为博主原创文章，未经博主允许不得转载。