BITREE

二叉树存储结构

typedef struct BiTNode {
    Elemtype data;
    struct BiTNode* lchild;
    struct BiTNode* rchild;
} BiTNode, *BiTree;

先序和中序遍历构建二叉树

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

typedef char Elemtype; 

typedef struct BiTNode {
    Elemtype data;
    struct BiTNode* lchild;
    struct BiTNode* rchild;
} BiTNode, *BiTree;

// 先序遍历
void preOrder(BiTree T) {
    if (T != NULL) {
        printf("%c ", T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

// 根据先序和中序遍历构建二叉树
BiTree createTree(Elemtype preList[], int preStart, int preEnd,
                 Elemtype inList[], int inStart, int inEnd) {
    if (preStart > preEnd) {
        return NULL;
    }
    BiTree root = (BiTree)malloc(sizeof(BiTNode));
    root->data = preList[preStart]; // 先序序列的起始位置为根节点
    int rootIndex;
    for (rootIndex = inStart; rootIndex <= inEnd; rootIndex++) {
        if (inList[rootIndex] == preList[preStart]) {
            break;
        }
    }
    int leftSubtreeSize = rootIndex - inStart;
    root->lchild = createTree(preList, preStart + 1, preStart + leftSubtreeSize, inList, inStart, rootIndex - 1);
    root->rchild = createTree(preList, preStart + leftSubtreeSize + 1, preEnd, inList, rootIndex + 1, inEnd);
    return root;
}

int main() {
    Elemtype preList[] = {'A', 'B', 'D', 'E', 'C', 'F', 'G'};
    int preListLength = 7;
    Elemtype inList[] = {'D', 'B', 'E', 'A', 'F', 'C', 'G'};
    int inListLength = 7;

    BiTree root = createTree(preList, 0, preListLength - 1, inList, 0, inListLength - 1);

    printf("先序遍历结果: ");
    preOrder(root);

    return 0;
}

层次+中序构建

算法思想:先从层次遍历中确定根结点(子树根结点),在到中序序列中确定根位置,此时会将中序序列分成左子树序列和右子树序列。然后再确定层次遍历的左右子树序列之后,构建左右子树。重复上述步骤,将构建出整棵树。

然后在层次遍历中,依次取出每个结点到左子树中序列中匹配,如果结点成功就能确定其为左子树层次遍历中的结点,重复上述步骤，便能找到左子树的层次遍历序列;通过上述方法,将获得右子树遍历序列,最终确定左右子树的层次遍历序列后,构建左右子树。

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

#define MAX_SIZE 100

typedef char Elemtype;

typedef struct BiTNode {
    Elemtype data;
    struct BiTNode* lchild;
    struct BiTNode* rchild;
} BiTNode, *BiTree;

void preOrder(BiTree T) {
    if (T != NULL) {
        printf("%c ", T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

// 根据层次和中序遍历构建二叉树
BiTree createTree(Elemtype levList[], int levStart, int levEnd,
                 Elemtype inList[], int inStart, int inEnd) {
    if (levStart > levEnd) {
        return NULL;
    }
    BiTree root = (BiTree)malloc(sizeof(BiTNode));
    root->data = levList[levStart]; // 层次序列的起始位置为根节点
    int rIndex;
    for (rIndex = inStart; rIndex <= inEnd; rIndex++) {
        if (root->data == inList[rIndex]) {
            break;
        }
    }
    char leftLevList[MAX_SIZE] = {0};
    int leftLength = 0;
    for (int j = levStart + 1; j <= levEnd; j++) {
        for (int i = inStart; i <= rIndex - 1; i++) {
            if (levList[j] == inList[i]) {
                leftLevList[leftLength++] = levList[j];
            }
        }
    }
    char rightLevList[MAX_SIZE] = {0};
    int rightLength = 0;
    for (int j = levStart + 1; j <= levEnd; j++) {
        for (int i = rIndex + 1; i <= inEnd; i++) {
            if (levList[j] == inList[i]) {
                rightLevList[rightLength++] = levList[j];
            }
        }
    }

    root->lchild = createTree(leftLevList, 0, leftLength - 1, inList, inStart, rIndex - 1);
    root->rchild = createTree(rightLevList, 0, rightLength - 1, inList, rIndex + 1, inEnd);
    return root;
}

int main() {
    Elemtype levList[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    Elemtype inList[] = {'D', 'B', 'E', 'A', 'F', 'C', 'G'};
    int inListLength = 7;

    BiTree root = createTree(levList, 0, inListLength - 1, inList, 0, inListLength - 1);

    printf("先序遍历结果: ");
    preOrder(root);
    printf("\n");

    return 0;
}

解题方法

二叉树解题大法

目的:转换信息,让肉眼可查,可分析

为什么要有二叉树的遍历?二叉树的表示方法。转换成一种肉眼直接看到的信息。二叉树
的遍历算法就是按照人类定义的规则将非线性的二叉树转换成线性的信息(序列)。例子:

将二叉树转换成先序遍历的序列.中序+其他三种遍历序列就能确定一棵树.

一棵二叉树是分为三个部分:根、左子树、右子树。当我们处理一棵树的时候,先处理根结点,再处理子树。子树也是一棵树,所以求解的过程实际上就是根+子树。

二叉树的遍历分为四种:先序、中序、后序、层次遍历。其实就是根结点的访问次序有关。
如果根结点在子树之前访问,那么就是先序,如果根在两个子树之间访问,那么中序,后序
就是根在两个子树访问之后访问。

递归:
递归的两大条件:
1、出口:树为空的时候,或者子树为空的时候就是出口
2、问题规模递减:为什么你能确定树递归设计的时候问题规模一定递减。处理了根,问题规
模只剩下左、右子树,处理左右子树的求解问题,直接函数调用(自己调用自己,递归)

Func(T)//根据我们的问题对树进行的求解=解1+解2
{
对根进行访问求解; = = = 》解1
再对左右子树进行求解; ==》解2
}
根存在就加1, 递归左、右子树,
左子树中结点数量+右子树中结点数量+1就是整棵树的结点数量

BiTNode * Func(BiTree T, int x)//接口设计

Func.(T)
{
if (NULL !=T)1/判树是否为空.一定会出去
{
访问根结点;
左子树的求解;===》Func(T-
lchild);
右子树的求解; ===>Fuc(T->rchild);
}
}
题目给你什么,你就要在函数中用什么。
隐藏的参数:手算的时候就会发现要用到这个东西(参数)

求一棵二叉树的结点个数。
1、设计函数接口,问题求解的方法就获得;
2、出口=>if判空树
3、问题求解:根的解+左右子树的解(直接调用方法)

中序:二叉排序中对于带顺序,大小,中序遍历二叉排序树的时候,升序序列
后序:表达式求解
其余情况的递归设计都是先序

求一颗二叉树的节点个数

求一棵二叉树的结点个数。
1、设计函数接口,问题求解的方法就获得;
2、出口=>if判空树
3、问题求解:根的解+左右子树的解(
直接调用方法)

int getNodes(BiTree T){
    if(T==NULL){
        return 0;
    }

    return 1+getNodes(T->lchild)+getNodes(T->rchild);
}

查找值为X的结点

BiTNode* findX(BiTree T,Elemtype x){
    if(T==NULL){
        return NULL;
    }
    else if(T->data==x){
        return T;
    }
    else{
        BiTNode* temp = findX(T->lchild,x);
        if(temp !=NULL)
            return temp;
        else 
            return findX(T->rchild,x);
    }

}

求树高

int getHeight(BiTree T){
    if(T==NULL)
        return 0;
    else{
        int leftHeight = getHeight(T->lchild);  
        int rightHeight = getHeight(T->rchild);
        return leftHeight > rightHeight ? leftHeight+1:rightHeight+1;
    }
}

求值为x的节点作为根节点的子树深度

int getXHeight(BiTree T ,Elemtype x){
    BiTNode *p = findX(T,x);
    if(p==NULL)
        return 0;
    return getHeight(p);
}

交换二叉树左右子树

void swapTree(BiTree T){
    if(T!=NULL){
        BiTNode* temp = T->lchild;
        T->lchild = T->rchild;
        T->rchild = temp;
        swapTree(T->lchild);
        swapTree(T->rchild);
    }
}

求叶子节点个数

int countLeaf(BiTree T){
    if(T==NULL)
        return 0;
    else if(T->lchild==NULL&&T->rchild==NULL){
        return 1;
    }
    else{
        return countLeaf(T->lchild)+countLeaf(T->rchild);
    }
}

设计算法利用叶子节点中的空指针域将所有叶子节点链接成一个带头节点的双链表

经过分析发现:该题实际上就是一个找到叶子结点,然后往双链表中插入结点过程(尾插)。警告!双链表不要头插。

void linkLeaf(BiTree T,BiTNode*pTail){
    if(T!=NULL){
        if(T->lchild==NULL&&T->rchild==NULL){
            T->lchild=pTail;
            pTail->rchild=T;
            pTail=pTail->rchild;
        }
        else{
            linkLeaf(T->lchild,pTail);
            linkLeaf(T->rchild,pTail);
        }
    }
}

void operate(BiTree T){
    BiTNode*L = (BiTNode*)malloc(sizeof(BiTNode));
    L->lchild=NULL;
    L->rchild=NULL;
    BiTNode* ptail= L;
    linkLeaf(T,ptail);
    BiTNode* pCurNode = L->rchild;
    while(pCurNode!=NULL){
        printf("%c",pCurNode->data);
        pCurNode=pCurNode->rchild;
    }

}

一个仅包含二元运算的算术表达式以二叉链表形式存放在二叉树T，设计算法求算术表达式。

int func(char sign,int left,int right){
    switch(sign){
        case '+':return left+right;
        case '-':return left-right;
        case '*':return left*right;
        case '/':return left/right;
    } 
}

int getResult(BiTree T){
    if(T==NULL)
        return 0;
    else if(T->lchild==NULL&&T->rchild==NULL){
        return T->data;
    }
    else{
        int left = getResult(T->lchild);
        int right = getResult(T->rchild);
        return func(T->data,left,right);
    }
}

二叉树的层次遍历

与某一层所有结点相关的性质判定。
完全二叉树、或者求一个棵树的最大宽度。手算的时候,发现问题求解是跟树的某一层所有顶点都相关。会涉及到不同的根结点,你访问的这一层的所有结点,他们的父亲都不相同。共根(先、中、后),因为他们都是从一个根结点出发的。前面三种遍历无法同时访问非共父母的节点。
我们的程序每次只能访问一个顶点,但是我们要访问一层多个顶点,为了在访问当前顶点的时候其余待访问的同批结点信息不丢失,我们需要用队列来保存来的父母，以至于带访问的同批节点的信息不丢失。

考试的时候不要重视非题目要求的功能函数实现。出队列，入队列,这些与题目功能,非核心功能实现,都可以直接写一个函数进行调用,加上注释就行了。

void levelOrder(BiTree T){
    Queue Q;
    initialQueue(Q);
    enQueue(Q,T);//将根节点压入队列；
    while(!isEmpty(Q)){
        BiTNode*e = NULL;
        deQueue(Q,&e);
        printf("%c",e->data);
        if(e->lchild!=NULL){
            enQueue(Q,e->lchild);
        }
        if(e->rchild!=NULL){
            enQueue(Q,e->rchild);
        }

    }
}

判断一棵树是否为完全二叉树

一个实节点前不能存在空节点。
就是不管节点是否为空，都入队，然后出队列。如果发现空节点，那么队列中还存在实节点，那么非完全二叉树，反之，队列中剩余的元素都为空结点，那么该树为完全二叉树。

int isComplete(BiTree T){
    Queue Q;
    initialQueue(Q);
    enQueue(Q,T);//将根节点压入队列；
    while(!isEmpty(Q)){
        BiTNode* e = NULL;
        deQueue(Q,&e);
        if(e==NULL){
            break;
        }
        enQueue(Q,e->lchild);
        enQueue(Q,e->rchild);
    }
    while(!isEmpty(Q)){
        BiTNode* e = NULL;
        deQueue(Q,&e);
        if(e!=NULL){
            return 0;
        }
    }
    return 1;
}

求二叉树最大宽度

p151 留坑

二叉排序树

数据结构

typedef struct BSTNode {
    ElemType data; 
    struct BSTNode* lchild; 
    struct BSTNode* rchild; 
} BSTNode, *BSTree;

一个插入操作
删除操作:分两个情况来操作
1、线性的。从删除结点的前驱(父亲结点)开始,构成一条链,也就是说删除结点只有一个孩子。所以就能像链表知道删除结点的前驱区,来删除该结点的操作方式一样,直接将前驱结点的指向它的指针,指向删除结点存在孩子。
2、非线性的(二分)。非线性将其转换成线性的结构,找到删除结点的左子树中的最大者，因为左子树中的结点都小于删除结点(子树根),右子树都大于删除结点,所以我们就确定左子树中最大者一定小于右子树中任意一个结点。我们将右子树的根结点挂到左子树中最
大者的右孩子上,这样就将非线性结构转换成了线性结构。|
然后将指向根节点的指针（指向子树根节点的指针），直接指向左子树根节点（右子树）。

注意【平均查找长度】

建立二叉排序树

void insert(BSTree &T,ElemType key){
    if(T==NULL){
        BSTNode* pNode = (BSTNode*)malloc(sizeof(BSTNode));
        pNode->lchild = NULL;
        pNode->rchild = NULL;
        pNode->data = key;
        T=pNode;
    }
    else if (key>T->data){
        insert(T->rchild,key);
    }
    else if (key<T->data){
        insert(T->lchild,key);
    }

}
BSTNode* createBsTree(){
    BSTNode* T = NULL;
    ElemType List[]={40,10,45,15};
    int length = 4;
    for(int i= 0;i<length;i++){
        insert(T,List[i]);
    }
    return T;
}

删除操作

void delNode(BSTree &T){
    if(T->lchild==NULL&&T->rchild==NULL){
        free(T);
        T=NULL;
    }
    else if(T->lchild!=NULL&&T->rchild==NULL){
        BSTNode* pNode = T;
        T=T->lchild;
        free(pNode);
    }
    else if(T->lchild==NULL&&T->rchild!=NULL){
        BSTNode* pNode = T;
        T=T->rchild;
        free(pNode);
    }
    else{
        BSTNode*pMAX = T->lchild;
        while(pMAX->rchild!=NULL){
            pMAX=pMAX->rchild;
        }
        pMAX->rchild = T->rchild;
        BSTNode *pNode = T;
        T=T->lchild;
        free(pNode);
    }


}
void delBST(BSTree &T ,ElemType x){
    if(T!=NULL){
        if(T->data==x){
            delNode(T);
        }
        else if(T->data>x){
            delBST(T->rchild,x);
        }
        else{
            delBST(T->lchild,x);
        }

    }
}

将一颗二叉排序树t分解成两颗二叉排序树t1和t2，使得t1中的所有节点关键字的值都小于key，t2中所有关键字的值都大于key。

void insert1(BSTNode* rNode,BSTree &T){
    if(T==NULL){
        T=rNode;
    }
    else if (rNode->data < T->data) {
        insert1(rNode, T->lchild);
    }
    else {
        insert1(rNode, T->rchild);
    }

}
void preOrderTraverse(BSTree &T,ElemType key,BSTree T1,BSTree T2){
    if(T!=NULL){
        if(key<T->data){
            preOrderTraverse(T->lchild,key,T1,T2);
            T->lchild=NULL;//左子树划分完了，置空
            insert1(T,T2);
        }
        else if(key==T->data){
            insert1(T->lchild,T1);
            insert1(T->lchild,T2);
            free(T);

        }
        else{
            preOrderTraverse(T->rchild,key,T1,T2);
            T->rchild=NULL;//左子树划分完了，置空
            insert1(T,T1);

        }
    }
    


}
void spilitBST(BSTree &T,ElemType key,BSTree T1,BSTree T2){
    T1 =NULL;
    T2 = NULL;
    preOrderTraverse(T,key,T1,T2);
}

已知二叉排序树中每一个节点值为整型，采用二叉链表存储编写算法，删除二叉排序树中所有小于x的节点。

解这类题的最关键就是你要知道根结点,然后左右子树的取值范围!然后根据这个范围,要不要对子树进行递归操作。先序遍历,先知道根结点才能知道左右子树的范围。

算法思想:使用先序遍历搜索小于x的结点并将其删除。如果当前访问结点大于x，那么使用先序遍历搜索并删除其左子树中小于x的结点，保留该结点及其右子树;如果当前结点小于.x，那么先序遍历搜索并删除其右子树中小于x的结点后
再直接删除左子树中所有
结点;如果当前访问结点等于x，那么直接删除该结点及其左子树，保留右子树。

void preOrderTtrav(BSTree &T,ElemType x){
    if(T!=NULL){
        if(T->data==x){
            delTree(T->lchild);
            T->lchild = NULL;
        }
        else if(T->data<x){
            preOrderTtrav(T->rchild,x);
            BSTNode* pNode = T; 
            T=T->rchild;
            pNode->rchild =NULL;
            delTree(pNode);
        }
        else if(T->data>x){
            preOrderTtrav(T->lchild,x);
        }
    }

}

查找所有小于key的关键字

void inOrderSeek(BSTree T,ElemType key){
    if(T!=NULL){
        inOrderSeek(T->lchild,key);
        if(T->data<key){
            printf("%d",T->data);
            inOrderSeek(T->rchild,key);
        }
    }
}

存在一个二叉排序树，给定一个value值，若查找value值，就返回比value值大的所有值中的最小值。若value最大就返回空。

BSTNode *p = NULL;
ElemType inOrderReturn(BSTree T,ElemType value){
    if(T!=NULL){
        inOrderReturn(T->rchild,value);
        if(value<T->data){
            p = T;
            inOrderReturn(T->lchild,value);
        }
    }
}

BSTNode* getValue(BSTree T,ElemType value){
    inOrderReturn(T,value);
    return p;
}

平衡二叉树

#线序二叉树