二叉树操作模板

最新推荐文章于 2023-02-23 22:33:40 发布
最新推荐文章于 2023-02-23 22:33:40 发布
阅读量141 收藏
点赞数
分类专栏： leetcode解题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41964962/article/details/104823898
版权

二叉树的操作模板

  • 使用递归进行遍历、查找、插入、删除、判断合法性

二叉树的遍历

先序遍历
void preorder(TreeNode* root){
	if(!root) return ;
	nums.push_back(root->val);
	preorder(root->left);
	preorder(root->right);
}

递归版本：

vector<int> preorder(TreeNode* root){
	vector<int> result;
	stack<TreeNode*> st;
	TreeNode* node = root;
	while(node || !st.empty()){
		while(node){
			st.push(node);
			result.push_back(node->val);
			node = node->left;
		}
		if(!st.empty()){
			auto t = st.top();
			st.pop();
			node = t->right;
		}
	}
	return result;
}
中序遍历
void inorder(TreeNode* root){
	if(!root) return ;
	inorder(root->left);
	nums.push_back(root->val);
	inorder(root->right);
}

递归版本：

vector<int> preorder(TreeNode* root){
	vector<int> result;
	stack<TreeNode*> st;
	TreeNode* node = root;
	while(node || !st.empty()){
		while(node){
			st.push(node);
			node = node->left;
		}
		if(!st.empty()){
			auto t = st.top();
			st.pop();
			result.push_back(node->val);
			node = t->right;
		}
	}
	return result;
}
后序遍历
void postorder(TreeNode* root){
	if(!root) return;
	postorder(root->left);
	postorder(root->right);
	nums.push_back(root->val);
}

递归版本：

vector<int> postorderTraversal(TreeNode* root) {
 	vector<int> result;
    stack<pair<TreeNode*,int>> st;
    TreeNode* node = root;
    if(!root) return result;
    while(node || !st.empty()){
        while(node){
            st.push(make_pair(node,1));
            node = node->left;
        }
        if(!st.empty()){
            auto& t = st.top();
            auto n = t.first;
            if(t.second == 0){
                st.pop();
                result.push_back(n->val);
            }else{
                if(n->right)
                    node = n->right;
                t.second = 0;
            }
        }
    }
    return result;
}
层次遍历
  • 二叉树是无环的图，层次遍历使用BFS
  • 可以使用 BFS+ Queue 来实现，也可以使用递归来实现
class Solution {
    void levelOrder(TreeNode* node,vector<vector<int>>& res,int level){
        if(!node) return ;
        if(res.size() <= level) res.push_back({});
        res[level].push_back(node->val);
        levelOrder(node->left,res,level+1);
        levelOrder(node->right,res,level+1);
    }
    typedef pair<TreeNode*,int> Pair;
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
        vector<vector<int>> res;
        levelOrder(root,res,0);
        return res;
    }
};

class Solution {
    typedef pair<TreeNode*,int> Pair;
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
        vector<vector<int>> res;
        queue<Pair> vertex;
        vertex.push({root,0});
        while(vertex.size()){
            auto cur = vertex.front();
            vertex.pop();
            auto node = cur.first;
            if(!node) continue;
            if(res.size()<=cur.second) res.push_back({});
            res[cur.second].push_back(node->val);
            vertex.push({node->left,cur.second+1});
            vertex.push({node->right,cur.second+1});
        }
        return res;
    }
};
宽度遍历
  • 设节点的索引为i，则其左节点的索引为 i ∗ 2 i*2 i∗2,右节点的索引为 i ∗ 2 + 1 i*2+1 i∗2+1
  • 所谓宽度遍历就是在层次遍历的时候，额外携带父节点的索引信息，则可以对每层的节点进行操作
class Solution {
    vector<vector<double>> table;
    int Height(TreeNode* root){
        if(!root) return 0;
        return max(Height(root->left),Height(root->right)) + 1;
    }
    void helper(TreeNode* root,int level,double index){
        if(!root) return;
        //记录每层中最左和最右节点的索引
        if(table[level][0] == -1) table[level][0] = index;
        else{
            table[level][1] = index;
        }
        double m = index*2;
        helper(root->left,level + 1,m);
        helper(root->right,level + 1,m+1);
    }
public:
    int widthOfBinaryTree(TreeNode* root) {
        int h = Height(root);
        int size = pow(2,h);
        table = vector<vector<double>>(h,vector<double>(2,-1));
        helper(root,0,0);
        double ans = 0;
        //统计
        for(auto& it : table){
            if(it[1] == -1){
                ans = max<double>(ans,1);
            }else{
                ans = max(ans,it[1] - it[0] + 1);
            }
        }
        return ans;

    }
};
  • 可以发现，先/中/后序遍历其实就是什么时候对当前节点进行操作
  • 先序： 先记录当前节点，在遍历左子树、右子树
  • 中序： 先遍历左子树，再记录当前节点，再遍历右子树
  • 后续： 先遍历左子树，再遍历右子树，最后记录当前节点

查找给定数字是否存在二叉树中

普通的二叉树
bool isExist(TreeNode* root,int target){
	if(!root) return false;
	if(root->val == target) return true;
	return isExist(root->left,target) || isExist(root->right,target);
}
二叉搜索树
  • 使用BST的性质，搜索时候进行二分
bool isExist(TreeNode* root,int target){
	if(!root) return false;
	if(root->va == target) return true;
	else if(root->val < target)
		return isExist(root->right,target);
	else return isExist(root->left,left);
}

二叉搜索树中第K小元素


class Solution { 
	// cnt 来记录当前遍历的节点数目
    int cnt = 0;   
    //val保存第k小的结果
    int val;
    void inorder(TreeNode* root,int k){
        if(!root) return ;
        inorder(root->left,k);
        cnt++;
        if(cnt == k){
            val = root->val;
            return;
        }
        inorder(root->right,k);
    }
public:
    int kthSmallest(TreeNode* root, int k) {
        inorder(root,k);
        return val;
    }
};

BST的最小/最大值

TreeNode* Mininum(TreeNode* root){
	if(!root) return nullptr;
	if(!root->left) return root;
	return Mininum(root->left);
}

TreeNode* Maxinum(TreeNode* root){
	if(!root) return nullptr;
	if(!root->right) return root;
	return Maxinum(root->right);
}

BST 前驱/后继

TreeNode* Successor(TreeNode* root,int val){
	if(!root) return nullptr;
	auto* l = Successor(root->left,val);
	if(l) return l;
	if(root->val > val) return root;
	auto* r = Successor(root->right,val);
	if(r) return r;
	return nullptr;
}

TreeNode* Precursor(TreeNode* root,int val){
	if(!root) return nullptr;
	auto* r = Precursor(root->right,val);
	if(r) return r;
	if(root->val < val) return root;
	auto* l = Precursor(root->left,val);
	if(l) return l;
	return nullptr;
}

相同的树

  • 使用先序遍历模板
  • 如果当前节点都是null 或者值相同，则当前节点相同，继续比较左右子树节点
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(!p && !q) return true;
        if(!p || !q || p->val != q->val) return false;
        return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
    }
};

对称二叉树

class Solution {
public:
    bool ismirror(TreeNode* p,TreeNode* q){
        if(!p && !q) return true;
        if(!p || !q || p->val != q->val) return false;
        return ismirror(p->left,q->right) && ismirror(p->right,q->left);
    }
    bool isSymmetric(TreeNode* root) {
        return ismirror(root,root);
    }
};

合并二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        // 使用先序遍历框架，返回当前节点
        if(!t1 && !t2) return nullptr;
        TreeNode* root = new TreeNode(0);
        TreeNode* l1 = nullptr,*l2 = nullptr,*r1 = nullptr,*r2 = nullptr;
        if(t1){
            root->val += t1->val;
            l1 = t1->left;r1 = t1->right;
        }
        if(t2){
            root->val += t2->val;
            l2 = t2->left;r2 = t2->right;
        }
        root->left = mergeTrees(l1,l2);
        root->right = mergeTrees(r1,r2);
        return root;
    }
};
反转二叉树
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
       if(!root) return nullptr;
       auto* l = invertTree(root->left);
       root->left = invertTree(root->right);
       root->right = l;
       return root;
    }
};

判断合法性

判断是否是二叉搜索树
  • 节点的左子树只包含小于当前节点的数
  • 节点的右子树只包含大于当前节点的数
  • 所有左子树和右子树自身必须也是二叉搜索树
class Solution {
	// 携带额外信息，从上层节点传入的最大值和最小值
    bool isValidBST(TreeNode* root,TreeNode* min,TreeNode* max){
        if(!root) return true;
        
        if(min && root->val <= min->val){
            return false;
        }
        if(max && root->val >= max->val){
            return false;
        }
        return isValidBST(root->left,min,root) && isValidBST(root->right,root,max);
    }
public:
    bool isValidBST(TreeNode* root) {
        return isValidBST(root,nullptr,nullptr);
    }
};
判断是否是平衡二叉树
class Solution {
    int depth(TreeNode* root){
        if(!root) return 0;
        int l = depth(root->left);
        if(l < 0) return -1;
        int r = depth(root->right);
        if(r < 0) return -1;
        if(abs(l-r) > 1) return -1;
        return max(l,r) + 1;
    }
public:
    bool isBalanced(TreeNode* root) {
        return depth(root) != -1;
        
    }
};
验证二叉树
class Solution {
public:
    bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
        // a.不能有环，b.不能逆向，c.不能有多棵树
        //每一个节点只能有一个父节点，使用一个unordered_map来记录每个节点的信息，每次插入新节点前，先查询父节点是否存在(解决c),再查询map中是否有新节点(解决a和b)

        unordered_map<int,int> map;
        int i  = 0;
        while(i < n &&leftChild[i] == -1 && rightChild[i] == -1) i++;
        map[i] = i;
        while(i < n){
            // 该行验证父节点是否存在
            if(map.count(i) == 0) return false;
            int l = leftChild[i],r = rightChild[i];
            if(l != -1){
                //该行验证节点是否已经被使用，如果被使用过，可能会形成逆向和有环
                if(map.count(l) != 0) return false;
                map[l] = i;
            }
            if(r != -1){
                if(map.count(r) != 0) return false;
                map[r] = i;
            }
            i++;
        }
        return true;
    }
};

插入

二叉搜索树的插入操作
  • 递归插入
  • 使用后续遍历的模板，找到新值的位置插入
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(!root) return new TreeNode(val);
        if(root->val > val){
            root->left = insertIntoBST(root->left,val);
        }else{
            root->right = insertIntoBST(root->right,val);
        }
        return root;
    }
};
  • 非递归插入
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        auto* node = new TreeNode(val);
        TreeNode* x=nullptr,*y = root;
        while(y){
            x = y;
            if(y->val > val) y = y->left;
            else y = y->right;
        }
        if(!x)  root = node;
        else if(x->val > val) x->left = node;
        else x->right = node;
        return root;
    }
};

BST 删除节点

  • 设要删除的节点为Z
  • 如果 Z 没有孩子节点，则直接删除Z
  • 如果Z只有一个孩子节点，用孩子节点替代Z
  • 如果Z有2个孩子节点，则需要找到Z的后继节点X和X的父节点

    用X的right节点替代X，再用X替代Z

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return nullptr;
        //找到该节点
        if(root->val == key){
        	// 无孩子节点和只有一个孩子节点的情况
            if(!root->left) return root->right;
            if(!root->right) return root->left;
            // 2个孩子节点
            TreeNode* x = root,*y = root->right;
            // 找到后继节点和后继节点的父节点
            while(y->left){
                x = y;
                y = y->left;
            }
            // 后继节点y不是root->right节点时，需要先把y->right替代y,再把y替代root->right;
            if(x != root){
                x->left = y->right;
                y->right = root->right;
            }
            y->left = root->left;
            delete root;
            return y;
        }
        if(root->val > key)
            root->left = deleteNode(root->left,key);
        else if(root->val < key)
            root->right = deleteNode(root->right,key);
        return root;
    }
};

二叉树剪枝

分析
  • 要求： 返回移除了所有不包含 1 的子树的原二叉树
  • 重点在于删除 所有不包含1的子树
  • 不包含1的子树：所有节点都是0，
  • 那么从叶子节点开始往上走，只要节点值为0且该节点无左右节点，则本节点需要删除。
  • 总体查找的时候需要按照后序遍历思路
class Solution {
public:
    TreeNode* pruneTree(TreeNode* root) {
        if(!root) return nullptr;
        root->left = pruneTree(root->left);
        root->right = pruneTree(root->right);
        if(root->val == 0 && !root->left && ! root->right)
            return nullptr;
        else return root;
    }
};

一个比较完整的BST 类

  • BST.hxx
#pragma once 
#include <vector>
#include <string>
#include <stdexcept>

struct TreeNode{
    int val;
    TreeNode* left = nullptr;
    TreeNode* right = nullptr;
    TreeNode(int v):val(v){}
};

class BST{
private:
    TreeNode* root = nullptr;
    TreeNode* DeleteTree(TreeNode* node);
    void InsertNode(TreeNode* node);
    TreeNode* SearchNode(int v);
    void Depth(TreeNode* r,int&depth,int temp);
    int Depth(TreeNode* r);
    TreeNode* MaxNode(TreeNode* r){
        if(!r) return nullptr;
        while(r->right)
            r = r->right;
        return r;
    }
    TreeNode* MaxNode(){
        return MaxNode(root);
    }
    TreeNode* MinNode(TreeNode* r){
        if(!r) return nullptr;
        while(r->left)
            r = r->left;
        return r;
    }
    TreeNode* MinNode(){
        return MinNode(root);
    }
    void PreOrder(TreeNode* r,std::vector<int>& res);
    void InOrder(TreeNode* r,std::vector<int>& res);
    void PostOrder(TreeNode* r,std::vector<int>& res);
    
public:
    BST(){}
    ~BST(){
        DeleteTree(root);
    }
    void Put(int v){
        TreeNode* node = new TreeNode(v);
        InsertNode(node);
    }
    TreeNode* Get(int v){
        return SearchNode(v);
    }
    // 递归操作
    void PreOrder(std::vector<int>& res);
    void InOrder(std::vector<int>& res);
    void PostOrder(std::vector<int>& res);
    // 非递归
    std::vector<int> PreOrder();
    std::vector<int> InOrder();
    std::vector<int> PostOrder();
    std::vector<std::vector<int>> LevelOrder();
    TreeNode* DeleteNode(int v);
    TreeNode* Successor(int v);
    TreeNode* Predecessor(int v);
    int MaxVal(){
        TreeNode* m = MaxNode();
        if(!m){
            throw std::runtime_error("bst is empty");
        }
        return m->val;
    }
    int MinVal(){
        TreeNode* m = MinNode();
        if(!m)
            throw std::runtime_error("bst is empty");
        return m->val;
    }
    int Depth(){
        if(!root)
            return 0;
        return Depth(root);
    }
};
  • BST.cpp
#include "BST.hxx"
#include <stack>
#include <queue>
#include <utility>
#include <cmath>
#include <unordered_map>

TreeNode* BST::DeleteTree(TreeNode* node){
    if(!node){
        return nullptr; 
    }
    DeleteTree(node->left);
    DeleteTree(node->right);
    delete node;
    return nullptr;
}
void BST::InsertNode(TreeNode* node){
    TreeNode* r = root;
    TreeNode* p = nullptr;
    while(r){
        p = r;
        if(r->val < node->val){
            r = r ->right;
        }else if(r->val > node->val){
            r = r->left;
        }else{
            return;
        }
    }
    if(!p){
        root = node;
        return;
    }
    if(p->val < node->val)
        p->right = node;
    else
        p->left = node;  
}
TreeNode* BST::SearchNode(int v){
    if(!root){
        return nullptr;
    }
    TreeNode* r = root;
    while(r){
        if(r->val == v)
            return r;
        else if(r->val > v)
            r = r->left;
        else 
            r = r->right;
    }
    return nullptr;
}
// DFS 
void BST::Depth(TreeNode*r,int&depth,int temp){
    if(!r){
        depth = std::max(depth,temp);
        return;
    }
    Depth(r->left,depth,temp+1);
    Depth(r->right,depth,temp+1);
}
int BST::Depth(TreeNode* r){
    if(!r)
        return 0;
    int  depth = 1;
    Depth(r,depth,0);
    return depth;
}
TreeNode* BST::Predecessor(int v){
    // 1. find v node
    // 2. if v node has left node,then the predecessor
    // is the max node of left subtree of the v node
    // 3. otherwise, the predecessor must be its ancestor node,
    // which is the right node of parent
    
    std::unordered_map<TreeNode*,TreeNode*> path;
    TreeNode* r = root;
    TreeNode* p = nullptr;
    while(r){
        path[r] = p;
        if(r->val == v){
            break;
        }
        p = r;
        if (r->val < v){
            r = r->right;
        }else {
            r = r->left;
        }
    }
    TreeNode* vnode = r;
    // not find v node;
    if(!vnode){
        return nullptr;
    }
    if(vnode->left){
        return MaxNode(vnode->left);
    }
    while(p && p->left == vnode){
        vnode = p;
        p = path[vnode];
    }
    return p ? p : nullptr;
}
TreeNode* BST::Successor(int v){
    /**
     * 1. find vnode
     * 2. if vnode has right node,the successor is the min node of its right subtree
     * 3. otherwise,the successor must be its ancestor,which is the left node of its parent
    */
    TreeNode* r = root;
    TreeNode* p = nullptr;
    std::unordered_map<TreeNode*,TreeNode*> path;
    while(r){
        path[r] = p;
        if(r->val == v)
                break;
            p = r;
            if(r->val < v){
                r = r->right;
            }else
            {
                r = r->left;
            }
    }
    TreeNode* vnode = r;
    if(!vnode)
        return nullptr;
    if(vnode->right)
        return MinNode(vnode->right);
    
    while(p && p->right == vnode){
        vnode = p;
        p = path[vnode];
    }
    return p ? p : nullptr;
}

TreeNode* BST::DeleteNode(int v){
    /**
     * 1. find v node
     * 2. if v node is leaf, set left or right of its parent is nullptr
     * 3. if v node only has left node , let its left node replace vnode
     * 4. if v node only has right node, find minnode of its right subtree, 
     *    let minnode replace vnode
     * 5. if v node has left and right node, find minnode of its right subtree,
     *    let minnode replace vnode
     * 
    */
    if(!root) return nullptr;
    TreeNode* r  = root;
    TreeNode* p = nullptr;
    TreeNode* pp = nullptr;
    while(r){
        if(r->val == v)
            break;
        pp = p;
        p = r;
        if(r->val < v)
            r = r->right;
        else 
            r = r->left;    
    }
    // if vnode is root,its parent node is nullptr
    if(!p){
        root = nullptr;
        return r;
    }
    TreeNode* vnode = p;
    TreeNode** pp_child = pp->left == vnode ? &(pp->left) : &(pp->right);
	// 1 and 2 case
    if(!vnode->right){
        *pp_child = vnode->left;
        return vnode;
    }
    TreeNode* minnode = vnode->right;
    while(minnode->left){
        p = minnode;
        minnode = minnode->left;
    }
    if(p != vnode){
        p->left = minnode->right;
        minnode->right = vnode->right;
    }
    minnode->left = vnode->left;
    vnode->left = nullptr;
    vnode->right = nullptr;
    *pp_child = minnode;
    return vnode;
}
void BST::PreOrder(TreeNode* r,std::vector<int>& res){
    if(!r) return;
    res.push_back(r->val);
    PreOrder(r->left,res);
    PreOrder(r->right,res);
}
void BST::PreOrder(std::vector<int>& res){
    if(!root) return;
    res.push_back(root->val);
    PreOrder(root->left,res);
    PreOrder(root->right,res);
}
std::vector<int> BST::PreOrder(){
    std::vector<int> res;
    std::stack<TreeNode*> stack;
    TreeNode* r = root;
    while(r || !stack.empty() ){
        while(r){
            res.push_back(r->val);
            stack.push(r);
            r = r->left;
        }
        if(!stack.empty()){
            auto n = stack.top();
            stack.pop();
            r = n->right;
        }
    }
    return res;
}

void BST::InOrder(TreeNode* r,std::vector<int>& res){
    if(!r) return;
    InOrder(r->left,res);
    res.push_back(r->val);
    InOrder(r->right,res);
}
void BST::InOrder(std::vector<int>& res){
    if(!root) return;
    InOrder(root->left,res);
    res.push_back(root->val);
    InOrder(root->right,res);
}
std::vector<int> BST::InOrder(){
    std::vector<int> res;
    std::stack<TreeNode*> stack;
    TreeNode* r = root;
    while(r || !stack.empty() ){
        while(r){
            stack.push(r);
            r = r->left;
        }
        if(!stack.empty()){
            auto n = stack.top();
            stack.pop();
            res.push_back(n->val);
            r = n->right;
        }
    }
    return res;
}
void BST::PostOrder(TreeNode* r,std::vector<int>& res){
    if(!r) return;
    PostOrder(r->left,res);
    PostOrder(r->right,res);
    res.push_back(r->val);
}
void BST::PostOrder(std::vector<int>& res){
    if(!root) return;
    PostOrder(root->left,res);
    PostOrder(root->right,res);
    res.push_back(root->val);
}
std::vector<int> BST::PostOrder(){
    std::vector<int> res;
    std::stack<std::pair<TreeNode*,bool>> stack;
    TreeNode* r = root;
    while(r || !stack.empty() ){
        while(r){
            stack.push(std::make_pair(r,false));
            r = r->left;
        }
        if(!stack.empty()){
            auto& n = stack.top();
            if(n.second || !n.first->right){
                stack.pop();
                res.push_back(n.first->val);
            }else{
                n.second = true;
                r =  n.first->right;
            }
        }
    }
    return res;
}
std::vector<std::vector<int>> BST::LevelOrder(){
    std::vector<std::vector<int>>  res;
    if(!root)return res;
    std::queue<std::pair<TreeNode*,int>> que;
    que.push(std::make_pair(root,0));
    std::vector<int> one_level;
    int last = 0;
    while(!que.empty()){
        auto& node = que.front();
        if(node.second != last){
            res.emplace_back(std::move(one_level));
            last = node.second;
        }
        one_level.push_back(node.first->val);
        if(node.first->left)
            que.push(std::make_pair(node.first->left,node.second+1));
        if(node.first->right)
            que.push(std::make_pair(node.first->right,node.second+1));
        que.pop();
    }
    res.emplace_back(std::move(one_level));
    return res;        
}
小强强-游泳的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树模板
qq_31602961的博客
03-27 183
#include<cstdio> //二叉树结点 struct node{ int data; node* lchild; node* rchild; }; //新建二叉树结点 node* newnode(int data){ node* a = new node; a->data = data; a->lchild = ...
二叉树--模板
qq_62846665的博客
10-17 315
#include<bits/stdc++.h> using namespace std; const int N = 100; const int MAXN = 0x3f3f3f3f; typedef long long ll; char s[N]; int n; int tot = 0; struct node{ char data; node *l, *r; }; // 建树 node *creat(node *root){ if(s[tot] == ','){.
树的概念、性质、存储、遍历
weixin_64840732的博客
06-01 137
基本概念： 树是n（n≥0）个结点的有限集合T(Tree)。当n=0时，称为空树；当n>0时， 该集合满足如下条件： (1) 其中必有一个称为根（root）的特定结点，它没有直接前驱，但有零个或多个直接后继。 (2) 其余n-1个结点可以划分成m（m≥0）个互不相交的有限集T1，T2，T3，…，Tm，其中Ti又是一棵树，称为根root的子树。 每棵子树的根结点有且仅有一个直接前驱，但有零个或多个直接后继。 结点：包含一个数据元素及若干指向其它结点的分支信息。 结点的度：一个结点的子树个数称为此结点的度。
二叉树路径模板
weixin_45483328的博客
08-14 201
朕苦二叉树久矣，故需模板来镇住此妖孽，不求时间复杂度最好，只求能够AC。
平衡二叉树AVL操作模板
12-31
代码如下:/*** 目的：实现AVL* 利用数组对左右儿子简化代码，但是对脑力难度反而增大不少，只适合acm模板* 其实avl在acm中基本不用，基本被treap取代* avl一般只要求理解思路，不要求写出代码，因为真心很烦*/ ...
二叉树模板代码 二叉树习题
03-20
5. 插入操作模板（以二叉搜索树为例）： ```cpp TreeNode* insertIntoBST(TreeNode* root, int val) { if (root == NULL) return new TreeNode(val); if (val < root->val) root->left = insertIntoBST(root->...
二叉树的操作算法
11-28
`BiTree` 类是二叉树的抽象，通常包括构造函数、析构函数以及与二叉树操作相关的成员函数，如插入、删除、查找等。例如，插入操作可以递归地进行： ```cpp template void BiTree<T>::insert(T value) { if (root ...
树与二叉树代码模板.zip
12-05
本压缩包"树与二叉树代码模板.zip"提供了一些基本的代码实现，帮助我们更好地理解和操作这些数据结构。 树是一种非线性的数据结构，它由一组节点（也称为顶点）组成，每个节点可以有零个或多个子节点，且具有唯一的...
数据结构--二叉树构造模板
m0_53252742的博客
11-27 3871
包含四个头文件，需要哪个函数直接抄上就可以的 头文件：binary_tree： #pragma once #pragma once #include<iostream> #include"lk_ queue.h" #include"lk_stack.h" #include"node.h" using namespace std; template <class ElemType> struct BinTreeNode { // 数据成员: ElemType data; .
二叉树模板整理
Leiroy的博客
11-16 1010
二叉树 二叉树的种类 在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。 满二叉树 这棵二叉树为满二叉树，深度为k，有2^k-1个节点 完全二叉树 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。 二叉搜索树 前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，「二叉搜索树是一个有序树」。 若它的左子树不空，则左子树上所有结点的值均小于它的
构建二叉树模板大全
hjxxxxx123491857的博客
08-30 741
有许多关于构建二叉树的题目，并且这些题目有固定的模板，我将对这类题目将进行分类总结。本篇致力于让读者能够融会贯通，抓住要领，建立模板化思维，看见一题想到一类。构造二叉树一般分为构造普通的二叉树，和构造二叉搜索树。构造二叉树我们学会一种思想，就是第一步先找当前根节点看哪一个数组能够明确确定根节点。第二步划分左区间，右区间。这里需要考察的是对vector的掌握，明确左开右闭，并且如何拷贝，如何resize。二叉搜索树的构建，也是先寻找当前根节点。只不过这里是对一个vector进行操作。......
算法22：二叉树各种算法——万能模板
街头小瘪三的专栏
02-23 382
二叉树算法的固定模板
二叉树c++模板实现
zhengzhongwu的博客
01-23 2813
二叉树c++模板实现
[数据结构]二叉树之二叉链表的类模板实现
借你一秒
07-29 5010
该类模板实现了一个二叉树的模板类，采用二叉链表实现。定义二叉树节点类，采用二叉链表实现。///////////////////////// #include #include #include #include using namespace std; template struct BinTreeNode //二叉树节点类的定义，使用二叉链表 { T data; B
二叉树的模板类实现
CodeCAT
03-20 7220
二叉树的定义 二叉树（Binary Tree）是n>0个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵不相交的分别被称为左子树和右子树组成。·不存在度大于2的结点； ·左右子树是有序的，次序不能任意的颠倒。 二叉树的链表存储方式 二叉树的每个结点最多有两个孩子，所以设计一个数据域和两个指针域，我们称为二叉链表。 二叉链树的结点定义为template<typenam
二叉树建立的输入问题
热门推荐
wudongming_000的博客
09-24 1万+
这几天在看数据结构的二叉树，被二叉树建立时的输入问题困扰很久。二叉树的建立一般使用递归算法，将所有节点的数据一股脑的输入，递归无法停止，二叉树就无法建立。 感谢此博文，原来我们在输入节点数据的时候，必须输入空闲叶子节点，并用特殊符号标记，比如上述的博文的空闲叶子节点采用‘0’作为标记符，就能完整建立二叉树。 修改后的代码，亲测有效： #include&lt;iostream&gt; #in...
leetcode 并查集
weixin_41964962的博客
03-05 761
并查集 并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（Union-find Algorithm）定义了两个用于此数据结构的操作： Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。 Union：将两个子集合并成同一个集合。 由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（Union-fi...
二叉树模板的C语言实现
最新发布
05-11
以下是二叉树的基本结构体和函数实现的C语言代码： ```c #include #include /* 二叉树结构体 */ ...上述代码实现了二叉树的基本操作，包括初始化、插入节点、中序遍历等。你可以根据需要进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值