左子右兄弟法:
#include<iostream>
#include<stdio.h>
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+10;
#define NIL -1
struct node
{
int p , l , r;
}T[N];
int n , D[N];
void print(int u)
{
int i , c;
cout << "node" << u << ":";
cout << "parent = " << T[u].p << ",";
cout << "depth = " << D[u] << ",";
if(T[u].p==NIL)
cout << "root, ";
else if(T[u].l==NIL)
cout << "leaf,";
else cout << "internal node, ";
cout << "[";
for(i = 0 , c = T[u].l;c!=NIL;i++,c=T[c].r)
{
if(i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
int rec(int u , int p)
{
D[u] = p;
if(T[u].r!=NIL)
rec(T[u].r,p);
if(T[u].l!=NIL)
rec(T[u].l,p+1);
}
int main()
{
int i , j , d , v , c , l , r;
cin >> n;
for(i = 0 ; i < n ; i++)
{
T[i].p = T[i].l = T[i].r = NIL;
}
for(i = 0 ; i < n ; i++)
{
cin >> v >> d;
for(j = 0 ; j < d ; j++)
{
cin >> c;
if(j==0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for(i = 0 ; i < n ; i++)
{
if(T[i].p == NIL)
r = i;
}
rec(r,0);
for(i = 0 ; i < n ; i++)
print(i);
return 0;
}
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define MAX 100005
#define NIL -1
struct node
{
int parent , left , right;
}T[MAX];
int n , D[MAX] , H[MAX];
void setDepth(int u , int d)
{
if(u == NIL)
return;
D[u] = d;
setDepth(T[u].left , d+1);
setDepth(T[u].right , d+1);
}
int setHeight(int u)
{
int h1 = 0;
int h2 = 0;
if(T[u].left!=NIL)
h1 = setHeight(T[u].left)+1;
if(T[u].right!=NIL)
h2 = setHeight(T[u].right)+1;
return H[u] = (h1 > h2 ? h1 : h2);
}
//返回结点u的兄弟节点
int getSibling(int u)
{
if(T[u].parent == NIL)
return NIL;
if(T[T[u].parent].left != u &&T[T[u].parent].left != NIL)
return T[T[u].parent].left;
if(T[T[u].parent].right != u && T[T[u].parent].right != NIL)
return T[T[u].parent].right;
return NIL;
}
void print(int u)
{
printf("node %d: ",u);
printf("parent = %d, ",T[u].parent);
printf("sibling = %d, ",getSibling(u));
int deg = 0;
if(T[u].left != NIL) deg++;
if(T[u].right != NIL) deg++;
printf("degree = %d, ",deg);
printf("depth = %d, ",D[u]);
printf("height = %d, ",H[u]);
if(T[u].parent == NIL)
{
printf("root\n");
}
else if(T[u].left == NIL&&T[u].right == NIL)
{
printf("leaf\n");
}
else
{
printf("internal node\n");
}
}
int main()
{
int v , l , r , root = 0;
scanf("%d",&n);
for(int i = 0 ; i < n ; i++)
{
T[i].parent = NIL;
}
for(int i = 0 ; i < n ; i++)
{
cin >> v >> l >> r;
T[v].left = l;
T[v].right = r;
if(l != NIL) T[l].parent = v;
if(r != NIL) T[r].parent = v;
}
for(int i = 0 ; i < n ; i++)
{
if(T[i].parent == NIL)
root = i;
}
setDepth(root , 0);
setHeight(root);
for(int i = 0 ; i < n ; i++)
print(i);
return 0;
}
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define MAX 10000
#define NIL -1
struct node
{
int p , l , r;
}T[MAX];
int n;
//前序遍历
void preParse(int u )
{
if(u == NIL)
return;
printf(" %d",u);
preParse(T[u].l);
preParse(T[u].r);
}
//中序遍历
void inParse(int u)
{
if(u == NIL)
return;
inParse(T[u].l);
printf(" %d",u);
inParse(T[u].r);
}
//后序遍历
void postParse(int u)
{
if(u == NIL)
return;
postParse(T[u].l);
postParse(T[u].r);
printf(" %d",u);
}
int main()
{
int i , v , l , r , root;
cin >> n;
for(i = 0 ; i < n ; i++)
{
T[i].p = NIL;
}
for(i = 0 ; i <n ; i++)
{
cin >> v >> l >> r;
T[v].l = l;
T[v].r = r;
if(l !=NIL)
T[l].p = v;
if(r != NIL)
T[r].p = v;
}
for(i = 0 ; i < n ; i++)
if(T[i].p == NIL)
root = i;
printf("Preorder\n");
preParse(root);
cout << endl;
printf("Inorder\n");
inParse(root);
cout << endl;
printf("Postorder\n");
postParse(root);
cout << endl;
return 0;
}
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
int n , pos;
vector<int> pre , in ,post;
void rec(int l , int r)
{
if(l >= r)
return;
int root = pre[pos++];
int m = distance(in.begin() , find(in.begin(),in.end(),root));
rec(l , m);
rec(m+1, r);
post.push_back(root);
}
void solve()
{
pos = 0;
rec(0 , pre.size());
for(int i = 0 ; i < n ; i++)
{
if(i)
cout << " ";
cout << post[i];
}
cout << endl;
}
int main()
{
int k;
cin >> n;
for(int i = 0 ; i < n ; i++)
{
cin >> k;
pre.push_back(k);
}
for(int i = 0 ; i < n ; i++)
{
cin >> k;
in.push_back(k);
}
solve();
return 0;
}