2022王道数据结构考研复习指导习题代码（树与二叉树）

最新推荐文章于 2023-08-05 00:19:16 发布
最新推荐文章于 2023-08-05 00:19:16 发布
阅读量1.7k 收藏 46
点赞数 9
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18431031/article/details/116903980
版权

5.2二叉树的概念

1.已知一棵二叉树按顺序存储结构进行存储，设计一个算法，求编号分别i和j的两个结点的最近公共祖先结点的值。

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

#define MAX 100

char *T;
char a[MAX];

char Comm_Ancestor(char *T, int i, int j)
{
    char res = '\0';
    if (T[i] != '#' && T[j] != '#') {
        while (i != j) {
            if (i > j) i = i / 2;
            else j = j / 2;
        }
        res = T[i];
    }
    return res;
}

int main()
{
    char ans;
    int p, q;
    scanf("%s", a);
    int len = strlen(a);
    T = (char *)malloc(sizeof(char) * len);
    for (int i = 1; i <= len; i++) {
        *(T + i) = a[i - 1];
    }
    scanf("%d %d", &p, &q);
    ans = Comm_Ancestor(T, p, q);
    printf("%c\n", ans);
    return 0;
}

5.3二叉树的遍历和线索二叉树

3.编写后序遍历二叉树的非递归算法。

#include <stack>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void visit(BiTNode *R)
{
    cout << R->data << " ";
}

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void PostOrder(BiTree T)
{
    stack<BiTNode *> st;
    BiTNode *p = T, *r = NULL;
    while (p || !st.empty()) {
        if (p) {
            st.push(p);
            p = p->lchild;
        } else {
            p = st.top();
            if (p->rchild != NULL && p->rchild != r) {
                p = p->rchild;
            } else {
                r = st.top();
                visit(r);
                st.pop();
                p = NULL;
            }
        }
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    PostOrder(T);
    return 0;
}

4.试给出二叉树的自下而上、从右到左的层次遍历算法。

#include <queue>
#include <stack>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void visit(BiTNode *R)
{
    cout << R->data << " ";
}

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void LevelOrder(BiTree T)
{
    queue<BiTNode *> q;
    stack<BiTNode *> st;
    BiTNode *p;
    q.push(T);
    while (!q.empty()) {
        p = q.front();
        st.push(p);
        q.pop();
        if (p->lchild != NULL) q.push(p->lchild);
        if (p->rchild != NULL) q.push(p->rchild);
    }
    while (!st.empty()) {
        visit(st.top());
        st.pop();
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    LevelOrder(T);
    return 0;
}

5.假设二叉树采用二叉链表存储结构，设计一个非递归算法求二叉树的高度。

#include <queue>
#include <stack>
#include <iostream>
using namespace std;

const int MaxSize = 100;

typedef char ElemType;

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

void visit(BiTNode *R)
{
    cout << R->data << " ";
}

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

int Btdepth(BiTree T)
{
    if (!T) return 0;
    int front = -1, rear = -1;
    int last = 0, level = 0;
    BiTree Q[MaxSize];
    Q[++rear] = T;
    BiTree p;
    while (front < rear) {
        p = Q[++front];
        if (p->lchild) Q[++rear] = p->lchild;
        if (p->rchild) Q[++rear] = p->rchild;
        if (front == last) {
            level++;
            last = rear;
        }
    }
    return level;
}

int main()
{
    BiTree T;
    InitBiTree(T);
    cout << Btdepth(T) << endl;
    return 0;
}

6.设一棵二叉树中各结点的值互不相同，其先序遍历序列和中序遍历序列分别存于两个一维数组 A [ 1... n ] A[1...n] A[1...n]和 B [ 1... n ] B[1...n] B[1...n]中，试编写算法建立该二叉树的二叉链表。

#include <cstring>
#include <iostream>
using namespace std;

const int maxn = 100;

typedef char ElemType;

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

ElemType *A, *B, A1[maxn], B1[maxn];

BiTree PreInCreat(ElemType *A, ElemType *B, int l1, int h1, int l2, int h2)
{
    int i, llen, rlen;
    BiTree root = (BiTree)malloc(sizeof(BiTNode));
    root->data = A[l1];
    for (i = l2; B[i] != root->data; i++)
        ;
    llen = i - l2;
    rlen = h2 - i;
    if (llen) root->lchild = PreInCreat(A, B, l1 + 1, l1 + llen, l2, l2 + llen - 1);
    else root->lchild = NULL;
    if (rlen) root->rchild = PreInCreat(A, B, h1 - rlen + 1, h1, h2 - rlen + 1, h2);
    else root->rchild = NULL;
    return root;
}

int main()
{
    scanf("%s", A1);
    scanf("%s", B1);
    int h1 = strlen(A1); int h2 = strlen(B1);
    A = (ElemType *)malloc(sizeof(ElemType) * h1);
    B = (ElemType *)malloc(sizeof(ElemType) * h2);
    for (int i = 1; i <= h1; i++) {
        *(A + i) = A1[i - 1];
    }
    for (int i = 1; i <= h2; i++) {
        *(B + i) = B1[i - 1];
    }
    BiTree T;
    T = PreInCreat(A, B, 1, h1, 1, h2);
    return 0;
}

7.二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法。

#include <queue>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

bool IsComplete(BiTree T)
{
    if (!T) return true;
    queue<BiTree> q;
    q.push(T);
    BiTree tmp = NULL;
    while (tmp = q.front()) {
        q.push(tmp->lchild);
        q.push(tmp->rchild);
        q.pop();
    }
    while (!q.empty()) {
        if (q.front() != NULL) return false;
        q.pop();
    }
    return true;
}

int main()
{
    BiTree T;
    InitBiTree(T);
    if (IsComplete(T)) cout << "Yes" << endl;
    else cout << "No" << endl;
    return 0;
}

8.假设二叉树采用二叉链表存储结构存储，试设计一个算法，计算一棵给定二叉树的所有双分支结点个数。

#include <queue>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

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

int main()
{
    BiTree T;
    InitBiTree(T);
    cout << DsonNodes(T) << endl;
    return 0;
}

9.设树B是一棵采用链式结构存储的二叉树，编写一个把树B中所有结点的左、右子树进行交换的函数。

#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void swap(BiTree b)
{
    if (b) {
        swap(b->lchild);
        swap(b->rchild);
        BiTree temp = b->lchild;
        b->lchild = b->rchild;
        b->rchild = temp;
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    swap(T);
    cout << T->rchild->data << endl;
    return 0;
}

10.假设二叉树采用二叉链表存储结构存储，设计一个算法，求先序遍历序列中第 k ( 1 ≤ k ≤ 二 叉 树 中 结 点 个 数 ) k(1 \leq k \leq 二叉树中结点个数) k(1≤k≤二叉树中结点个数)个结点的值。

#include <iostream>
using namespace std;

typedef char ElemType;

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

int i = 1;

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

ElemType PreNode(BiTree b, int k)
{
    if (b == NULL) return '#';
    if (i == k) return b->data;
    i++;
    ElemType ch;
    ch = PreNode(b->lchild, k);
    if (ch != '#') return ch;
    ch = PreNode(b->rchild, k);
    return ch;
}

int main()
{
    BiTree T;
    InitBiTree(T);
    ElemType ans;
    ans = PreNode(T, 4);
    cout << ans << endl;
    return 0;
}

11.已知二叉树以二叉链表存储，i编写算法完成：对于树中每个元素值为x的结点，删去以它为根的子树，并释放相应的空间。

#include <queue>
#include <iostream>
using namespace std;

typedef char ElemType;

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

int i = 1;

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void DeleteXTree(BiTree &bt)
{
    if (bt) {
        DeleteXTree(bt->lchild);
        DeleteXTree(bt->rchild);
        free(bt);
    }
}

void Search(BiTree bt, ElemType x)
{
    queue<BiTree> q;
    if (bt) {
        if (bt->data == x) {
            DeleteXTree(bt);
            exit(0);
        }
        q.push(bt);
        while (!q.empty()) {
            BiTree temp = q.front();
            q.pop();
            if (temp->lchild) {
                if (temp->lchild->data == x) {
                    DeleteXTree(temp->lchild);
                    temp->lchild = NULL;
                } else {
                    q.push(temp->lchild);
                }
            }
            if (temp->rchild) {
                if (temp->rchild->data == x) {
                    DeleteXTree(temp->rchild);
                    temp->rchild = NULL;
                } else {
                    q.push(temp->rchild);
                }
            }
        }
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    ElemType x;
    cin >> x;
    Search(T, x);
    cout << T->rchild->lchild->data << endl;
    return 0;
}

12.在二叉树中查找值为x的结点，试编写算法（用C语言）打印值为x的结点的所有祖先，假设值为x的结点不多于一个。

#include <stack>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void visit(BiTree T)
{
    cout << T->data << " ";
}

void Search(BiTree T, ElemType x)
{
    BiTree p = T, r = NULL;
    stack<BiTree> st;
    while (p || !st.empty()) {
        if (p) {
            st.push(p);
            p = p->lchild;
        } else {
            p = st.top();
            if (p->data == x) {
                while (!st.empty()) {
                    visit(st.top());
                    st.pop();
                }
                return;
            }
            if (p->rchild && p->rchild != r)
                p = p->rchild;
            else {
                r = st.top();
                st.pop();
                p = NULL;
            }
        }
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    ElemType x;
    cin >> x;
    Search(T, x);
    return 0;
}

13.设一棵二叉树的结点结构为 ( L L I N K , I N F O , R L I N K ) (LLINK,INFO,RLINK) (LLINK,INFO,RLINK)， R O O T ROOT ROOT为指向该二叉树根结点的指针， q q q和 q q q分别指向该二叉树中任意两个结点的指针，试编写算法 A N C E S T O R ( R O O T , p , q , r ) ANCESTOR(ROOT,p,q,r) ANCESTOR(ROOT,p,q,r)，找到 p p p和 q q q的最近公共祖先结点 r r r。

#include <map>
#include <iostream>
using namespace std;

typedef char ElemType;

typedef struct BiTNode {
    ElemType INFO;
    struct BiTNode *LLINK, *RLINK;
} BiTNode, *BiTree;

map<ElemType, BiTree> fa;
map<int, bool> vis;

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->INFO = ch;
        InitBiTree(T->LLINK);
        InitBiTree(T->RLINK);
    }
}

void dfs(BiTree T)
{
    if (T->LLINK) {
        fa[T->LLINK->INFO] = T;
        dfs(T->LLINK);
    }
    if (T->RLINK) {
        fa[T->RLINK->INFO] = T;
        dfs(T->RLINK);
    }
}

void ANCESTOR(BiTree ROOT, BiTree p, BiTree q, BiTree &r)
{
    fa[ROOT->INFO] = NULL;
    dfs(ROOT);
    while (p != NULL) {
        vis[p->INFO] = true;
        p = fa[p->INFO];
    }
    while (q != NULL) {
        if (vis[q->INFO]) {
            r = q;
            return;
        } else q = fa[q->INFO];
    }
    return;
}

int main()
{
    BiTree ROOT, ans = NULL;
    InitBiTree(ROOT);
    ANCESTOR(ROOT, ROOT->RLINK->LLINK->RLINK, ROOT->RLINK->RLINK, ans);
    cout << ans->INFO << endl;
    return 0;
}

14.假设二叉树采用二叉链表存储结构，设计一个算法，求非空二叉树b的宽度（即具有结点数最多的那一层的结点个数）。
王道书上的做法：

#include <iostream>
using namespace std;

const int MaxSize = 100;

typedef char ElemType;

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

typedef struct {
    BiTree data[MaxSize];
    int level[MaxSize];
    int front, rear;
} Qu;

Qu q;

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

int BTWidth(BiTree b)
{
    BiTree p;
    int k, maxn, i, n;
    q.front = q.rear = -1;
    q.rear++;
    q.data[q.rear] = b;
    q.level[q.rear] = 1;
    while (q.front < q.rear) {
        q.front++;
        p = q.data[q.front];
        k = q.level[q.front];
        if (p->lchild != NULL) {
            q.rear++;
            q.data[q.rear] = p->lchild;
            q.level[q.rear] = k + 1;
        }
        if (p->rchild != NULL) {
            q.rear++;
            q.data[q.rear] = p->rchild;
            q.level[q.rear] = k + 1;
        }
    }
    maxn = 0; i = 0;
    k = 1;
    while (i <= q.rear) {
        n = 0;
        while (i <= q.rear && q.level[i] == k) {
            n++;
            i++;
        }
        k = q.level[i];
        if (n > maxn) maxn = n;
    }
    return maxn;
}

int main()
{
    BiTree T;
    InitBiTree(T);
    cout << BTWidth(T) << endl;
    return 0;
}

我的做法：

#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

int LevelOrder(BiTree T)
{
    int res = 0;
    queue<BiTree> q;
    q.push(T);
    while (!q.empty()) {
        BiTree temp = q.front();
        q.pop();
        if (temp->lchild) q.push(temp->lchild);
        if (temp->rchild) q.push(temp->rchild);
        int t = q.size();
        res = max(res, t);
    }
    return res;
}

int main()
{
    BiTree T;
    InitBiTree(T);
    cout << LevelOrder(T) << endl;
    return 0;
}

15.设有一棵满二叉树（所有结点值均不同），已知其先序序列为pre，设计一个算法求其后序序列post。

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

char pre[50], post[50];

void PreToPost(char pre[], int l1, int r1, char post[], int l2, int r2)
{
    int mid;
    if (r1 >= l1) {
        post[r2] = pre[l1];
        mid = (r1 - l1) / 2;
        PreToPost(pre, l1 + 1, l1 + mid, post, l2, l2 + mid - 1);
        PreToPost(pre, l1 + mid + 1, r1, post, l2 + mid, r2 - 1);
    }
}

int main()
{
    scanf("%s", pre);
    int len = strlen(pre);
    PreToPost(pre, 0, len, post, 0, len);
    for (int i = 0; i < len + 1; i++)
        printf("%c", post[i]);
    return 0;
}

16.设计一个算法将二叉树的叶结点按从左到右的顺序连成一个单链表，表头指针为head，二叉树按二叉链表方式存储，链接时用叶结点的右指针域来存放单链表指针。

#include <iostream>
using namespace std;

typedef char ElemType;

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

BiTree head, pre = NULL;

void InitBiTree(BiTree &bt)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') bt = NULL;
    else {
        bt = (BiTree)malloc(sizeof(BiTNode));
        bt->data = ch;
        InitBiTree(bt->lchild);
        InitBiTree(bt->rchild);
    }
}

BiTree InOrder(BiTree bt)
{
    if (bt) {
        InOrder(bt->lchild);
        if (bt->lchild == NULL && bt->rchild == NULL) {
            if (pre == NULL) {
                head = bt;
                pre = bt;
            } else {
                pre->rchild = bt;
                pre = bt;
            }
        }
        InOrder(bt->rchild);
        pre->rchild = NULL;
    }
    return head;
}

int main()
{
    BiTree bt;
    InitBiTree(bt);
    BiTree ans = InOrder(bt);
    while (ans) {
        cout << ans->data << " ";
        ans = ans->rchild;
    }
    cout << endl;
    return 0;
}

17.试设计判断两棵二叉树是否相似的算法。所谓二叉树 T 1 T_{1} T1​和 T 2 T_{2} T2​相似，指的是 T 1 T_{1} T1​和 T 2 T_{2} T2​都是空的二叉树或都只有一个根结点；或 T 1 T_{1} T1​的左子树和 T 2 T_{2} T2​的左子树是相似的，且 T 1 T_{1} T1​的右子树和 T 2 T_{2} T2​的右子树是相似的。

#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

int similar(BiTree T1, BiTree T2)
{
    int leftS, rightS;
    if (T1 == NULL && T2 == NULL) return 1;
    else if (T1 == NULL || T2 == NULL) return 0;
    else {
        leftS = similar(T1->lchild, T2->lchild);
        rightS = similar(T1->rchild, T2->rchild);
        return leftS && rightS;
    }
}

int main()
{
    BiTree T1, T2;
    InitBiTree(T1);
    InitBiTree(T2);
    if (similar(T1, T2)) cout << "yes" << endl;
    else cout << "no" << endl;
    return 0;
}

18.写出在中序线索二叉树里查找指定结点在后序的前驱结点的算法。

#include <iostream>
using namespace std;

typedef char ElemType;

typedef struct ThreadNode {
    ElemType data;
    struct ThreadNode *lchild, *rchild;
    int ltag, rtag;
} ThreadNode, *ThreadTree;

void InitInThread(ThreadTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (ThreadTree)malloc(sizeof(ThreadNode));
        T->data = ch;
        InitInThread(T->lchild);
        InitInThread(T->rchild);
    }
}

void InThread(ThreadTree &p, ThreadTree &pre)
{
    if (p != NULL) {
        InThread(p->lchild, pre);
        if (p->lchild == NULL) {
            p->lchild = pre;
            p->ltag = 1;
        }
        if (pre != NULL && pre->rchild == NULL) {
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
        InThread(p->rchild, pre);
    }
}

void CreateInThread(ThreadTree T)
{
    ThreadTree pre = NULL;
    if (T != NULL) {
        InThread(T, pre);
        pre->rchild = NULL;
        pre->rtag = 1;
    }
}

ThreadTree InPostPre(ThreadTree t, ThreadTree p)
{
    ThreadTree q;
    if (p->rtag == 0) q = p->rchild;
    else if (p->ltag == 0) q = p->lchild;
    else if (p->lchild == NULL) q = NULL; // p是中序序列第一结点，无后序前驱
    else {
        while (p->ltag == 1 && p->lchild != NULL) p = p->lchild;
        if (p->ltag == 0) q = p->lchild;
        else q = NULL;
    }
    return q;
}

int main()
{
    ThreadTree T;
    InitInThread(T);
    CreateInThread(T);
    ThreadTree ans = InPostPre(T, T->rchild->lchild);
    cout << ans->data << endl;
    return 0;
}

19.二叉树的带权路径长度（WPL）是二叉树中所有叶结点的带权路径长度之和。给定一棵二叉树T，采用二叉链表存储，请设计求T的WPL的算法。

#include <iostream>
using namespace std;

typedef char ElemType;

typedef struct BiTNode {
    int weight;
    ElemType data;
    struct BiTNode *left, *right;
} BiTNode, *BiTree;

void InitBiTree(BiTree &T)
{
    int w;
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        cin >> w;
        T->weight = w;
        InitBiTree(T->left);
        InitBiTree(T->right);
    }
}

int wpl_PreOrder(BiTree root, int deep)
{
    static int wpl = 0;
    if (root->left == NULL && root->right == NULL)
        wpl += deep * root->weight;
    if (root->left != NULL)
        wpl_PreOrder(root->left, deep + 1);
    if (root->right != NULL)
        wpl_PreOrder(root->right, deep + 1);
    return wpl;
}

int WPL(BiTree root)
{
    return wpl_PreOrder(root, 0);
}

int main()
{
    BiTree T;
    InitBiTree(T);
    int ans = WPL(T);
    cout << ans << endl;
    return 0;
}

20.设计一个算法，将给定的表达式树转换为等价的中缀表达式（通过括号反映操作符的计算次序）并输出。

#include <iostream>
using namespace std;

typedef char ElemType;

typedef struct BNode {
    ElemType data;
    struct BNode *left, *right;
} BNode, *BTree;

void InitBTree(BTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BTree)malloc(sizeof(BNode));
        T->data = ch;
        InitBTree(T->left);
        InitBTree(T->right);
    }
}

void BtreeToExp(BTree root, int deep)
{
    if (root == NULL) return;
    else if (root->left == NULL && root->right == NULL)
        cout << root->data;
    else {
        if (deep > 1) cout << "(";
        BtreeToExp(root->left, deep + 1);
        cout << root->data;
        BtreeToExp(root->right, deep + 1);
        if (deep > 1) cout << ")";
    }
}

void BtreeToE(BTree root)
{
    BtreeToExp(root, 1);
}

int main()
{
    BTree T;
    InitBTree(T);
    BtreeToE(T);
    return 0;
}

5.5树与二叉树的应用
6.试编写一个算法，判断给定的二叉树是否是二叉排序树。

#include <climits>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

bool dfs(BiTree T, int minv, int maxv)
{
    if (T == NULL) return true;
    if (T->data < minv || T->data > maxv) return false;
    return dfs(T->lchild, minv, T->data - 1) && dfs(T->rchild, T->data + 1, maxv);
}

bool JudgeBST(BiTree T)
{
    return dfs(T, INT_MIN, INT_MAX);
}

int main()
{
    BiTree T;
    InitBiTree(T);
    if (JudgeBST(T)) cout << "yes" << endl;
    else cout << "no" << endl;
    return 0;
}

7.设计一个算法，求出指定结点在给定二叉排序树中的层次。

#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

int level(BiTree T, ElemType w)
{
    int res = 0;
    BiTree p = T;
    if (T != NULL) {
        res++;
        while (p->data != w) {
            if (p->data < w) p = p->rchild;
            else p = p->lchild;
            res++;
        }
    }
    return res;
}

int main()
{
    ElemType w;
    BiTree T;
    InitBiTree(T);
    cin >> w;
    int ans = level(T, w);
    cout << ans << endl;
    return 0;
}

8.利用二叉树遍历的思想编写一个判断二叉树是否是平衡二叉树的算法。

#include <cmath>
#include <iostream>
using namespace std;

typedef char ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == '#') T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void Judge_AVL(BiTree bt, int &balance, int &h)
{
    int bl = 0, br = 0, hl = 0, hr = 0;
    if (bt == NULL) {
        h = 0;
        balance = 1;
    } else if (bt->lchild == NULL && bt->rchild == NULL) {
        h = 1;
        balance = 1;
    } else {
        Judge_AVL(bt->lchild, bl, hl);
        Judge_AVL(bt->rchild, br, hr);
        h = (hl > hr ? hl : hr) + 1;
        if (abs(hl - hr) < 2) balance = bl && br;
        else balance = 0;
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    int balance = 0, h = 0;
    Judge_AVL(T, balance, h);
    cout << balance << endl;
    return 0;
}

9.设计一个算法，求出给定二叉排序树中最小和最大的关键字。

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

typedef int ElemType;

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

ElemType Max_Element(BiTree T)
{
    while (T->rchild != NULL)
        T = T->rchild;
    return T->data;
}

ElemType Min_Element(BiTree T)
{
    while (T->lchild != NULL)
        T = T->lchild;
    return T->data;
}

void InitBiTree(BiTree &T)
{
    ElemType ch;
    scanf("%d ", &ch);
    if (ch == -1) T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

int main()
{
    BiTree T;
    InitBiTree(T);
    printf("%d %d\n", Max_Element(T), Min_Element(T));
    return 0;
}

10.设计一个算法，从大到小输出二叉排序树中所有值不小于k的关键字。

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

typedef int ElemType;

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

void InitBiTree(BiTree &T)
{
    ElemType ch;
    scanf("%d ", &ch);
    if (ch == -1) T = NULL;
    else {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        InitBiTree(T->lchild);
        InitBiTree(T->rchild);
    }
}

void OutPut(BiTree T, ElemType k)
{
    if (T == NULL) return;
    if (T->rchild != NULL) OutPut(T->rchild, k);
    if (T->data >= k) printf("%d ", T->data);
    if (T->lchild != NULL) OutPut(T->lchild, k);
}

int main()
{
    BiTree T;
    ElemType k;
    InitBiTree(T);
    scanf("%d", &k);
    OutPut(T, k);
    return 0;
}
Soft'Wind
关注
  • 9
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python数据结构树和二叉树简介
01-20
树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。它非常类似于自然界中的树。树的递归定义：树(Tree)是n(n≥0)个结点的有限集T，T为空时称为空树，否则它满足如下两个条件：(1)有...
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，编写一个算法ANCESTOR(ROOT,p,q,r),找
weixin_43405277的博客
04-23 1774
设一棵二叉树的结点结构为(LLINK,INFO,RLINK）ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，编写一个算法ANCESTOR(ROOT,p,q,r),找到p和q的最近公共祖先结点. 思路: 采用非递归后续遍历算法,因为在访问一个结点p时,栈中结点恰好是p结点的所有祖先,从栈底到栈顶结点再加上p结点,刚好构成从根结点到p结点的一条路径. 栈内数据: 伪代码: BiTree Ancestor(BiTree ROOT,BiTNode *p,BiTNode *q
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，试编写一个算法ANCESTOR(ROOT,p,q,r)，
syh666233的博客
09-09 1845
思路：在做这道题之前，如果知道怎么求某个结点所有祖先结点就很好求了。在这个前提下，我们把p的祖先和q的祖先分别存放在两个栈里面，并且设p在q的左边，那么p的祖先一定也是q的祖先，然后对比两个栈中的元素，第一个相等的元素就是最近的公共祖先结点，下面是示意图， 把路径都找到过后，就挨个出栈，并且比较。 代码没时间写了，以后有时间再更吧，不过如果会写某个结点所有祖先的那道题，这道题其实是一样的。 ...
二叉树的遍历和线索二叉树 p126 3-18
云淡风轻_的博客
09-14 1727
3.编写后序遍历二叉树非递归算法 后序非递归遍历二叉树的顺序是先访问左子树，再访问右子树，最后访问根节点，当用堆栈来存储节点时必须分清返回根节点时是从左子树返回的还是从右子树返回的。所以使用辅助指针r，其指向最近访问过的结点。也可在节点中增加一个标志域，记录是否已经被访问过。 void PostOrder(BiTree T){ InitStack(S); Bnode *p=T,*r=NULL; while(p||!IsEmpty){ if(p){ push(S,p); p=p
王道——数据结构——树与二叉树（3）
不会就用洛必达的博客
05-03 963
系列文章目录 王道——数据结构——树与二叉树（1） 王道——数据结构——树与二叉树（2） 文章目录系列文章目录前言一、5.3节 前言 本文为王道数据结构的第五章——树与二叉树的编程题。 运行软件：vscode 使用c++文件编写 本文所使用的树为《王道——数据结构——树与二叉树（1）》中建立的树 一、5.3节 11、已知二叉树以二叉链表存储，编写算法完成：对于树中的每个元素值为x的结点，删去以它为根节点的子树，并释放相应的空间。 // 第十一题 使用层次遍历主树，发现结点值为x时，对x的子树进行后续
2024王道数据结构大题p143-p144（二）
weixin_47098905的博客
04-26 337
【代码】2024王道数据结构大题p143-p144。
数据结构与算法：树和二叉树.pptx
05-11
【练习】 下图(b)中各结点的度与树的度分别是多少？ ;⑶ 叶子(left)结点、非叶子结点：树中度为0的结点称为叶子结点(或终端结点)。相对应地，度不为0的结点称为非叶子结点(或非终端结点或分支结点)。除根结点外，...
数据结构与算法实验（C++）：二叉树实验-代码
最新发布
01-18
1.内容概要： （1）实验目的： 1）熟练掌握二叉链的存储特点； 2）熟练掌握二叉树的基本操作； 3）熟练掌握基于二叉链的二叉树操作算法实现； 4）能灵活使用二叉树解决具体的问题。...数据结构与算法实验
【C语言->数据结构与算法】->树与二叉树概念&哈夫曼树的构造
01-07
树&二叉树&哈夫曼树Ⅰ 树A. 树的概念B. 树的表达形式（存储结构）C. 树的遍历a. 广度优先遍历（队列）b. 深度优先遍历（堆栈）Ⅱ. 二叉树A. 二叉树的有关概念B. 二叉树中相关公式C. 二叉树的存储结构Ⅲ 哈夫曼树及...
山东大学《数据结构》实验指导04树和二叉树.docx
12-17
山东大学《数据结构》实验指导04树和二叉树.docx
数据结构--树（c 代码部分）（王道书、考研适用）
m0_73918713的博客
08-02 205
【代码】数据结构--树（c 代码部分）
王道数据结构代码——二叉树
qq_53381910的博客
08-05 973
王道数据结构代码——二叉树
王道数据结构代码---第五章：二叉树（重要）
jinzhi66的博客
07-17 1043
二叉树
王道数据结构代码题（C语言）二叉树
Cerulea_n的博客
06-29 113
考研数据结构（每日一题）day34
DTRblank的博客
04-02 293
考研数据结构（每日一题） 题目：设一棵二叉树的结点结构为(LLINK,INFO,RLINK)，ROOT为指向该二叉树根结点的指针，p和q分别指向该二叉树中任意两个结点的指针，试编写算法ANCESTOR(ROOT,p,q,r)找到p和q的最近公共祖先结点r。 算法思想： 这道题的目的是了解后序遍历的特性，在遍历中，栈内元素都是当前元素的直系祖先。栈存在是意义：访问到了，但是还没有轮到它输出，因为顺序是左右根，它是根，所以现在还不能输出，入栈了，接下来访问它的左右孩子。 采用后序非递归算法，栈中存放二叉树结点的
王道考研408 数据结构 5.3 二叉树的遍历和线索二叉树
weixin_46524058的博客
10-06 492
太长不看
数据结构树习题（一）
无知的我
11-07 2710
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，试编写一个算法ANCESTOR(ROOT,p,q,r)，该算法找到p和q的最近共同祖先结点r 分析：本题要找p和q的最近共同祖先结点r，不失一般性，设p在q的左边。采用后续非递归算法，栈中存放二叉树结点的指针，当访问到某结点时，栈中所有元素均为该结点的祖
王道课后练习之二叉树的非递归后序遍历
qq_40066238的博客
11-22 794
首先毫无疑问，非递归的后续遍历必定要借助栈来实现，我们先用祖传的二叉树做个开头 根据页面提示，我们知道它的后序遍历结果为 7 -> 3 -> 4 -> 1 -> 5 -> 6 -> 2 -> 0 点击此处可以访问这个在线生成二叉树的页面 现在用Java实现代码，我们对节点Node及相关操作定义如下： class Node{ int data; Node left_child,right_child; Node parent; p
二叉树先序、中序、后序遍历的非递归算法 非递归先序、中序、后序遍历二叉树
辣鸡的博客
08-07 669
//非递归实现中序遍历 stack<BiTree*> bs; void preOrderTraversal(BiTree* t) { BiTree *p=t; while (p||!bs.empty()) { if (p) { bs.push(p); p=p->lc; } else { p=bs.top(); bs.pop(); pr...
王道考研408数据结构二叉树
08-02
王道考研408数据结构中关于二叉树的内容主要包括二叉树的遍历（先序、中序和后序）和平衡二叉树（AVL）及其旋转。[1]此外，对于初学数据结构的同学，推荐一本名为《大话数据结构》的书，该书内容深入浅出，有条有理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值