剑offer - 1 - 二叉树

最新推荐文章于 2022-04-18 15:24:45 发布
最新推荐文章于 2022-04-18 15:24:45 发布
阅读量74 收藏
点赞数
分类专栏： coding
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s11show_163/article/details/112209565
版权
这篇博客主要介绍了关于二叉树的一系列算法题目，包括LC958的完全性校验、蛇形遍历、重建二叉树、判断子结构、对称二叉树、从上到下打印、二叉搜索树的后序遍历序列、求和路径、最近祖先、删除节点以及计算二叉树深度等。通过这些题目，博主探讨了不同类型的二叉树问题及其解题思路。
摘要由CSDN通过智能技术生成
LC958二叉树的完全性校验

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isCompleteTree(TreeNode* root) {
        if(root == nullptr) return true;
        bool flag = false;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            TreeNode *t = q.front();q.pop();
            if(t == nullptr){
                flag = true;
                continue;
            }
            if(flag) return false; 
            //走到这个if说明此次循环没有t!=nullptr,而上次循环t==nullptr，
            //所以说明有空节点夹杂在非空结点之前。
            q.push(t->left);
            q.push(t->right);
        }
        return true;
    }
};
103.蛇形二叉树遍历

算法题：给定一棵二叉树，返回蛇形遍历顺序。leetcode水题，宽度优先遍历之后将偶数行的结果reverse就可以。只做出这一个。
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

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

TreeNode* init(int *a, int len){
	TreeNode *root = nullptr;
	TreeNode *p = nullptr;
	int flag = 0;
	for(int i=0;i<len;){
		if(i == 0)  {
				root = new TreeNode(a[i++]);
				p = root;
				cout<<p->val<<"mmm"<<endl;
		}else{
				cout<<a[i]<<"mmm"<<endl;
				if(a[i] == NULL) p->left=nullptr;
				else p->left = new TreeNode(a[i]);
				i++;
				cout<<a[i]<<"mmm"<<endl;
				if(a[i] == NULL) p->right=nullptr;
				else p->right = new TreeNode(a[i]);
				i++;
				if(flag == 0) {
						if(p->left) p = p->left;
						flag=1;
				}else if(flag == 1){
					if(p->right) p = p->right;
					flag = 0;
				}
		}
	}
	return root;
}


void levelOrder(TreeNode *root){
	TreeNode *p = root;
	queue<TreeNode*> q;
	q.push(root);
	vector<vector<int>> v;
	int level = 1;
	while(!q.empty()){
		int size = q.size();
		vector<int>t;
		for(int i=0;i<size;i++){
			p = q.front();q.pop();
			t.push_back(p->val);
			if(p->left) q.push(p->left);
			if(p->right) q.push(p->right);
		}
		if(level %2 == 0) reverse(t.begin(),t.end());
		v.push_back(t);
		level++;
	}
	for(int i=0;i<v.size();i++){
		for(vector<int>::iterator it = v[i].begin(); it != v[i].end(); it++){
			cout<<*it<<",";
		}
		cout<<endl;
	}
}

int main(){
	int a[] = {3,9,20,NULL,NULL,15,7};
	int len = sizeof(a)/sizeof(a[0]);
	TreeNode *root = init(a, len);
	levelOrder(root);

}

00.二叉树遍历

#include<bits/stdc++.h>

using namespace std;

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

void PreOrder(TreeNode *root){
	if(root == NULL) return ;
	TreeNode *p = root;
	cout<<p->val<<" ";
	PreOrder(p->left);
	PreOrder(p->right);
}

//层序非递归是一个队列
//前序非递归是一个栈
void PreOrder2(TreeNode *root){
	if(root == NULL) return;
	TreeNode *p = root;
	stack<TreeNode *>s;
	while(p || !s.empty()){
		while(p){
			cout<<p->val<<" ";
			s.push(p);
			p = p->left;
		}
		if(!s.empty()){
			p = s.top(); s.pop();
			p = p->right;
		}

	}

}
void InOrder(TreeNode *root){
	if(root == NULL) return ;
	InOrder(root->left);
	cout<<root->val<<" ";
	InOrder(root->right);
}

void InOrder2(TreeNode *root){
	if(root == NULL) return;
	TreeNode *p = root;
	stack<TreeNode *> s;
	while(p || !s.empty()){
		while(p){
			s.push(p);
			p = p->left;
		}
		if(!s.empty()){
			p = s.top();
			s.pop();
			cout<<p->val<<" ";
			p = p->right;

		}
	}
}

void PostOrder(TreeNode *root){
	if(root == NULL) return ;
	PostOrder(root->left);
	PostOrder(root->right);
	cout<<root->val<<" ";
}


void postorder(TreeNode *root) {
	stack<TreeNode*> s;
	TreeNode* pre=NULL;
	TreeNode* cur;
	s.push(root);
	while(!s.empty()) {
		cur = s.top();
		if ((cur->left==NULL && cur->right==NULL) ||
			(pre!=NULL&&(pre==cur->left||pre==cur->right))) {
				cout << cur->val << " ";
				pre = cur;
				s.pop();
			}
		if (cur->right) s.push(cur->right);
		if (cur->left) s.push(cur->left);
	}
}

//后序遍历非递归1：由前序非递归改进，采用根右左的遍历写法，最后结果再翻转
void PostOrder1(TreeNode *root){
	vector<TreeNode*> v;
	stack<TreeNode*>s;
	TreeNode *p = root;
	while(p || !s.empty()){
		while(p){
			v.push_back(p);
			s.push(p);
			p=p->right;
		}
		if(!s.empty()){
			p = s.top();s.pop();
			p = p->left;
		}
	}
	reverse(v.begin(),v.end());
	for(int i=0;i<v.size();i++){
		cout<<v[i]->val<<" ";
	}
}

//后序遍历非递归2：建立一个指向前一节点的指针，标记右孩子是否被访问
void PostOrder2(TreeNode *root){
	TreeNode *pre = NULL;
	TreeNode *p = root;
	stack<TreeNode*>s;
	while(p || !s.empty()){
		while(p){
			s.push(p);
			p = p->left;
		}
		p = s.top();//这里先不要弹出栈顶，因为可能右子树还要进来，如果有右子树要进来则这个相对根节点就需要稍后再弹出
		if(p->right == pre || p->right == NULL){ //若没有右节点或者右节点已经被访问过则输出这个相对根节点
			s.pop();
			cout<<p->val<<" ";
			pre = p;
			p = NULL;
		}else{
			p = p->right;
		}
	}
}

void LevelOrder(TreeNode *root){
	queue<TreeNode*> q;
	q.push(root);
	TreeNode *p = root;
	while(!q.empty()){
		p = q.front();
		q.pop();
		cout<<p->val<<" ";
		if(p->left) q.push(p->left);
		if(p->right) q.push(p->right);
	}
}

TreeNode* init(TreeNode *root){
	TreeNode *p = root;
	fstream f("int.txt");
	int x;
	while(f>>x){
		if(p->left == NULL){
			p->left = new TreeNode(x);
		}else{
			p->right = new TreeNode(x);
			p = p->left;

		}
	}
	return root;
}


int main(){
	TreeNode root(0);
	init(&root);
	cout<<"前序："<<" ";
	PreOrder(&root);
	cout<<"\n前序："<<" ";
	PreOrder2(&root);
	cout<<"\n中序: " <<" ";
	InOrder(&root);
	cout<<"\n中序: " <<" ";
	InOrder2(&root);
	cout<<"\n后序: " <<" ";
	PostOrder(&root);
	cout<<endl;
	PostOrder1(&root);
	cout<<endl;
	PostOrder2(&root);
	cout<<"\n层序："<<" ";
	LevelOrder(&root);
}

	//				0
	//			1		2
	//		3		4
	//	5		6
	//7		8
//9

07.重建二叉树（给前中写后序）

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出
前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        //递归分治
        return recursionBuild(preorder.begin(),preorder.end(),inorder.begin(),inorder.end());
    }

    //递归分治
    TreeNode* recursionBuild(vector<int>::iterator preBegin, vector<int>::iterator preEnd,vector<int>::iterator inBegin, vector<int>::iterator inEnd )
    {
        if(inEnd==inBegin) return NULL;
        TreeNode* cur = new TreeNode(*preBegin);
        auto root = find(inBegin,inEnd,*preBegin);
        cur->left = recursionBuild(preBegin+1,preBegin+1+(root-inBegin),inBegin,root);
        cur->right = recursionBuild(preBegin+1+(root-inBegin),preEnd,root+1,inEnd);
        return cur;
    }
};

感想：迭代器迭代器迭代器

26.树的子结构

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==NULL|| B==NULL) return false;
        bool res = false;
        if(A->val == B->val){
            res = helper(A,B);
        }
        if(!res){
            res = isSubStructure(A->left,B);
        }
        if(!res){
            res = isSubStructure(A->right,B);
        }
        return res;
    }
    
    bool helper(TreeNode* a,TreeNode* b){
        if(b==NULL) return true;
        if(a==NULL) return false;
        if(a->val == b->val) return helper(a->left,b->left) && helper(a->right,b->right);
        else return false;
    }
};

感想：递归敢于截止。

28. 对称的二叉树

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        else  return helper(root->left,root->right);
    }

    bool helper(TreeNode* leftRoot,TreeNode* rightRoot){
        if(leftRoot == NULL && rightRoot == NULL) return true;
        else if(leftRoot == NULL || rightRoot == NULL) return false;
        if(leftRoot->val != rightRoot->val) return false;
        else return helper(leftRoot->left,rightRoot->right) && helper(leftRoot->right,rightRoot->left);
    }
};

32-3 从上到下打印二叉树

class Solution {
public:
    vector<vector<int>> v;
    vector<vector<int>> levelOrder(TreeNode* root) {
        dfs(root,0);
        return v;
    }

    void dfs(TreeNode* root,int level){
        if(root == NULL) return ;
        if(level>=v.size()) v.emplace_back(vector<int>());
        v[level].emplace_back(root->val);
        if(root->left) dfs(root->left,level+1);
        if(root->right) dfs(root->right,level+1);
    }
};

33.二叉搜索树树后序遍历序列

在这里插入图片描述

bool fun2(vector<int> &a,int left,int right){
	if(left >= right) return true;
	int pos = left;
	for(;pos<right;pos++){
		if(a[pos]>a[right]) break;
	}
	for(int j=pos;j<right;j++){
		if(a[j]<a[right]) return false;
	}
	return fun2(a,left,pos-1) && fun2(a,pos,right-1);
}

void fun1(vector<int> &a){
	fun2(a,0,a.size()-1);	
}

34.二叉树中和为某一值的路径

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

 

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

class Solution {
public:
    vector<vector<int>> v;
    vector<int> single;
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        if(root == NULL) return v;
        dfs(root,sum);
        return v;
    }

    void dfs(TreeNode* root,int sum){
        if(root == NULL) return;
        sum -= root->val;
        single.push_back(root->val);
        if(!root->left && !root->right && sum == 0) v.emplace_back(single);
        dfs(root->left,sum);
        dfs(root->right,sum);
        single.pop_back();
    }
};

感想：想成了每次怎么新建一个vector实际上每一条dfs深度里都是一条新的vector，即使用的全局变量。

68-1 二叉搜索树中的最近祖先

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//递归
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root->val < p->val && root->val < q->val) return lowestCommonAncestor(root->right, p, q);
        if(root->val > p->val && root->val > q->val) return lowestCommonAncestor(root->left, p, q);
        return root;
    }
};
//迭代
class Solution {
    public:
    TreeNode* lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
        while(root != NULL) {
            if(root->val < p->val && root->val < q->val) // p,q 都在 root 的右子树中
                root = root->right; // 遍历至右子节点
            else if(root->val > p->val && root->val > q->val) // p,q 都在 root 的左子树中
                root = root->left; // 遍历至左子节点
            else break;
        }
        return root;
    }
};

68-2二叉树中的最近公共祖先

在这里插入图片描述

TreeNode* fun1(TreeNode *root,TreeNode *p,TreeNode *q){
	if(root == NULL) return NULL;
	if(root->val == p->val || root->val == q->val) return root;
	TreeNode *left = fun1(root->left,p,q);
	TreeNode *right = fun1(root->right,p,q);
	if(left == NULL && right == NULL) return NULL;
	if(left == NULL) return right;
	if(right == NULL) return left;
	return root;
}

18.删除指定节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode* p = head;
        ListNode* q = p;
        if(p->val == val){
            head = head->next;
            return head;
        }
        while(p->next){
            q=p;
            p=p->next;
            if(p->val == val){
                if(p->next) q->next = p->next;
                else q->next = NULL;
                break;
            }
        }
        return head;
    }
};

55.二叉树深度

/**************************BFS*************************/

class Solution {
public:
    int length=0;
    queue<TreeNode*> q;
    int maxDepth(TreeNode* root) {
       if(root == NULL) return 0;
       q.push(root);
       while(!q.empty()){
           int size = q.size();
           for(int i=0;i<size;i++){
               TreeNode* tmp = q.front();q.pop(); 
    //注意这个出队操作是写在横排for的里面的，就是说同一行的节点的出队操作值归为length加一次。
               if(tmp->left) q.push(tmp->left);
               if(tmp->right) q.push(tmp->right);
           }
           length+=1;
       }
       return length;
    }
};

/****************DFS**************************/
class Solution {
public:
    int maxDepth(TreeNode* root) {
	    if(root == NULL) return 0;
	    return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};
s11show_163
关注
专栏目录
alienxcn#ZXBlog#剑指Offer - 57 - 二叉树的下一个结点1
07-25
剑指Offer - 57 - 二叉树的下一个结点题目链接题目给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。//觉得改成parent更好
alienxcn#ZXBlog#剑指Offer - 58 - 对称的二叉树1
07-25
左右节点的值相等且对称子树left.left 和 right.right对称 ，且left.rigth和right.left也对称。boolean mirror
剑指offer- 07 重建二叉树
weixin_45599288的博客
04-18 576
根据前序遍历和后序遍历创建二叉树 根据中序遍历和后序遍历创建二叉树
剑指Offer-重建二叉树
疯狂的兔子
03-20 2031
题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 解题思想：递归思想！ 使用前序和中序遍历可以确认唯一的二叉树，通过前序可以得知根节点为1，然后通过中序可以得知左子树为{4, 7, 2}，右子树为{5,...
剑指offer---平衡二叉树
Unique-You的博客
01-17 211
题目描述输入一棵二叉树，判断该二叉树是否是平衡二叉树。class Solution { public: bool IsBalanced_Solution(TreeNode* pRoot) { if(!pRoot) return true; int left=getDepth(pRoot->left); int right=getDepth(
剑指offer---二叉树的镜像
Unique-You的博客
06-13 537
题目描述操作给定的二叉树，将其变换为源二叉树的镜像。/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: v...
剑指offer-重建二叉树C++实现
YANJINING
12-06 830
剑指offer-重建二叉树C++实现 原题链接 #include <iostream> #include <unordered_map> #include <vector> using namespace std; struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(nullp
剑指offer---重建二叉树
qq_47406941的博客
02-23 444
题目分析 在二叉树中，前序序列的第一个节点是根节点，而在中序序列中根节点一般在序列中间位置。中序序列中，根节点值的左侧的m个值是根节点的左子树根节点右侧的n个值值是根节点的右子树，而在前序序列中根节点后面紧跟着的m个值是左子树，其余的n个值是右子树。因此，可以通过递归利用左右子树的前序和中序序列构建左右子树，从而构建二叉树。 例如，下面的二叉树中，前序序列的第一个值就是1。根据中序序列的特点，可以确定中序序列中根节点的左侧有三个值右侧有四个值（左侧的三个值是左子树的值，右侧的四个值是右子树的值）。 ..
剑指offer -- 平衡二叉树
婷子的博客
08-04 148
leetcode链接：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof/ 输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回 true 。 示例 2: 给定二叉树 [1,2,2,3,3,nul...
剑指offer-二叉树的深度C++实现
YANJINING
11-26 544
剑指offer-二叉树的深度C++实现 原题链接 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: int TreeDepth(TreeNode* root) { // 根节点为叶子节点，返回0 if
剑指offer-二叉树的镜像-php
重口味码农
03-24 2453
题目 操作给定的二叉树，将其变换为源二叉树的镜像。 题解 翻转二叉树，有递归和非递归两种方式，非递归就是使用队列。 代码<?php/*class TreeNode{ var $val; var $left = NULL; var $right = NULL; function __construct($val){ $this->val = $
剑指OFFER-平衡二叉树
会有Mao的
10-31 99
剑指OFFER-平衡二叉树QuestionSolution递归 Question 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 关键词：二叉树 深度 递归 Solution 这题简直是二叉树深度的更新版，不仅要知道当前深度，还要判断左右深度差不能超过1。虽然既要返回深度也要返回判断，不好写函数的返回值，干脆设置深度为-1时代表否定，那么在递归中要时刻判断是否为-1，是就结束递归。 递归 时间复杂...
【Python学习-二叉树-递归】【剑指offer】之重建二叉树
12-21
本篇内容将讨论如何使用Python通过递归方法根据前序遍历和中序遍历的序列重建二叉树，这是基于《剑指Offer》中的一道题目。 二叉树的遍历主要有三种方式：前序遍历、中序遍历和后序遍历。前序遍历的顺序是根节点 ->...
zhidd#ZXBlog#剑指Offer - 22 - 从上往下打印二叉树1
07-25
剑指Offer - 22 - 从上往下打印二叉树题目链接题目从上往下打印出二叉树的每个节点，同层节点从左至右打印。直接上二叉树层次遍历代码即可。代码:publi
剑指offer--java版1--10源码及解析总结.zip
07-08
《剑指Offer——Java版1-10源码及解析总结》是一份针对《剑指Offer》这本书中前10个编程题目的Java实现及解析的资料合集。《剑指Offer》是许多程序员面试必备的参考书，它涵盖了大量经典的算法和数据结构问题，旨在...
深入剖析Oracle与MySQL在事务处理上的差异
10-06
在数据库管理系统中，事务处理是确保数据一致性和完整性的关键机制。Oracle和MySQL作为两大主流的数据库系统，在事务处理方面有着各自的特点和差异。本文将从事务的基本概念、隔离级别、锁机制以及事务控制语句等方面，详细探讨Oracle与MySQL在事务处理上的差异，并提供代码示例。 Oracle和MySQL在事务处理上有着各自的特点。Oracle提供了强大的并发控制和隔离级别管理，适合处理复杂的企业级事务。MySQL则以其简单性和灵活性，在Web应用和中小型项目中广泛使用。了解这些差异对于开发者选择合适的数据库系统以及优化事务处理至关重要。通过本文的分析和代码示例，读者应该能够更深入地理解Oracle与MySQL在事务处理上的差异，并在实际应用中做出更合适的选择。
电力系统稳态分析-考研必备
10-06
电力系统分析经典教材资料
人工智能在高中信息技术教学中的应用与实践.pdf
最新发布
10-06
毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询 毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询毕业设计选题/开题答辩/项目源码/论文等资源 硕博论文、期刊资源、有需要可详细咨询
基于Springboot和Vue的获奖的知名作家信息管理系统源码 获奖的知名作家信息管理系统代码
10-06
获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统-获奖的知名作家信息管理系统 1、资源说明：获奖的知名作家信息管理系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/detail
二叉树深度计算与剑指Offer面试题解
在《剑指Offer》这本经典的Java面试题集里，第39题涉及的是求解二叉树的深度问题。这个问题的主要目标是给定一棵二叉树，计算从根节点到最远叶子节点的最长路径长度，也就是树的深度。深度定义为从根节点到最远叶子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值