6:1二叉树的构建与遍历

一、代码块

构造树结点

typedef struct BTNode{
    
    char element;
    BTNode* left;
    BTNode* right;
    
}BTNode, *BTNodePtr;

构造队列

typedef struct BTNodePtrQueue{
    
    BTNodePtr* nodePtrs;
    int front;
    int rear;
    
}BTNodePtrQueue, *QueuePtr;

初始化队列

QueuePtr initQueue(){
    
    QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
    resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
    resultQueuePtr->front = 0;
    resultQueuePtr->rear = 1;
    return resultQueuePtr;
    
}

判断队列是否为空

bool isQueueEmpty(QueuePtr paraQueuePtr){
    if((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear){
        //为空
        return true;
    }

    //非空
    return false;
}

入队

void enqueue(QueuePtr paraQueuePtr, BTNodePtr paraBTNodePtr){
    
    printf("front = %d, rear = %d.\r\n", paraQueuePtr->front, paraQueuePtr->rear);
    if ((paraQueuePtr->rear + 1) % QUEUE_SIZE == paraQueuePtr->front % QUEUE_SIZE){
        printf("Error, trying to enqueue %c. queue full.\r\n", paraBTNodePtr->element);
        return;
    }
    paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
    paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
    printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
    
}

出队

BTNodePtr dequeue(QueuePtr paraQueuePtr){
    
    if (isQueueEmpty(paraQueuePtr)){
        printf("Error, empty queue\r\n");
        return NULL;
    }

    paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
    //BTNodePtr tempPtr = paraQueuePtr->nodePtrs[paraQueuePtr->front + 1];

    printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
    return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}

创建树结点

BTNodePtr constructBTNode(char paraChar){
    BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
    resultPtr->element = paraChar;
    resultPtr->left = NULL;
    resultPtr->right = NULL;
    return resultPtr;
}

构造二叉树

BTNodePtr stringToBTree(char* paraString){
    
    int i;
    char ch;

    //用队列创建树结点
    QueuePtr tempQueuePtr = initQueue();

    BTNodePtr resultHeader;
    BTNodePtr tempParent, tempLeftChild, tempRightChild;
    i = 0;
    ch = paraString[i];
    resultHeader = constructBTNode(ch);
    enqueue(tempQueuePtr, resultHeader);

    while(!isQueueEmpty(tempQueuePtr)){
        //队头出
        tempParent = dequeue(tempQueuePtr);

        //左
        i++;
        ch = paraString[i];
        if(ch == '#'){
            tempParent->left = NULL;
        }else{
            tempLeftChild = constructBTNode(ch);
            enqueue(tempQueuePtr, tempLeftChild);
            tempParent->left = tempLeftChild;
        }

        
        //右
        i++;
        ch = paraString[i];
        if(ch == '#'){
            tempParent->right = NULL;
        }else{
            tempRightChild = constructBTNode(ch);
            enqueue(tempQueuePtr, tempRightChild);
            tempParent->right = tempRightChild;
        }
    }

    return resultHeader;
}

按层历遍

void levelwise(BTNodePtr paraTreePtr){
    
    char tempString[100];
    int i = 0;
    QueuePtr tempQueuePtr = initQueue();
    BTNodePtr tempNodePtr;
    enqueue(tempQueuePtr, paraTreePtr);
    while(!isQueueEmpty(tempQueuePtr)){
        tempNodePtr = dequeue(tempQueuePtr);
        
        tempString[i] = tempNodePtr->element;
        i++;

        if(tempNodePtr->left != NULL){
            enqueue(tempQueuePtr, tempNodePtr->left);
        }
        if(tempNodePtr->right != NULL){
            enqueue(tempQueuePtr, tempNodePtr->right);
        }
    }
    tempString[i] = '\0';

    printf("Levelwise: %s\r\n", tempString);
}

中左右历遍

void preorder(BTNodePtr tempPtr){
    if (tempPtr == NULL){
        return;
    }

    printf("%c", tempPtr->element);
    preorder(tempPtr->left);
    preorder(tempPtr->right);
}

左中右历遍

void inorder(BTNodePtr tempPtr){
    if(tempPtr == NULL){
        return;
    }

    inorder(tempPtr->left);
    printf("%c", tempPtr->element);
    inorder(tempPtr->right);
}

左右中历遍

void postorder(BTNodePtr tempPtr){
    if(tempPtr == NULL){
        return;
    }

    postorder(tempPtr->left);
    postorder(tempPtr->right);
    printf("%c", tempPtr->element);
}

---

二、部分代码及二叉树建立图示

BTNodePtr tempHeader = constructBTNode('c');

 二叉树建立

 

 

 

 

---

三、全部代码 

//
//  main.c
//
//  Created on 2022/5/23.
//


#include <stdio.h>
#include <malloc.h>

#define QUEUE_SIZE 5

//构造树结点
typedef struct BTNode{
    
    char element;
    BTNode* left;
    BTNode* right;
    
}BTNode, *BTNodePtr;

//构造队列
typedef struct BTNodePtrQueue{
    
    BTNodePtr* nodePtrs;
    int front;
    int rear;
    
}BTNodePtrQueue, *QueuePtr;

//初始化队列
QueuePtr initQueue(){
    
    QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
    resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
    resultQueuePtr->front = 0;
    resultQueuePtr->rear = 1;
    return resultQueuePtr;
    
}

//判断队列是否为空
bool isQueueEmpty(QueuePtr paraQueuePtr){
    if((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear){
        //为空
        return true;
    }

    //非空
    return false;
}

//入队
void enqueue(QueuePtr paraQueuePtr, BTNodePtr paraBTNodePtr){
    
    printf("front = %d, rear = %d.\r\n", paraQueuePtr->front, paraQueuePtr->rear);
    if((paraQueuePtr->rear + 1) % QUEUE_SIZE == paraQueuePtr->front % QUEUE_SIZE){
        printf("Error, trying to enqueue %c. queue full.\r\n", paraBTNodePtr->element);
        return;
    }
    paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
    paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
    printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
    
}

//出队
BTNodePtr dequeue(QueuePtr paraQueuePtr){
    
    if(isQueueEmpty(paraQueuePtr)){
        printf("Error, empty queue\r\n");
        return NULL;
    }

    paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
    //BTNodePtr tempPtr = paraQueuePtr->nodePtrs[paraQueuePtr->front + 1];

    printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
    return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}

//创建树结点
BTNodePtr constructBTNode(char paraChar){
    BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
    resultPtr->element = paraChar;
    resultPtr->left = NULL;
    resultPtr->right = NULL;
    return resultPtr;
}

//构造二叉树
BTNodePtr stringToBTree(char* paraString){
    
    int i;
    char ch;

    //用队列创建树结点
    QueuePtr tempQueuePtr = initQueue();

    BTNodePtr resultHeader;
    BTNodePtr tempParent, tempLeftChild, tempRightChild;
    i = 0;
    ch = paraString[i];
    resultHeader = constructBTNode(ch);
    enqueue(tempQueuePtr, resultHeader);

    while(!isQueueEmpty(tempQueuePtr)){
        //队头出
        tempParent = dequeue(tempQueuePtr);

        //左
        i++;
        ch = paraString[i];
        if(ch == '#'){
            tempParent->left = NULL;
        }else{
            tempLeftChild = constructBTNode(ch);
            enqueue(tempQueuePtr, tempLeftChild);
            tempParent->left = tempLeftChild;
        }

        
        //右
        i++;
        ch = paraString[i];
        if(ch == '#'){
            tempParent->right = NULL;
        }else{
            tempRightChild = constructBTNode(ch);
            enqueue(tempQueuePtr, tempRightChild);
            tempParent->right = tempRightChild;
        }
    }

    return resultHeader;
}

//按层历遍
void levelwise(BTNodePtr paraTreePtr){
    
    char tempString[100];
    int i = 0;
    QueuePtr tempQueuePtr = initQueue();
    BTNodePtr tempNodePtr;
    enqueue(tempQueuePtr, paraTreePtr);
    while(!isQueueEmpty(tempQueuePtr)){
        tempNodePtr = dequeue(tempQueuePtr);
        
        tempString[i] = tempNodePtr->element;
        i++;

        if(tempNodePtr->left != NULL){
            enqueue(tempQueuePtr, tempNodePtr->left);
        }
        if(tempNodePtr->right != NULL){
            enqueue(tempQueuePtr, tempNodePtr->right);
        }
    }
    tempString[i] = '\0';

    printf("Levelwise: %s\r\n", tempString);
}

//中左右历遍
void preorder(BTNodePtr tempPtr){
    if (tempPtr == NULL){
        return;
    }

    printf("%c", tempPtr->element);
    preorder(tempPtr->left);
    preorder(tempPtr->right);
}

//左中右历遍
void inorder(BTNodePtr tempPtr){
    if(tempPtr == NULL){
        return;
    }

    inorder(tempPtr->left);
    printf("%c", tempPtr->element);
    inorder(tempPtr->right);
}

//左右中历遍
void postorder(BTNodePtr tempPtr){
    if(tempPtr == NULL){
        return;
    }

    postorder(tempPtr->left);
    postorder(tempPtr->right);
    printf("%c", tempPtr->element);
}

//main
int main(){
    
    BTNodePtr tempHeader;
    tempHeader = constructBTNode('c');
    printf("There is only one node. Preorder visit: ");
    preorder(tempHeader);
    printf("\r\n");

    char* tempString = "acde#bf######";

    tempHeader = stringToBTree(tempString);
    printf("Preorder: ");
    preorder(tempHeader);
    printf("\r\n");
    printf("Inorder: ");
    inorder(tempHeader);
    printf("\r\n");
    printf("Postorder: ");
    postorder(tempHeader);
    printf("\r\n");
    printf("Levelwise: ");
    levelwise(tempHeader);
    printf("\r\n");

    return 0;
}

---

四、小结 

性质1：二叉树的第i层上至多有2i-1（i≥1）个节点。

性质2：深度为h的二叉树中至多含有2h-1个节点。

性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1。

性质4：具有n个节点的满二叉树深为log2n+1。

性质5：若对一棵有n个节点的完全二叉树进行顺序编号（1≤i≤n），那么，对于编号为i（i≥1）的节点：

当i=1时，该节点为根，它无双亲节点。

当i>1时，该节点的双亲节点的编号为i/2。

若2i≤n，则有编号为2i的左节点，否则没有左节点。

若2i+1≤n，则有编号为2i+1的右节点，否则没有右节点。