二叉树

简单总结一下，树的一些操作

一：树的遍历

1、前序遍历：访问该节点，然后访问该节点的左子树和右子数

代码：

递归实现：

void preOrder(link h, void (*visit)(link))
{
    if(h == NULL)
        return;
    (*visit)(h);
    preOrder(h->left,visit);
    preOrder(h->right,visit);
}

非递归实现：

void preOrder(link h, void (*visit)(link))
{
    stack<int> s(max);
    s.push(h);
    while(!s.empty())
    {
        (*visit)(s.top());
        s.pop();
        if(h->r != NULL) s.push_back(h->r);
        if(h->l != NULL) s.push_back(h->l);
    }
}

2、中序遍历：先访问该节点的左子树，再访问该节点，最后访问该节点的右子树

代码：

递归实现

void inOrder(link h, void (*visit)(link))
{
    if(h == NULL)
        return;
    
    inOrder(h->l, visit);
    (*visit)(h);
    inOrder(h->r, visit);
}

3、后序遍历：先访问节点的左子树，再访问节点的右子树，最后访问该节点

代码：

void postOrder(link h, void (*visit)(link))
{
    if(h == NULL)
        return;
    postOrder(h->l, visit);
    postOrder(h->r, visit);
    (*visit)(h);
}

4、层序遍历:一层一层访问节点，从上到下，从左到右

代码：

void level(link h, void (*visit)(link))
{
    queue<int> q(max);
    queue.push(h);
    while(!q.empty())
    {
        (*visit)(q.top());
        q.pop();
        if(h->l != NULL) q.push(h->l);
        if(h->r != NULL) q.push(h->r);
    }
}

二：二叉树的几个应用

1、由前序和中序、后序构建二叉树

前序和中序可以唯一确定二叉树、后序和中序也可以唯一确定二叉树、前序和后序不能唯一确定一颗二叉树

由前序和中序构建二叉树

代码：

#define maxN 1000
int mapIndex[maxN];
void mapToIndex(int inorder[], int n)
{
    for (int i=0; i<n; i++)
    {
        mapIndex[inorder[i]] = i;                                   //中序排列中，节点的位置
    }
}

binarynode* buildInorderPreorder(int pre[], int n, int begin)      //pre为前序数组中子数开始的起始指针，n 为节点数，begin为子树开始位置，初始为0;
{
    if (n == 0)
        return NULL;
    int rootVal = pre[0];
    int i = mapIndex[rootVal] - begin;                              //节点个数
    binarynode* root = newNode(rootVal);
    root->left = buildInorderPreorder(pre+1, i, begin);
    root->right = buildInorderPreorder(pre+i+1, n-i-1, begin+i+1);
    
    return root;
}

后序和中序

binarynode *buildInorderPostorder(int post[], int n, int begin)
{
    if (n == 0) 
        return NULL;
    int rootVal = post[n-1];
    int i = mapIndex[rootVal]-begin;
    binarynode *root = newNode(rootVal);
    root->left = buildInorderPostorder(post, i, begin);
    root->right = buildInorderPostorder(post+i, n-i-1, begin+i+1);
  
    return root;
}

2、二叉搜索树

binary serch tree,BST：他的每一个节点关键字具有以下性质：任意节点关键字都大于（或等于）该节点的左子树中所有节点的关键字，小于（或）等于该节点右子树所有关键字

二叉搜索树一些常用操作

代码：

typedef struct STnode* link;
struct STnode
{
    int item;
    link l,r;
    int N;                //节点个数
}
static link head, z;
link NEW(int item, link l, link r, int N)
{
    link x = new(sizeof *x);
    x->item = item;
    x->l = l;
    x->r = r;
    x->N = N;
    return x;
}

void STinit()
{
    head = (z = NEW(NULLitem, 0, 0, 0));
}

int STcount()
{
    return head->N;
}

int searchR(link h, int v)
{
    int t = h->item;
    if(h == z)
        return NULLitem;
    if(v == t)
        return h->item;
    if(v < t)
        return searchR(h->l,v);
    else
        return searchR(h->r,v);
}

int STsearch(int v)
{
    return searchR(head,v);
} 

link insertR(link h, int v)
{
    if(h == z)
        return NEW(item,z,z,1);
    if(v < h->item)
        h->l = insertR(h->l,v)
    else
        h->r = insertR(h->r,v);
    (h->N)++;
    return h;
}

void STinsert(int item)
{
    head = insertR(head,item);
}