秋招备战-算法系列（二叉树篇）更新中。。。

最新推荐文章于 2024-03-08 22:24:15 发布
最新推荐文章于 2024-03-08 22:24:15 发布
阅读量141 收藏
点赞数 1
分类专栏： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zaozhichangxiaojie99/article/details/98115759
版权

数据结构：

四种主要的遍历思想为：
深度优先：
前序遍历：根结点 —> 左子树 —> 右子树
中序遍历：左子树—> 根结点 —> 右子树
后序遍历：左子树 —> 右子树 —> 根结点

广度优先：
层次遍历：只需按层次遍历即可

基础题

给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。

递归解法
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class TreeToSequence {
public:
    void preOrder(TreeNode* root, vector<int>& v){
        if(root == NULL) return;
        v.push_back(root->val);
        preOrder(root->left, v);
        preOrder(root->right, v);
    }
    
    void midOrder(TreeNode* root, vector<int>& v){
        if(root == NULL) return;
        midOrder(root->left, v);
        v.push_back(root->val);
        midOrder(root->right, v);
    }
    
    void afterOrder(TreeNode* root, vector<int>& v){
        if(root == NULL) return;
        afterOrder(root->left, v);
        afterOrder(root->right, v);
        v.push_back(root->val);
    }
    
    vector<vector<int> > convert(TreeNode* root) {
        // write code here
        vector<vector<int>> result;
        vector<int> pre, mid, after;
        result.resize(3);
        preOrder(root, pre);
        midOrder(root, mid);
        afterOrder(root, after);
        result = {pre, mid, after};
        return result;
        
    }
};
非递归解法

思路：
二叉树的非递归解法需要借助栈来实现，具体三种遍历的方法如下
先序遍历：
s1:创建一个栈为s
s2:将二叉树的头节点head压入栈s中。
s3:将s中的头节点出栈，并且记为cur，如果cur的右节点不为空，将右节点入栈，如果cur的左节点不为空，左节点入栈
s4:重复s3直到栈为空时结束

头节点入栈
在这里插入图片描述
1为cur
打印序列：1
在这里插入图片描述
2为cur
打印序列：1 2
在这里插入图片描述
5为cur
打印序列：1 2 4 5
在这里插入图片描述
中序遍历：
s1:创建一个栈为s，head为cur
s2:将cur压入栈中，不断的使cur = cur.left，重复步骤s2。
s3:当cur为空时，弹出头节点记为node并打印，cur = node.right，重复步骤二，若cur的右节点为空，继续出栈记为node并打印
s4:当stack为空，cur为空，结束

cur = 4
在这里插入图片描述
cur = 4.left
出栈：4
在这里插入图片描述
cur = 4.right
出栈：4 2
在这里插入图片描述
cur = 2.right
在这里插入图片描述
cur = 5.right
出栈：4 2 5 1
cur = 1
在这里插入图片描述
后序遍历：
s1:创建一个栈为s，h为最近一次弹出的节点，c指向栈顶节点，h初始为head，c为null
s2:t指向栈顶节点，此时有三种情况
1.若c的左节点不为空，h不等于c的左节点和右节点，h的左节点入栈
2.若不满足条件1，c的右节点不为空，h不等于c的右孩子，h的右节点入栈
3.若不满足1，2条件，弹出c，h = t
3.重复s2，直到s为空
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
void pre(TreeNode* root, vector<int> &v){
    stack<TreeNode*> s;
    TreeNode* cur = NULL;
    s.push(root);
    while(!s.empty()){
        cur = s.top();
        v.push_back(cur->val);
        s.pop();
        if(cur->right != NULL) s.push(cur->right);
        if(cur->left != NULL) s.push(cur->left);
    }
}

void middle(TreeNode* root, vector<int> &v){
    stack<TreeNode*> s;
    TreeNode* cur = root;
    TreeNode* node = NULL;
    //s.push(root);
    while(!s.empty() || cur != NULL){
        if(cur != NULL){
            s.push(cur);
            cur = cur->left;
        }else{
            node = s.top();
            v.push_back(node->val);
            s.pop();
            cur = node->right;
        }
    }
}

void after(TreeNode* root, vector<int> &v){
    stack<TreeNode*> s;
    TreeNode* c = NULL;//top
    TreeNode* h = root;//pop node
    s.push(root);
    c = s.top();
    while(!s.empty()){
        if(c->left != NULL && h!=c->left && h!=c->right){
            s.push(c->left);
        }else if(c->right != NULL && h != c->right){
            s.push(c->right);
        }else{
            h = s.top();
            v.push_back(h->val);
            s.pop();
        }
        c = s.top();
    }
}

class TreeToSequence {
public:
    vector<vector<int> > convert(TreeNode* root) {
        vector<vector<int>> res;
        vector<int> temp;
        // write code here
        pre(root, temp);
        res.push_back(temp);
        temp.clear();
        
        middle(root, temp);
        res.push_back(temp);
        temp.clear();
        
        after(root, temp);
        res.push_back(temp);
        temp.clear();
        
        return res;
    }
};

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if(pRoot == NULL) return 0;
        int left = TreeDepth(pRoot->left);
        int right = TreeDepth(pRoot->right);
        return (left > right)? left+1:right+1;
    }
};

有一棵二叉树，请设计一个算法判断这棵二叉树是否为平衡二叉树。

基础知识：
平衡二叉树：
任何一个结点的左子树与右子树都是平衡二叉树，并且高度之差的绝对值不超过1

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class Solution {
public:
    int getDepth(TreeNode* root){
        if(root == NULL) return 0;
        int left = getDepth(root->left);
        int right = getDepth(root->right);
        return (left>right)? (left+1) : (right+1);
    }
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if(pRoot == NULL) return true;
        int left = getDepth(pRoot->left);
        int right = getDepth(pRoot->right);
        if(abs(left-right) > 1){
            return false;
        }
        return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);;
    }
};

从上往下打印出二叉树的每个节点，同层节点从左至右打印。(广度优先遍历)

在这里插入图片描述
思路：
该题采用队列的方式来实现，将根节点0入队列
s1：当打印根节点0时，将0的两个节点1和2入队列，0出队列
s2：将队列最开始的元素1打印，出队列，将1的两个子节点3和4入队列
s3：不断重复s2，直到队列为空

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> q;
        TreeNode* cur;
        if(root == NULL) return res;
        q.push(root);
        while(q.size()){
            cur = q.front();
            res.push_back(cur->val);
            q.pop();
            if(cur->left){
                q.push(cur->left);
            }
            if(cur->right){
                q.push(cur->right);
            }
        }
        return res;
    }
};

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行

在这里插入图片描述
思路：
这道题和上一道题类似，也是用队列的方法来实现的，思路在上一题的基础上再添加两个变量，nextLevel用来存储下一层的节点数，toBePrinted用来存储当前层未打印的节点数。
s1：将根节点a入队列，toBePrinted初始值为1，nextLevel为0
s2：当打印根节点a时，a出队列，toBePrinted减1，若根节点的左节点b存在，nextLevel自增1，右节点c同理，b，c入队列，当toBePrinted等于0时，本行打印结束，并且toBePrinted=nextLevel
s3：重复s2直到栈为空

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
        vector<vector<int>> Print(TreeNode* pRoot) {   
            vector<vector<int>> res;
            vector<int> temp;
            if(pRoot == nullptr) return res;
            
            queue<TreeNode*> q;
            q.push(pRoot);
            int nexlLevel = 0;
            int toBePrinted = 1;
            TreeNode* node;
            while(!q.empty()){
                node = q.front();
                q.pop();
                temp.push_back(node->val);
                if(node->left != nullptr){
                    q.push(node->left);
                    ++nexlLevel;
                }
                if(node->right != nullptr){
                    q.push(node->right);
                    ++nexlLevel;
                }
                toBePrinted--;
                if(toBePrinted == 0){
                    res.push_back(temp);
                    temp.clear();
                    toBePrinted = nexlLevel;
                    nexlLevel = 0;
                }
            }
            return res;
        }  
};

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

在这里插入图片描述
思路：
这一题使用栈的数据结构，从之前的两个问题可以知道，顺序打印每一个节点使用队列的数据结构，那么逆序打印使用的是栈的数据结构。
从图上可以知道：
当行数为奇数行1，3时先入栈左节点再入栈右节点，当行数为偶数时先入栈右节点再入栈左节点，这道题用两个栈分别存储当前层的节点的和下一层的节点

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        vector<int> temp;
        if(pRoot == nullptr) return res;
        stack<TreeNode*> levels[2];
        int current = 0;
        int next = 1;
        levels[current].push(pRoot);
        while(!levels[1].empty() || !levels[0].empty()){
            TreeNode* pNode = levels[current].top();
            temp.push_back(pNode->val);
            levels[current].pop();
            if(current == 0){
                if(pNode->left != nullptr) levels[next].push(pNode->left);
                if(pNode->right != nullptr) levels[next].push(pNode->right);
            }else{
                if(pNode->right != nullptr) levels[next].push(pNode->right);
                if(pNode->left != nullptr) levels[next].push(pNode->left);
            }
            if(levels[current].empty()){
                res.push_back(temp);
                temp.clear();
                current = 1-current;
                next = 1-next;
            }
        }
        return res;
    }
    
};

进阶题

和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路：
这道题可以采取二叉树递归的思路来解：二叉树的前序遍历中第一个节点是二叉树的根节点，二叉树的中序遍历中，根节点左边的节点是左子树，根节点右边的节点是右子树。
s1:求出二叉树的根节点
s2:找出二叉树的左子树以及右子树
s3:递归重复以上步骤

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int len = pre.size();
        if (len == 0){
            return NULL;
        }
        int root = 0;
        TreeNode* head = new TreeNode(pre[0]);
        vector<int> preLeft, inLeft, preRight, inRight;
        for (int i = 0; i < len; i ++){
            if (pre[0] == vin[i]){
                root = i;
                break;
            }
        }
        for (int i = 0; i < root; i++){
            inLeft.push_back(vin[i]);
            preLeft.push_back(pre[i+1]);
        }
        for (int i = root+1; i < len; i++){
            inRight.push_back(vin[i]);
            preRight.push_back(pre[i]);
        }
        head->left = reConstructBinaryTree(preLeft, inLeft);
        head->right = reConstructBinaryTree(preRight, inRight);
         
        return head;
    }
};

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思路：
这题采用递归的思路
s1:在a树中找出与b树根节点相等的值
s2:判断a树中与b树根节点相等的子树的左右子树是否相等

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        bool result;
        if(pRoot1!= NULL && pRoot2!=NULL){
            if(pRoot1->val == pRoot2->val){
                result = HasSubtree2(pRoot1,pRoot2);
            }
            if(!result){
                result = HasSubtree(pRoot1->right, pRoot2);
            }
            if(!result){
                result = HasSubtree(pRoot1->left, pRoot2);
            }
        }
        return result;
    }
    bool HasSubtree2(TreeNode* pRoot1, TreeNode* pRoot2){
        if(pRoot2 == NULL){
            return true;
        }
        if(pRoot1 == NULL){
            return false;
        }
        if(pRoot1->val != pRoot2->val){
            return false;
        }
        return HasSubtree2(pRoot1->left, pRoot2->left) && HasSubtree2(pRoot1->right, pRoot2->right);
    }
};

操作给定的二叉树，将其变换为源二叉树的镜像。

在这里插入图片描述

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot==NULL) return;
        if(pRoot->left == NULL && pRoot->right == NULL) return;
        
        TreeNode *temp = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = temp;
        
        if(pRoot->left){
            Mirror(pRoot->left);
        }
        if(pRoot->right){
            Mirror(pRoot->right);
        }
    }
};

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSame(TreeNode* r1, TreeNode* r2){
        if(r1 == NULL && r2 == NULL) return true;
        if(r1 == NULL || r2 == NULL) return false;
        if(r1->val != r2->val) return false;
        return isSame(r1->left, r2->right) && isSame(r1->right, r2->left);
    }
    bool isSymmetrical(TreeNode* pRoot)
    {
        if (pRoot == NULL) return true;
        return isSame(pRoot->left, pRoot->right);
    }

};

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

在这里插入图片描述
思路：
关于二叉树中序遍历的下一个节点有三种情况：
1.如果一个节点有右子树，那么下一个节点为从右子树出发一直指向左节点的指针
例如：b的下一个节点为h
2.如果一个节点没有右子树，并且是父节点的左节点，下一个节点为父节点。例如：h下一个节点为e
3.如果一个节点既没有右子树，并且是父节点的右节点，这时就要沿着父指针一直向上遍历，直到遍历到的当前节点满足条件2，那么下一个节点为该节点的父节点。例如：i的下一个节点为a

/*
struct TreeLinkNode {
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {
        
    }
};
*/
class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        if(pNode == nullptr){
            return nullptr;
        }
        TreeLinkNode* pNext = nullptr;
        if(pNode->right != nullptr){
            TreeLinkNode* pRight = pNode->right;;
            while(pRight->left != nullptr){
                pRight = pRight->left;
            }
            pNext = pRight;
        }
        else if(pNode->next != nullptr){
            TreeLinkNode* pCurrent = pNode;
            TreeLinkNode* pParent = pNode->next;
            while(pParent != nullptr && pCurrent == pParent->right){
                pCurrent = pParent;
                pParent = pParent->next;
            }
            pNext = pParent;
        }
        return pNext;
    }
};

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

基础知识：
二叉搜索树是一种节点值之间具有一定数量级次序的二叉树，对于树中每个节点：
若其左子树存在，则其左子树中每个节点的值都不大于该节点值；
若其右子树存在，则其右子树中每个节点的值都不小于该节点值。
二叉树的后序遍历结果中，最后一个元素为二叉树的根节点
思路：
根据二叉树和二叉搜索树的基本性质，序列最后一个元素为根节点，之前的序列可以看作两个部分，比根节点小的序列为左子树，比根节点大的序列为右子树。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size() == 0) return false;
        return func(sequence, 0, sequence.size()-1);
    }
    bool func(vector<int> array, int begin, int end){
        int root = array[end];
        int i;
        for(i = begin; i < end; i++){
            if(array[i]>root) break;
        }
        int j = i;
        for(; j < end; j++){
            if(array[j]<root) return false;
        }
        bool left = true;
        if(begin<i-1) left = func(array, begin, i-1);
        bool right = true;
        if(i<end-1) right = func(array, i, end-1);
        return left && right;
    }
};

复杂题

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

思路：
该题使用递归的思想，当访问到某一节点时，若该节点不是叶节点，该节点下面的路径和等于输入的值减去这一节点的值。当该节点访问结束时，递归自动回归到它的父节点。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<vector<int> > buffer;
    vector<int> tmp;
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root==NULL)
            return buffer;
        tmp.push_back(root->val);
        if((expectNumber-root->val)==0 && root->left==NULL && root->right==NULL)
            {
            buffer.push_back(tmp);
        }
        FindPath(root->left,expectNumber-root->val);
        FindPath(root->right,expectNumber-root->val);
        if(tmp.size()!=0)
            tmp.pop_back();
        return buffer;
    }
};

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void convert(TreeNode* root, TreeNode** lastNode){
        if(root == nullptr) return;
        TreeNode* pNode = root;
        if(root->left != nullptr){
            convert(root->left, lastNode);
        }
        pNode->left = *lastNode;
        if(*lastNode != nullptr){
            (*lastNode)->right = pNode;
        }
        *lastNode = pNode;
        if(root->right != nullptr){
            convert(root->right, lastNode);
        }
    }
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        TreeNode* lastNode = nullptr;
        convert(pRootOfTree, &lastNode);
        TreeNode* pHead = lastNode;
        while(pHead != nullptr && pHead->left != nullptr){
            pHead = pHead->left;
        }
        return pHead;
    }
};

给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。

思路：
二叉搜索树的中序遍历为节点从小到大排序的顺序，第k小的值为中序遍历的第k个节点

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    
    TreeNode* KthNode(TreeNode* pRoot, int k)
    {
        if(pRoot == nullptr || k == 0) return nullptr;
        return  findTarget(pRoot, k);
    }
    
    TreeNode* findTarget(TreeNode* pRoot, int &k){
        TreeNode* target = nullptr;
        if(pRoot->left != nullptr){
            target = findTarget(pRoot->left, k);
        }
        if(target == nullptr){
            if(k==1)
                target = pRoot;
            //遍历一次k减1
            k--;
        }
        if(target == nullptr && pRoot->right != nullptr){
            target = findTarget(pRoot->right, k);
        }
        return target;
    }
    
};

请实现两个函数，分别用来序列化和反序列化二叉树

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。
序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

造纸厂小姐99
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Objective-C实现二叉树遍历算法（源代码）
04-30
本文展示了如何在Objective-C中实现一个简单的二叉树算法。首先，定义了一个二叉树节点的类BinaryTreeNode，用于存储数据和指向左右子节点的指针。接着，定义了一个二叉树类BinaryTree，该类包含一个根节点指针，并...
数据结构之二叉树（更新中）
weixin_30237281的博客
04-15 101
typedef char elemtype; struct node { elemtype data; struct node *lchild; struct node *rchild; }; typedef struct node btnode; typedef struct node *btree; void initbt(btree &t...
数据结构-二叉树-更新完整版
weixin_57535054的博客
04-30 592
二叉树详细剖析（更新完整版）（加动图更容易理解！）
我的面试准备过程--二叉树(更新中)
weixin_34292287的博客
06-15 92
写在最前面 导师贪腐出逃美国，两年未归，可怜了我。拿了小米和美团的offer，要被延期，offer失效，工作重新找。把准备过程纪录下来，共勉。 二叉树的基础 结点定义 public class TreeNode{ int val; TreeNode left; TreeNode right; public...
树，堆（详解）二叉树在持续更新
_zhy_cq
04-26 168
二叉树的性质： 一颗非空二叉树的第i层最多有2i-1个节点 深度为h的二叉树最大的节点数为2h - 1 对于任何一个二叉树，如果叶子结点为n0,度为2的结点为n2，则n0=n2+1 n个结点的满二叉树，深度为log(n + 1) （以上是对任何的二叉树，不一定是对完全二叉树） 特殊的二叉树： 1.满二叉树 每一层的结点都是最大值，如果数的深度为h，则结点的个数为2h - 1 2.完全二叉树 前h - 1层都是满的，最后一层从左到右是连续的 // 二叉链 struct TreeNode { int va
二叉树系列汇总，持续更新！
不积跬步，无以至千里！
04-27 2524
这次终于把二叉树弄懂了！
【25届秋招备战C++】数据结构篇-二叉树
weixin_44791229的博客
03-08 2007
由 n≥0 个节点与节点之间的关系组成的有限集合。当 n=0 时称为空树，当 n>0 时称为非空树。
基础算法-python实现二叉树遍历
11-20
【基础算法】-python实现二叉树遍历 # -*- coding: gb2312 -*- class Queue(object): def __init__(self): self.q = [] def enqueue(self, item): self.q.append(item) def dequeue(self): # if self....
C#-使用C#实现的二叉树算法-算法实现.zip
02-25
在C#编程语言中，二叉树是一种常用的...在提供的项目中，你可以找到这些算法的具体实现，通过阅读和理解代码，能深入掌握二叉树算法在C#中的运用。学习和实践这些算法将有助于提升你的编程能力和解决复杂问题的能力。
数据结构与算法-二叉树的排序
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
qingq0825#Javabook-Interview#算法-二叉树-递归-二叉树反转1
07-25
原二叉树：反转后的二叉树：TreeNode temp = root.left;欢迎光临我的博客，发现更多技术资源~
二叉树专题 -- 持续更新
weixin_42096202的博客
06-09 216
二叉树题目总结归纳： 二叉树结构： #include <iostream> #include <vector> #include <queue> using namespace std; class TreeNode{ public: int val; TreeNode* left; TreeNode* right; TreeN...
基于SpringCloud微服务架构的B2C电子商务系统-可执行内含文档代码-可执行内含文档代码.zip
07-28
基于SpringCloud微服务架构的B2C电子商务系统-可执行内含文档代码-可执行内含文档代码.zip
智慧校园整体解决方案-6PPT(102页).pptx
07-28
智慧校园整体解决方案是响应国家教育信息化政策，结合教育改革和技术创新的产物。该方案以物联网、大数据、人工智能和移动互联技术为基础，旨在打造一个安全、高效、互动且环保的教育环境。方案强调从数字化校园向智慧校园的转变，通过自动数据采集、智能分析和按需服务，实现校园业务的智能化管理。 方案的总体设计原则包括应用至上、分层设计和互联互通，确保系统能够满足不同用户角色的需求，并实现数据和资源的整合与共享。框架设计涵盖了校园安全、管理、教学、环境等多个方面，构建了一个全面的校园应用生态系统。这包括智慧安全系统、校园身份识别、智能排课及选课系统、智慧学习系统、精品录播教室方案等，以支持个性化学习和教学评估。 建设内容突出了智慧安全和智慧管理的重要性。智慧安全管理通过分布式录播系统和紧急预案一键启动功能，增强校园安全预警和事件响应能力。智慧管理系统则利用物联网技术，实现人员和设备的智能管理，提高校园运营效率。 智慧教学部分，方案提供了智慧学习系统和精品录播教室方案，支持专业级学习硬件和智能化网络管理，促进个性化学习和教学资源的高效利用。同时，教学质量评估中心和资源应用平台的建设，旨在提升教学评估的科学性和教育资源的共享性。 智慧环境建设则侧重于基于物联网的设备管理，通过智慧教室管理系统实现教室环境的智能控制和能效管理，打造绿色、节能的校园环境。电子班牌和校园信息发布系统的建设，将作为智慧校园的核心和入口，提供教务、一卡通、图书馆等系统的集成信息。 总体而言，智慧校园整体解决方案通过集成先进技术，不仅提升了校园的信息化水平，而且优化了教学和管理流程，为学生、教师和家长提供了更加便捷、个性化的教育体验。
anaconda配置pytorch环境.pdf
最新发布
07-28
使用Anaconda配置PyTorch环境是一个相对直接的过程，以下是一个详细的步骤指南，包括Anaconda的下载与安装、PyTorch环境的创建以及PyTorch的安装与验证。 一、Anaconda的下载与安装 1.访问Anaconda官网： 1.前往Anaconda官网下载最新版本的Anaconda。 2.下载Anaconda： 1.在官网首页，点击“Free Download”按钮，选择合适的操作系统版本进行下载。 3.安装Anaconda： 1.双击下载好的Anaconda安装包，按照提示进行安装。 2.注意选择安装路径（建议不安装在C盘），并确保安装路径为全英文。 3.安装过程中，根据需要选择“为所有用户安装”或“仅为当前用户安装”。 4.验证Anaconda安装： 1.安装完成后，打开“Anaconda Prompt”（或Anaconda Navigator），输入conda --version查看conda版本，以验证Anaconda是否安装成功。 二、创建PyTorch环境 1.打开Anaconda Prompt： 1.在开始菜单中找到并打开“Anaconda Pro
2024小米SOC面试经验
07-28
• 自我介绍，然后针对项目实习进行提问。 • sdram仲裁模块设计：面试官询问了我关于sdram（同步动态随机存取存储器）仲裁模块的设计思路，这可能涉及到如何高效地管理多个设备或进程对sdram的访问，确保数据一致性和性能优化。 • FIFO设计：我们探讨了FIFO（先进先出队列）是否使用了现成的IP核（知识产权核），并假设如果我自己设计FIFO时可能遇到的难点，如同步问题、缓冲区管理、性能优化等。 • 跨时钟域问题：讨论了跨时钟域信号同步的挑战，特别是信号展宽（metastability）的解决策略，这是确保数据在不同时钟域间可靠传输的关键。 • TMDS编码流程：面试官询问了我TMDS（Transition Minimized Differential Signaling，转换最小化差分信号）编码的具体流程，这通常涉及视频或高速数据传输领域，要求我对数据传输协议有深入理解。 • 项目调试方法：面试官要求我分享在项目中如何进行调试的经验，包括使用的工具、调试策略及问题解决过程。
1920x1080尺寸的NV12 YUV的图像数据
07-28
1920x1080尺寸的NV12 YUV的图像数据
步行街招商计划书范本（附租赁合同等）.doc
07-28
商业计划书，创业计划书，项目计划书，计划书模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
掌握计算机软件技术：算法与数据结构详解-树与二叉树篇
本资源是关于计算机软件技术基础的一份讲义，重点探讨了算法和数据结构中的树和二叉树。树是一种非线性数据结构，它由一个根节点和若干子树构成，这些子树可以是树也可以为空。树的结构通过层次关系来表示，如深度、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值