有关二叉树的一系列操作

二叉树一些基本操作

#include <stdio.h>
#include <stdlib.h>
#include <bits/stdc++.h>
#include <string.h>

using namespace std;

struct treenode {
    char ch;
    treenode *ltreenode, *rtreenode;
};

char str[60];
int i;

treenode *build_tree();
treenode *build_preorder_tree();
void print_inorder_tree(treenode *root);
void print_postorder_tree(treenode *root);

int main() {
    while(cin >> str) {
        i = 0;
        treenode *root = build_preorder_tree();
        print_inorder_tree(root);
        printf("\n");
        print_postorder_tree(root);
        printf("\n");
    }

    return 0;
}

void print_postorder_tree(treenode *root) {
    if(root == NULL) {
        return;
    }
    print_postorder_tree(root->ltreenode);
    print_postorder_tree(root->rtreenode);
    printf("%c", root->ch);
}

void print_inorder_tree(treenode *root) {
    if(root == NULL) {
        return;
    }
    print_inorder_tree(root->ltreenode);
    printf("%c", root->ch);
    print_inorder_tree(root->rtreenode);
}

treenode *build_preorder_tree() {
    if(str[i] == ',') {
        i++;
        return NULL;
    }
    treenode *p = build_tree();
    p->ch = str[i++];
    p->ltreenode = build_preorder_tree();
    p->rtreenode = build_preorder_tree();
    return p;
}

treenode *build_tree() {
    treenode *root = (treenode *)malloc(sizeof(treenode));
    root->ltreenode = NULL;
    root->rtreenode = NULL;
    return root;
}

给出先序中序还原后续

#include <stdio.h>
#include <stdlib.h>
#include <bits/stdc++.h>
#include <string.h>

using namespace std;

struct treenode {
    char ch;
    treenode *ltreenode, *rtreenode;
}*root;

char str1[1000], str2[1000];

void print_postorder_tree(int l1, int r1, int l2, int r2);

int main() {
    cin >> str1 >> str2;
    int len = strlen(str1);
    print_postorder_tree(0, len-1, 0, len-1);
    return 0;
}

void print_postorder_tree(int l1, int r1, int l2, int r2) {
    if(l1 > r1 || l2 > r2) {
        return;
    }
    int pos = l2;
    while(str2[pos] != str1[l1]) {
        pos++;
    }
    print_postorder_tree(l1+1, l1+(pos-l2), l2, pos-1);
    print_postorder_tree(l1+(pos-l2)+1, r1, pos+1, r2);
    printf("%c", str2[pos]);
}

/***
treenode *build_postorder_tree(int l1, int r1, int l2, int r2);
treenode *build_tree();
void print_Postorder_tree(treenode *root);

int main() {
    cin >> str1 >> str2;
    int len = strlen(str1);
    root = build_postorder_tree(0, len-1, 0, len-1);
    print_Postorder_tree(root);
    return 0;
}

void print_Postorder_tree(treenode *root) {
    if(root == NULL) {
        return;
    }
    print_Postorder_tree(root->ltreenode);
    print_Postorder_tree(root->rtreenode);
    printf("%c", root->ch);
}

treenode *build_postorder_tree(int l1, int r1, int l2, int r2) {
    if(l1 > r1 || l2 > r2) {
        return NULL;
    }
    int pos = l2;
    while(str2[pos] != str1[l1]) {
        pos++;
    }
    treenode *root = build_tree();
    root->ch = str2[pos];
    root->ltreenode = build_postorder_tree(l1+1, l1+(pos-l2), l2, pos);
    root->rtreenode = build_postorder_tree(l1+(pos-l2)+1, r1, pos+1, r2);
    return root;
}

treenode *build_tree() {
    treenode *root = (treenode *)malloc(sizeof(treenode));
    root->ltreenode = root->rtreenode = NULL;
    return root;
}
***/

层序遍历

#include <stdio.h>
#include <stdlib.h>

struct treenode
{
    char data;
    struct treenode *ltreenode;
    struct treenode *rtreenode;
};

struct treenode *build_preorder_tree();

void print_level_tree(struct treenode *root);

char str[100];
struct treenode *que[100];
int i, head, tail;

int main()
{
    int t;
    scanf("%d", &t);
    getchar();
    while(t--)
    {
        i = 0, head = 0, tail = 0;
        scanf("%s", str);
        struct treenode *root = build_preorder_tree();
        print_level_tree(root);
        printf("\n");
    }

    return 0;
}

void print_level_tree(struct treenode *root)
{
    if(root == NULL)
        return;
    que[tail++] = root;
    while(head < tail)
    {
        if(que[head]->ltreenode)
            que[tail++] = que[head]->ltreenode;
        if(que[head]->rtreenode)
            que[tail++] = que[head]->rtreenode;
        printf("%c", que[head++]->data);
    }
}

struct treenode *build_preorder_tree()
{
    if(str[i] == ',')
    {
        i++;
        return NULL;
    }
    struct treenode *p = (struct treenode *)malloc(sizeof(struct treenode));
    p->data = str[i++];
    p->ltreenode = build_preorder_tree();
    p->rtreenode = build_preorder_tree();
    return p;
}

给先序中序还原后续并且输出树高

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct treenode
{
    char data;
    int dp;
    struct treenode *ltreenode;
    struct treenode *rtreenode;
};

struct treenode *build_postorder_tree(int l1, int r1, int l2, int r2);
int Max_dp(struct treenode *p, struct treenode *q);

char str1[100], str2[100];

int main()
{
    int N;
    while(~scanf("%d", &N))
    {
        getchar();
        scanf("%s%s", str1, str2);
        struct treenode *root = build_postorder_tree(0, N-1, 0, N-1);
        printf("%d\n", root->dp);
        free(root);
    }

    return 0;
}
int Max_dp(struct treenode *p, struct treenode *q)
{
    int m;
    if(p && q)
    {
        if(p->dp > q->dp)
            m = p->dp + 1;
        else
            m = q->dp + 1;
    }
    else if(p == NULL && q == NULL)
    {
        m = 1;
    }
    else
    {
        if(p == NULL)
            m = q->dp + 1;
        else
            m = p->dp + 1;
    }
    return m;
}
struct treenode *build_postorder_tree(int l1, int r1, int l2, int r2)
{
    if(l1 > r1 || l2 > r2)
    {
        return NULL;
    }
    int key = l2;
    while(str2[key] != str1[l1])
        key++;
    struct treenode *p = (struct treenode *)malloc(sizeof(struct treenode));
    p->ltreenode = build_postorder_tree(l1+1, l1+key-l2, l2, key-1);
    p->rtreenode = build_postorder_tree(l1+key-l2+1, r1, key+1, r2);
    p->data = str2[key];
    p->dp = Max_dp(p->ltreenode, p->rtreenode);
    free(p->ltreenode);
    free(p->rtreenode);

    return p;
}