二叉树的复制，线索二叉树，用树处理表达式

使用递归方式创建二叉树，然后备份原来的二叉树，最后将原来的二叉树和备份的二叉树都输出来

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

struct tree
{
    int data;
    struct tree* left;
    struct tree* right;
};

typedef struct tree treenode;
typedef treenode* btree;

btree createbtree(int* data,int pos)
{
    btree newnode;

    if(data[pos] == 0 || pos > 15)
        return NULL;
    else
    {
        newnode = (btree)malloc(sizeof(treenode));
        newnode->data = data[pos];

        newnode->left = createbtree(data,2*pos);
        newnode->right = createbtree(data,2*pos + 1);
        return newnode;
    }
}

btree copybtree(btree root)
{
    btree newnode;
    
    if(root == NULL)
        return NULL;
    else
    {
        newnode = (btree)malloc(sizeof(treenode));
        newnode->data = root->data;
        newnode->left = copybtree(root->left);
        newnode->right = copybtree(root->right);
        return newnode;
    }
}


void printbtree(btree ptr)
{
    if(ptr != NULL)
    {
        printbtree(ptr->left);
        printf("[%2d]",ptr->data);
        printbtree(ptr->right);
    }
}

int main()
{
    btree root = NULL;
    btree backup = NULL;

    int data[16] = {0,5,4,6,2,0,0,8,1,3,0,0,0,0,7,9};
    root = createbtree(data,1);
    backup = copybtree(root);
    printf("原二叉树的结点内容\n");
    printbtree(root);
    printf("\n备份二叉树的结点内容 \n");
    printbtree(backup);
    printf("\n");
    return 0;
}

 

 

使用数组值创建线索二叉树，然后使用中序遍历方式将二叉树的内容输出来

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

struct t_tree
{
    int data;
    int leftthread;
    int rightthread;
    struct t_tree* left;
    struct t_tree* right;
};

typedef struct t_tree treenode;
typedef treenode* t_btree;

t_btree insertnode(t_btree root,int value)
{
    t_btree newnode;
    t_btree current;
    t_btree parent;
    t_btree previous;
    int pos;
    
    newnode = (t_btree)malloc(sizeof(treenode));
    newnode->data = value;
    newnode->left = NULL;
    newnode->right = NULL;
    newnode->leftthread = 1;
    newnode->rightthread = 1;
    current = root->right;
    if(current == NULL)
    {
        root->right = newnode;
        newnode->left = root;
        newnode->right = root;
        return root;
    }
    parent = root;
    pos = 0;
    while(current != NULL)
    {
        if(current->data > value)
        {
            if(pos != -1)
            {
                pos = -1;
                previous = parent;
            }
            parent = current;
            if(current->leftthread == 0)
                current = current->left;
            else
                current = NULL;
        }
        else
        {
            if(pos != 1)
            {
                pos = 1;
                previous = parent;
            }
            parent = current;
            if(current->rightthread == 0)
                current = current->right;
            else
                current = NULL;
        }
    }
    if(parent->data > value)
    {
        parent->leftthread = 0;
        parent->left = newnode;
        newnode->left = previous;
        newnode->right = parent;
    }
    else
    {
        parent->rightthread = 0;
        parent->right = newnode;
        newnode->left = parent;
        newnode->right = previous;
    }
    return root;
}

t_btree createtbtree(int* data,int len)
{
    t_btree root = NULL;
    int i;
    
    root = (t_btree)malloc(sizeof(treenode));
    root->left = root;
    root->right = NULL;
    root->leftthread = 1;
    root->rightthread = 0;
    
    for(i = 0;i < len;i++)
        root = insertnode(root,data[i]);
    return root;
    
}

void printtbtree(t_btree root)
{
    t_btree ptr;
    
    ptr = root;
    do
    {
        if(ptr->rightthread == 1)
            ptr = ptr->right;
        else
        {
            ptr = ptr->right;
            while(ptr->leftthread != 1)
                ptr = ptr->left;
        }
        if(ptr != root)
            printf("[%d]\n",ptr->data);
    }while(ptr != root);
}


int main()
{
    t_btree root = NULL;
    
    int data[9] = {5,6,4,8,2,3,7,1,9};
    root = createtbtree(data,9);
    printf("线索二叉树的节点内容\n");
    printtbtree(root);
    return 0;
}

将前序的表达式二叉树存入数组，然后使用递归创建表达式二叉树，接着输出三种遍历的结果

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

struct tree
{
    char data;
    struct tree* left;
    struct tree* right;
};

typedef struct tree treenode;
typedef treenode* btree;

btree createbtree(int* data,int pos)
{
    btree newnode;
    
    if(data[pos] == 0 || pos > 7)
        return NULL;
    else
    {
        newnode = (btree)malloc(sizeof(treenode));
        newnode->data = data[pos];
        newnode->left = createbtree(data,2*pos);
        newnode->right = createbtree(data,2*pos + 1);
        return newnode;
    }
}

void inorder(btree ptr)
{
    if(ptr != NULL)
    {
        inorder(ptr->left);
        printf("%c",ptr->data);
        inorder(ptr->right);
    }
}

void preorder(btree ptr)
{
    if(ptr != NULL)
    {
        printf("%c",ptr->data);
        preorder(ptr->left);
        preorder(ptr->right);
    }
}

void postorder(btree ptr)
{
    if(ptr != NULL)
    {
        postorder(ptr->left);
        postorder(ptr->right);
        printf("%c",ptr->data);
    }
}

int getvalue(int op,int operand1,int operand2)
{
    switch((char) op)
    {
        case '*': return (operand2 * operand1);
        case '/': return (operand2 / operand2);
        case '+': return (operand2 + operand1);
        case '-': return (operand2 - operand2);
    }
}

int cal(btree ptr)
{
    int operand1 = 0;
    int operand2 = 0;
    
    if(ptr->left == NULL && ptr->right == NULL)
        return ptr->data - 48;
    {
        operand1 = cal(ptr->left);
        operand2 = cal(ptr->right);
        return getvalue(ptr->data,operand1,operand2);
    }
}

int main()
{
    btree root = NULL;
    int result;
    
    int data[8] = {' ','+','*','*','5','6','4','3'};
    root = createbtree(data,1);
    printf("中序表达式：");
    inorder(root);
    printf("\n前序表达式：");
    preorder(root);
    printf("\n后序表达式：");
    postorder(root);
    result = cal(root);
    printf("\n表达式结果是：%d\n",result);
    
    return 0;
}