文章目录

• 一、二叉树遍历
• 二、给定二叉树先序遍历序列和中序遍历序列，重建二叉树（重点）
• 三、静态二叉链表
• 四、树的遍历

一、二叉树遍历

递归实现二叉树遍历还是比较容易的…

通过遍历序列确定一棵树必须要知道中序遍历序列，因为通过先序遍历序列和后序遍历序列都只能得到根结点，而只有通过中序遍历序列才能利用根结点把左右子树分开，从而递归生成一棵二叉树。

层序遍历和BFS的思想是一样的

void preOrder(Bintree root)
{
    if(root)
    {
        printf("%d",root->data); //访问
        preOrder(root->left);
        preOrder(root->right);
    }
}

void postOrder(Bintree root)
{
    if(root)
    {
        postOrder(root->left);
        postOrder(root->right);
        printf("%d",root->data); //访问
    }
}

void LayerOrder(Bintree root)
{
    queue<Bintree> q;
    root->layer=1;
    q.push(root);

    while(!q.empty())
    {
        Bintree t=q.front();
        q.pop();
        printf("%d",t->data);
        if(t->left)
        {
             t->left->layer=t->layer+1;
             q.push(t->left);

        }
        if(t->right) 
        {
            t->right->layer=t->layer+1;
            q.push(t->right);
        }
    }


}

二、给定二叉树先序遍历序列和中序遍历序列，重建二叉树（重点）

const int maxn=100;
//typename pre[maxn];
int pre[maxn];
int in[maxn];

Bintree create(int preL,int preR,int inL,int inR)
{
    if(preL>preR) return NULL;
    Bintree root=(Bintree)malloc(sizeof(struct TNode));
    root->data=pre[preL];
    int k;
    for(k=inL;k<=inR;k++)
    {
        if(pre[preL]==in[k]) break;
    }
    int numLeft=k-inL;

    root->left=create(preL+1,preL+numLeft,inL,k-1);
    root->right=create(preL+numLeft+1,preR,k+1,inR);

    return root;

}

三、静态二叉链表

#include<bits/stdc++.h>
using namespace std;
const int maxn=100;
struct Node
{
    int data;
    int left;
    int right;
}node[maxn];

int index=0;
int newNode(int v)
{
    node[index].data=v;
    node[index].left=-1;
    node[index].right=-1;
    return index++;
}

void find(int root,int x,int newdata)
{
    if(root==-1) return;
    else if(node[root].data==x)
    {
        node[root].data=newdata;

        
    }
    find(node[root].left,x,newdata);
    find(node[root].right,x,newdata);

}

void insert(int &root,int x)
{
    if(root==-1)
    {
        root=newNode(x);
    }
//插入左子树中
    insert(node[root].left,x);
//插入右子树中
    insert(node[root].right,x);
}

int create(int data[],int n)
{
    int i;
    int root=-1;
    for(i=0;i<n;i++)
    {
        insert(root,data[i]);
    }
    return root;


}

四、树的遍历

#include<bits/stdc++.h>
const int maxn=100;
using namespace std;
struct Node
{
    int data;
    vector<int> child;

}node[maxn];

int index=0;

int newNode(int v)
{
    node[index].data=v;
    node[index].child.clear();
    return index++;
}

void preOrder(int root)
{
    printf("%d",node[root].data);
    for(int i=0;i<node[root].child.size();i++)
    {
        preOrder(node[root].child[i]);
    }
}