二叉树代码实现笔记

最新推荐文章于 2023-09-22 22:47:30 发布
最新推荐文章于 2023-09-22 22:47:30 发布
阅读量4k 收藏 3
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minghe_uestc/article/details/10729903
版权

二叉树

定义节点

class Node {
public:
    int key;
    struct Node *l;
    struct Node *r;
    Node(int _key): l(NULL), r(NULL), key(_key) {}
};

二叉树上一个节点，最少需要三个属性，一个用于表示节点编号的key值，一个指向左子节点的指针、一个指向右子节点的指针。

定义一棵树

class BTree {
public:
    BTree() : root(NULL) {}
    void insert(int key);
    void insertRoot(int key);
    void deleteNode(int key);
    void print();

private:
    Node *root;
private:
    // 向h树指向的树中添加元素key，返回更新后的树
    static Node *insertR(Node *h, int key);
    // 右旋操作，可以令左子树深度减一，返回旋转后的树
    static Node *rotateR(Node *h);
    // 左旋操作，可以令右子树深度减一，返回旋转后的树
    static Node *rotateL(Node *h);
    // 将h树最小的元素上浮到树根部，返回最后上浮后的树
    static Node *minToRoot(Node *h);
    // 将两棵树合并成一棵树，返回合并后的树
    static Node *join(Node *l, Node *r);
    // 向h树中插入元素，并且插入的元素会存在树根部，返回插入后的树
    static Node *insertT(Node *h, int key);
    // 中序遍历h树
    static void inOrder(Node *h);
    // 从h树中删除key，返回删除后的树
    static Node *deleteR(Node *h, int key);
};



树的操作很多，以上只是列举其中的一些操作，对于代码实现，难点反而在于正确理解递归调用，二叉树的性质反而很简单。只要能够理解这些递归调用的特点，添加新的操作方法反而不是太难。

封装

void BTree::insert(int key) {
    this->root = insertR(this->root, key);
}

void BTree::insertRoot(int key) {
    this->root = insertT(this->root, key);
}

void BTree::print() {
    inOrder(this->root);
}

void BTree::deleteNode(int key) {
    this->root = deleteR(this->root, key);
}

树的很多操作通过递归可以很容易的实现，所以需要对这些递归操作进行封装，可以简化外部操作。


插入元素

Node *BTree::insertR(Node *h, int key) {
    if (h == NULL) return new Node(key);
    if (h->key < key) {
        h->r = insertR(h->r, key);
    } else {
        h->l = insertR(h->l, key);
    }
    return h;
}


插入元素必须递归地向树根部游走，直到遇到树根部，然后插入元素，再依次退回。递归调用的过程就是向下游走的过程，遇到NULL，表明已经走到树根部。

这里比较绕的就是返回值的语义，它表示插入元素后新生成的树。


旋转

Node *BTree::rotateR(Node *h) {
    if (h->l == NULL) return h;
    Node *x = h->l;
    h->l = x->r;
    x->r = h;
    return x;
}

Node *BTree::rotateL(Node *h) {
    if (h->r == NULL) return h;
    Node *x = h->r;
    h->r = x->l;
    x->l = h;
    return x;
}

树的旋转操作很有意思，它可以在不更改树的性质的情况下，改变左右子树的高度
  • 左旋操作：可以让右子树高度减一，左子树高度加一，让原有的右子树的根节点称为旋转后子树的根节点，让原有子树的根节点变成其左子树的根节点
  • 右旋操作：与左旋操作相反。

合并子树

Node *BTree::minToRoot(Node *h) {
    if (h->l != NULL)  {
        h->l = minToRoot(h->l); // 将最小元素提升到左子树的根部
        h = rotateR(h); // 将左子树中最小元素提升到根部
    }
    return h;
}

Node *BTree::join(Node *l, Node *r) {
    if (r == NULL) return l;
    r = minToRoot(r); // 将r树的最小元素提升到根节点
    r->l = l;
    return r;
}

合并子树的操作也很有趣(这里的合并不是任意两个子树合并，而是左子树中任意元素必须小于右子树中最小的元素)：
  • 首先是如何将一颗树的最小元素提升到根：一颗树的最小元素永远在树最左边的节点处，所以不断向左游走就可以到达最小元素点处，然后依靠之前的右旋操作可知，右旋可以将左子节点提升，所以在递归返回的时候最小的元素就会不断上浮到达整棵树的根部。
  • 然后是如何连接两棵树：首先将需要作为连接后右子树利用minToRoot操作将其最小元素上浮到根部，根据树的性质，上浮后这个树根的左子节点必然为NULL，所以这时候就可以直接指向左子树了。
如果希望将任意两棵树进行合并，则要麻烦许多。

特殊的插入(根插入)

Node *BTree::insertT(Node *h, int key) {
    if (h == NULL) return new Node(key);
    if (h->key > key) {
        h->l = insertT(h->l, key);
        h = rotateR(h); // 右旋操作让左子树深度减一
    } else {
        h->r = insertT(h->r, key);
        h = rotateL(h);
    }
    return h;
}

这个代码可以帮助更好的理解左旋与右旋操作，向左子树插入，则通过右旋可以让左子树深度减一，反之亦然。最后插入的元素会不断的上浮返回到根部，所以称作为根插入。

删除节点

Node *BTree::deleteR(Node *h, int key) {
    if (h == NULL) return h;
    if (h->key == key) { // 关键字相同
        Node *x = h;
        h = join(h->l, h->r); // 合并左右两个子树
        delete x;
    } else if (h->key < key) {
        h->r = deleteR(h->r, key); // 在右子树中删除key
    } else {
        h->l = deleteR(h->l, key); // 在左子树中删除key
    }
    return h;
}

删除操作比较复杂，但是如果可以理解之前的join操作，那就很容易理解这个代码：
利用join操作将删除节点后空余出来的两个子树合并成一棵树，这样就解决了删除时候复杂的操作了。


小结

二叉树是所有树中最简单的，其实现也很容易理解，只要能够体会这些操作中的递归操作的语义即可。

普通二叉树代码

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

class Node {
public:
    int key;
    struct Node *l;
    struct Node *r;
    Node(int _key): l(NULL), r(NULL), key(_key) {}
};

class BTree {
public:
    BTree() : root(NULL) {}
    void insert(int key);
    void insertRoot(int key);
    void deleteNode(int key);
    void print();

private:
    Node *root;

private:
    // 向h树指向的树中添加元素key，返回更新后的树
    static Node *insertR(Node *h, int key);
    // 右旋操作，可以令左子树深度减一，返回旋转后的树
    static Node *rotateR(Node *h);
    // 左旋操作，可以令右子树深度减一，返回旋转后的树
    static Node *rotateL(Node *h);
    // 将h树最小的元素上浮到树根部，返回最后上浮后的树
    static Node *minToRoot(Node *h);
    // 将两棵树合并成一棵树，返回合并后的树
    static Node *join(Node *l, Node *r);
    // 向h树中插入元素，并且插入的元素会存在树根部，返回插入后的树
    static Node *insertT(Node *h, int key);
    // 中序遍历h树
    static void inOrder(Node *h);
    // 从h树中删除key，返回删除后的树
    static Node *deleteR(Node *h, int key);
};

void BTree::insert(int key) {
    this->root = insertR(this->root, key);
}

void BTree::insertRoot(int key) {
    this->root = insertT(this->root, key);
}

void BTree::print() {
    inOrder(this->root);
}

void BTree::deleteNode(int key) {
    this->root = deleteR(this->root, key);
}

Node *BTree::insertR(Node *h, int key) {
    if (h == NULL) return new Node(key);
    if (h->key < key) {
        h->r = insertR(h->r, key);
    } else {
        h->l = insertR(h->l, key);
    }
    return h;
}

Node *BTree::rotateR(Node *h) {
    if (h->l == NULL) return h;
    Node *x = h->l;
    h->l = x->r;
    x->r = h;
    return x;
}

Node *BTree::rotateL(Node *h) {
    if (h->r == NULL) return h;
    Node *x = h->r;
    h->r = x->l;
    x->l = h;
    return x;
}

Node *BTree::minToRoot(Node *h) {
    if (h->l != NULL)  {
        h->l = minToRoot(h->l); // 将最小元素提升到左子树的根部
        h = rotateR(h); // 将左子树中最小元素提升到根部
    }
    return h;
}

Node *BTree::join(Node *l, Node *r) {
    if (r == NULL) return l;
    r = minToRoot(r); // 将r树的最小元素提升到根节点
    r->l = l;
    return r;
}

Node *BTree::insertT(Node *h, int key) {
    if (h == NULL) return new Node(key);
    if (h->key > key) {
        h->l = insertT(h->l, key);
        h = rotateR(h); // 右旋操作让左子树深度减一
    } else {
        h->r = insertT(h->r, key);
        h = rotateL(h);
    }
    return h;
}

void BTree::inOrder(Node *h) {
    if (h == NULL) return;
    inOrder(h->l);
    cout << h->key << " ";
    inOrder(h->r);
}

Node *BTree::deleteR(Node *h, int key) {
    if (h == NULL) return h;
    if (h->key == key) { // 关键字相同
        Node *x = h;
        h = join(h->l, h->r); // 合并左右两个子树
        delete x;
    } else if (h->key < key) {
        h->r = deleteR(h->r, key); // 在右子树中删除key
    } else {
        h->l = deleteR(h->l, key); // 在左子树中删除key
    }
    return h;
}

int main() {
    int a[] = {3, 2, 1, 4, 9, 8, 6, 7, 5};
    BTree t;
    for (int i = 0; i < 9; i++)
        t.insert(a[i]);

    t.insertRoot(4);
    t.print();
    cout << endl;
    t.deleteNode(4);
    t.print();
    return 0;
}


在节点中加入计数域

在节点中加入计数域后，算法的灵活度就得到许多改变。

加入计数域后的代码

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

class Node {
public:
    int key;
    Node *l;
    Node *r;
    int size; // = 树节点数
    Node(int _key): l(NULL), r(NULL), key(_key), size(1) {}
};

class BTree {
public:
    BTree() : root(NULL) {}
    void insert(int key);
    void insertRoot(int key);
    void deleteNode(int key);
    void print();
    int select(int k);
    void kToRoot(int k);
    void balance();

private:
    Node *root;

private:
    // 向h树指向的树中添加元素key，返回更新后的树
    static Node *insertR(Node *h, int key);
    // 右旋操作，可以令左子树深度减一，返回旋转后的树
    static Node *rotateR(Node *h);
    // 左旋操作，可以令右子树深度减一，返回旋转后的树
    static Node *rotateL(Node *h);
    // 将h树最小的元素上浮到树根部，返回最后上浮后的树
    static Node *minToRoot(Node *h);
    // 将两棵树合并成一棵树，返回合并后的树
    static Node *joinR(Node *l, Node *r);
    // 向h树中插入元素，并且插入的元素会存在树根部，返回插入后的树
    static Node *insertT(Node *h, int key);
    // 中序遍历h树
    static void inOrder(Node *h);
    // 从h树中删除key，返回删除后的树
    static Node *deleteR(Node *h, int key);
    // 从h中找到第k大的元素，返回元素的指针
    static Node *selectR(Node *h, int k);
    // 从h中找到第k大的元素，然后将其提升到树根部，返回更新后的树
    static Node *partR(Node *h, int k);
    // 将h树转换成平衡二叉树(不是完全平衡二叉树)，返回平衡后的树
    static Node *balanceR(Node *h);
    // 组合任意的两棵树
    static Node *joinLR(Node *l, Node *r);
};

void BTree::insert(int key) {
    this->root = insertR(this->root, key);
}

void BTree::insertRoot(int key) {
    this->root = insertT(this->root, key);
}

void BTree::print() {
    inOrder(this->root);
}

void BTree::deleteNode(int key) {
    this->root = deleteR(this->root, key);
}

int BTree::select(int k) {
    if (k < 0 || k >= root->size)
        return -1;
    Node *ret = selectR(this->root, k);
    return (ret == NULL) ? -1 : ret->key;
}

void BTree::kToRoot(int k) {
    if (k < 0 || k >= root->size) return;
    this->root = partR(root, k);
}

void BTree::balance() {
    this->root = balanceR(this->root);
}

Node *BTree::insertR(Node *h, int key) {
    if (h == NULL) return new Node(key);
    if (h->key < key) {
        h->r = insertR(h->r, key);
    } else {
        h->l = insertR(h->l, key);
    }
    h->size++;
    return h;
}

Node *BTree::rotateR(Node *h) {
    if (h->l == NULL) return h;
    Node *x = h->l;
    h->l = x->r;
    x->r = h;
    // 重新计算旋转后h和x子树的大小
    h->size = 1; x->size = 1;
    if (h->l != NULL) h->size += h->l->size;
    if (h->r != NULL) h->size += h->r->size;
    if (x->l != NULL) x->size += x->l->size;
    if (x->r != NULL) x->size += x->r->size;
    return x;
}

Node *BTree::rotateL(Node *h) {
    if (h->r == NULL) return h;
    Node *x = h->r;
    h->r = x->l;
    x->l = h;
    // 重新计算旋转后h和x子树的大小
    h->size = 1; x->size = 1;
    if (h->l != NULL) h->size += h->l->size;
    if (h->r != NULL) h->size += h->r->size;
    if (x->l != NULL) x->size += x->l->size;
    if (x->r != NULL) x->size += x->r->size;
    return x;
}

Node *BTree::minToRoot(Node *h) {
    if (h->l != NULL)  {
        h->l = minToRoot(h->l); // 将最小元素提升到左子树的根部
        h = rotateR(h); // 将左子树中最小元素提升到根部
    }
    return h;
}

Node *BTree::joinR(Node *l, Node *r) {
    if (r == NULL) return l;
    r = minToRoot(r); // 将r树的最小元素提升到根节点
    r->l = l;
    r->size += (r->l == NULL) ? 0 : r->l->size;
    return r;
}

Node *BTree::insertT(Node *h, int key) {
    if (h == NULL) return new Node(key);
    if (h->key > key) {
        h->l = insertT(h->l, key);
        h->size++;
        h = rotateR(h); // 右旋操作让左子树深度减一
    } else {
        h->r = insertT(h->r, key);
        h->size++;
        h = rotateL(h);
    }

    return h;
}

void BTree::inOrder(Node *h) {
    if (h == NULL) return;
    inOrder(h->l);
    cout << h->key << " ";
    inOrder(h->r);
}

Node *BTree::deleteR(Node *h, int key) {
    if (h == NULL) return h;
    if (h->key == key) { // 关键字相同
        Node *x = h;
        h = joinR(h->l, h->r); // 合并左右两个子树
        delete x;
    } else if (h->key < key) {
        h->r = deleteR(h->r, key); // 在右子树中删除key
    } else {
        h->l = deleteR(h->l, key); // 在左子树中删除key
    }
    return h;
}

Node *BTree::selectR(Node *h, int k) {
    if (h == NULL) return NULL;
    int t = (h->l == NULL) ? 0 : h->l->size;
    if (t == k) return h;
    if (t > k) {
        return selectR(h->l, k);
    } else {
        return selectR(h->r, k-t-1);
    }
}

Node *BTree::partR(Node *h, int k) {
    int t = (h->l == NULL) ? 0 : h->l->size;
    if (t == k) return h;
    if (t > k) {
        h->l = partR(h->l, k);
        h = rotateR(h);
    } else {
        h->r = partR(h->r, k-t-1);
        h = rotateL(h);
    }
}

Node *BTree::balanceR(Node *h) {
    if (h == NULL || h->size < 2) return h; // 当元素个数小于2时候，不用平衡
    h = partR(h, h->size / 2); // 将中间元素提升到根部
    h->l = balanceR(h->l); // 平衡左子树
    h->r = balanceR(h->r); // 平衡右子树
    return h;
}

Node *BTree::joinLR(Node *l, Node *r) {
    if (l == NULL) return r;
    if (r == NULL) return l;
    r = insertT(r, l->key);
    r->l = joinLR(l->l, r->l);
    r->r = joinLR(l->r, r->r);
    delete l; // 冗余节点，所以需要删除
    return NULL;
}

int main() {
    int a[] = {3, 2, 1, 4, 9, 8, 6, 7, 5};
    BTree t;
    for (int i = 0; i < 9; i++)
        t.insert(a[i]);

    t.insertRoot(4);
    t.print();
    cout << endl;
    t.deleteNode(4);
    t.print();

    cout << t.select(10) << endl;
    t.kToRoot(0);
    t.balance();
    return 0;
}


明何
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C+学习笔记+树、堆、二叉树代码
03-28
内容概要：通过简单的代码，用C语言实现了堆的一些相关接口，比如堆的初始化创建销毁，插入删除，堆排序，TOPK问题解决等等...还有一些链式二叉树的相关内容，在这里为了简单链式二叉树相关内容均是用递归的思路来...
数据结构-二叉树的代码实现（详解）
weixin_73142957的博客
07-11 2667
内容：二叉树的前、中，后序遍历，层序遍历，二叉树节点个数，叶子节点个数，二叉树高度，第k层节点的个数，查找某个节点，二叉树销毁，判断是否为完全二叉树
二叉树的实现（C语言数据结构）
芊樱烛渊的博客
05-23 8983
一、以下是我们需要实现的功能 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <stdbool.h> typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; stru
二叉树的代码实现
荧光百叶草的博客
08-03 522
二叉树（Binary Tree)是n（n≥0）个节点所构成的集合，它或为空树（n=0），或为非空树。对于非空树T: （1）有且仅有一个称之为根的节点； （2）除根节点以外的其余节点分为两个互不相交的子集T1和T2，分别称为T的左子树和右子树，且T1和T2本身又都是二叉树。 二叉树与树一样具有递归性质，二叉树与树的区别主要有以下两点： （1）二叉树每个节点至多只有两棵子树（二叉树中不存在度大于2的节点）; （2）二叉树的子树有左右之分，其次序不能任意颠倒。 二叉树的递归定义表明二叉树或为空，或由一个根节点加上
C语言【数据结构】二叉树实现
冰果滴的博客
06-16 1158
目录一.二叉树逐步实现1.创建结构体2.创建二叉树3.二叉树前序遍历4.二叉树中序遍历5.二叉树后序遍历6.二叉树层序遍历7.二叉树节点个数8.二叉树叶子节点个数9.二叉树第k层节点个数10.二叉树最大深度11.二叉树查找值为x的节点12.判断二叉树是否为完全二叉树13.二叉树销毁二.代码1.BinaryTree.h2.BinaryTree.c3.Test.c4.Queue.h5.Queue.c三.测试结果前言：二叉树的最后一篇，实现二叉树（才发现前面竟然忘记写了😢） 发现了就赶紧补上.
【二叉树教程详解以及C语言/C++实现二叉树】
qq_43884946的博客
06-30 1784
二叉树是一种特殊的树状数据结构，其中每个节点最多有两个子节点。每个节点包含一个数据元素和指向其左子节点和右子节点的指针。左子节点的值小于或等于父节点的值，而右子节点的值大于父节点的值。这个特性使得二叉树在查找、插入和删除操作方面非常高效。A / \B C / \ \D E F二叉树通常用于模拟具有层级结构的数据。它的一些常见应用包括搜索算法（例如二叉搜索树）、表达式树、哈夫曼编码树等。在二叉树中，我们可以使用不同的遍历方式来访问节点，包括先序遍历、中序遍历和后序遍历。
数据结构（C++）上课笔记——二叉树的C++实现(2020-5-11) .doc
05-21
数据结构（C++）上课笔记——二叉树的C++实现(2020-5-11) ，详细记录上课内容，附有二叉树调试成功的代码，很好的复习、编程参考资料
数据结构（C++）上课笔记——线索二叉树的概念与C++实现(2020-5-12).doc
05-21
数据结构（C++）上课笔记——线索二叉树的概念与C++实现(2020-5-12)，详细记录上课内容，并附有可调试成功的代码，很好的复习、编程参考资料
javalruleetcode-leetcode:leetcode刷题笔记python代码实现
06-29
leetcode刷题笔记 （Python3\JAVA） Easy 1.两数之和() () 7.反转整数() () 9.回文数() () 14.最长公共前缀() () 20.有效的括号() () 21.合并两个有序列表() () 53.最大子序列和() () 70.爬楼梯() () 88.合并两个...
完整学习笔记：《剑指offer》Java版代码实现
最新发布
10-31
第七题 使用两个栈实现队列 测试7 第八题 寻求旋转带宽的最小数字 测试8 第九题 斐波那契数列的第n项（青蛙跳台阶） 测试9 第十题 二进制中1的个数 测试10 第十一题 数值的整数次方 测试11 第十二题 打印1到最大的n...
【数据结构】二叉树相关函数代码实现
weixin_61909417的博客
09-22 124
到这相关的二叉树的一些基本性质就结束了，我们现在所学的二叉树都是为了以后学更复杂的二叉树做准备复杂的二叉树->二叉搜索树->AVL->红黑树学习二叉树注重的是结构递归的的层层调用函数栈帧的理解等本文若有地方有错，还请各位指正。如果觉得文章写得还不错能够帮得上你的希望能给一个三连，新人作者急需你的鼓励。需要本文代码全部实现的下方链接本文的全篇代码下篇预告，堆及堆排序。
【数据结构】二叉树的实现
m0_73367097的博客
05-13 1476
二叉树的实现
【数据结构】二叉树（C语言实现）
在平淡的日子里寻找存在的价值
08-15 5983
树和二叉树的基本介绍，以及基于C语言的链式二叉树的实现。
二叉树基本代码实现
m0_61548909的博客
03-30 4215
目录 1.二叉树的链式结构 2.二叉树的遍历 2.1先序遍历 2.2中序遍历 2.3后序遍历 3.二叉树的基本操作 3.1求二叉树结点个数 3.1.1全局遍历 3.1.2递归的思想分治 3.1.3局部变量 3.2求二叉树叶子结点个数 3.3求二叉树第K层结点个数 3.4求二叉树的深度/高度 3.5查找二叉树中值为x的结点 3.6二叉树的销毁 3.7运用队列实现广度优先的层序遍历 1.二叉树的链式结构 typedef int BTDataType; typ
二叉树的编程与实现（C语言）
热门推荐
timerring的博客
07-10 5万+
一 、目的： 掌握指针变量、动态变量的含义； 掌握二叉树的结构特征，以及各种存储结构的特点及适用范围； 掌握指针类型描述、访问和处理二叉树的运算三 、内容： 已知以二叉树表作为存储结构，写出按层次顺序遍历二叉树的算法。 算法思想：本算法采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点，若它有左子树，便将左子树根结点入队列；若有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。 四 、要求： 实现二叉树表的层次遍历算法，并给出应用。
数据结构之二叉树（C语言附详细代码）
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
二叉树代码实现
linzexin_ll的博客
03-18 100
1.建立二叉树。 二叉树如图所示 #include <stdio.h> #include <stdlib.h> //定义结点 typedef struct node { int data; struct node* left; struct node* right; }Node; int main(){ //用typedef了struct，并起名字为NODE以后可以简便一点声明一个结点 //struct node n1;
Java的数据结构之路——二叉树（代码实现）
m0_62747332的博客
10-14 1699
二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分。二叉树是n个有限元素集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点。（以上来自百度对二叉树的解释）
二叉树实现（C语言完整代码+详细注释版）【数据结构】
小賀のBlog
08-16 1万+
注释详细完整且健壮的二叉树的顺序/链式以及线索二叉树实现与常规操作的代码： 二叉树的顺序实现 // // main.c // SqBiTree // // Created by Eason on 2020/8/7. // Copyright © 2020 Eason. All rights reserved. // #include <stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #defin
遍历序列还原二叉树代码实现
05-26
遍历序列还原二叉树可以通过递归的方式实现。具体步骤如下： 1. 根据前序遍历序列，确定根节点，创建一个新的二叉树节点。 2. 在中序遍历序列中，找到根节点的位置，将中序遍历序列分成左子树和右子树两个部分。 3. 根据左子树的前序遍历序列和中序遍历序列，递归构造左子树。 4. 根据右子树的前序遍历序列和中序遍历序列，递归构造右子树。 5. 将左右子树分别作为根节点的左右子节点。 下面是 Python 代码实现： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def buildTree(preorder: List[int], inorder: List[int]) -> TreeNode: if not preorder or not inorder: return None root_val = preorder[0] root = TreeNode(root_val) idx = inorder.index(root_val) root.left = buildTree(preorder[1:idx+1], inorder[:idx]) root.right = buildTree(preorder[idx+1:], inorder[idx+1:]) return root ``` 其中，`preorder` 为前序遍历序列，`inorder` 为中序遍历序列。函数返回重建的二叉树的根节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值