二叉树进阶

最新推荐文章于 2024-06-15 18:06:06 发布
最新推荐文章于 2024-06-15 18:06:06 发布
阅读量27 收藏
点赞数 1
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gtyyky/article/details/132198456
版权

一、二叉搜索树

1.1 二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树
在这里插入图片描述

1.2 二叉搜索树操作

在这里插入图片描述

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

1. 二叉搜索树的查找
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。
2. 二叉搜索树的插入
插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
在这里插入图片描述

  1. 二叉搜索树的删除
    首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
    况：
    a. 要删除的结点无孩子结点
    b. 要删除的结点只有左孩子结点
    c. 要删除的结点只有右孩子结点
    d. 要删除的结点有左、右孩子结点
    看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
    如下：
    情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
    情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
    情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除
    替换法：左子树的最右节点（最大节点）或者右子树的最左节点（最小节点）。

在这里插入图片描述

1.3 二叉搜索树的实现

#pragma once

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree()
		:_root(nullptr)
	{}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) //当cur等于空指针的时候调出循环，在cur的位置插入，用parent是cur父节点，便于插入新节点
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false; //找到相等的，不插入
			}
		}

		cur = new Node(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}

	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if(cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//找到了
			{
				//左为空
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = _root->_right;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}
				}
				//右为空
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = _root->_left;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
				}
				//左右都不为空
				else
				{
					//找替代节点(左边最右节点或者右边最左节点都可以),这里找最左节点
					Node* parent = cur;//这里要用cur,因为如果leftMax->_right一上来就是nullptr，下面的循环没有进入，第二个循环使用parent就会报错
					Node* leftMax = cur->_left;
					while (leftMax->_right)
					{
						parent = leftMax;
						leftMax = leftMax->_right;
					}

					//找到可以替代的节点，将数值进行替换
					swap(cur->_key, leftMax->_key);

					//删除要删除的节点
					if (parent->_left == leftMax)
					{
						parent->_left = leftMax->_left;//将最右节点的左边接起来，是空的话也不影响
					}
					else
					{
						parent->_right = leftMax->_left;
					}

					cur = leftMax;
				}

				delete cur;
				return true;
			}
		}

		return false;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	void _InOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

private:
	Node* _root;
};

void TestBSTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t;
	for (auto e : a)
	{
		t.Insert(e);
	}

	t.InOrder();

	t.Erase(4);
	t.InOrder();

	t.Erase(6);
	t.InOrder();

	t.Erase(7);
	t.InOrder();

	t.Erase(3);
	t.InOrder();

	for (auto e : a)
	{
		t.Erase(e);
	}
	t.InOrder();
}

运行结果：
在这里插入图片描述

1.4 二叉搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
    在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
  2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
    再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
// 改造二叉搜索树为KV结构
template<class K, class V>
struct BSTNode
{
	BSTNode(const K& key = K(), const V& value = V())
	 : _pLeft(nullptr) , _pRight(nullptr), _key(key), _Value(value)
	{}
	BSTNode<T>* _pLeft;
	BSTNode<T>* _pRight;
	K _key;
	V _value
};
template<class K, class V>
class BSTree
{
	typedef BSTNode<K, V> Node;
	typedef Node* PNode;
public:
	BSTree(): _pRoot(nullptr){}
	PNode Find(const K& key);
	bool Insert(const K& key, const V& value)
	bool Erase(const K& key)
private:
	PNode _pRoot;
};
void TestBSTree3()
{
	// 输入单词，查找单词对应的中文翻译
	BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("left", "左边、剩余");
	dict.Insert("right", "右边");
	dict.Insert("sort", "排序");
	// 插入词库中所有单词
	string str;
	while (cin>>str)
	{
		BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret == nullptr)
		{
			cout << "单词拼写错误，词库中没有这个单词:" <<str <<endl;
		}
		else
		{
			cout << str << "中文翻译:" << ret->_value << endl;
		}
	}
}
void TestBSTree4()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉" };
	BSTree<string, int> countTree;
	for (const auto& str : arr)
	{
		// 先查找水果在不在搜索树中
		// 1、不在，说明水果第一次出现，则插入<水果, 1>
		// 2、在，则查找到的节点中水果对应的次数++
		//BSTreeNode<string, int>* ret = countTree.Find(str);
		auto ret = countTree.Find(str);
		if (ret == NULL)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
}

运行结果：
![在这里插入图片描述](https://img-blog.csdnimg.cn/50870f98d1934b77b6711a0baa8b7845.png

在这里插入图片描述

1.5 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二
叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为： l o g 2 N log_2 N log2​N
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为： N 2 \frac{N}{2} 2N​
问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插
入关键码，二叉搜索树的性能都能达到最优？AVL树和红黑树就可以。

三、 二叉树进阶面试题

  1. 二叉树创建字符串。OJ链接
class Solution {
public:
    string tree2str(TreeNode* root) 
    {
        if(root == nullptr)
            return "";

        string str = to_string(root->val);//把数字转化为字符
        //左边为空，右边不为空的情况，左边的括号要保留
        if(root->left || root->right)
        {
            str+= '(';
            str+=tree2str(root->left);
            str+= ')';
        }
        //右边为空的话不进入(右边括号不保留)
        if(root->right)
        {
            str+= '(';
            str+=tree2str(root->right);
            str+= ')';
        }

        return str;
    }
};
  1. 二叉树的分层遍历1。OJ链接
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        vector<vector<int>> vv;
        queue<TreeNode*> q;
        int levelsize = 0;
        if(root)
        {
            q.push(root);
            levelsize = 1;
        }

        while(!q.empty())
        {
            vector<int>v;//这一句必须放在 while 循环中，因为每一层都需要一个新的v来存储节点值。
            //一层一层存入
            //每pop一个数，将它的值存入到v中，再将它的左右子孩子放存入到栈中
            for(int i = 0;i < levelsize; i++)
            {
                TreeNode* front = q.front();
                v.push_back(front->val);
                q.pop();
                
                if(front->left)
                {
                    q.push(front->left);
                }
                if(front->right)
                {
                    q.push(front->right);
                }
            }
            vv.push_back(v);//将每层的数据放入二维数组
            levelsize = q.size();//每层存入的个数就是下一次遍历的个数
        }
    return vv;
    }
};
  1. 二叉树的分层遍历2。OJ链接
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) 
    {
        vector<vector<int>> vv;
        queue<TreeNode*> q;

        int levelsize = 0;
        if(root)
        {
            q.push(root);
            levelsize = 1;
        }

        while(!q.empty())
        {
            vector<int> v;
            for(int i = 0;i<levelsize;i++)
            {
                TreeNode* front = q.front();
                q.pop();

                v.push_back(front->val);

                if(front->left)
                    q.push(front->left);

                if(front->right)
                    q.push(front->right);
            }
            levelsize = q.size();
            vv.push_back(v);
        }
        reverse(vv.begin(),vv.end());
        return vv;
    }
};
  1. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。OJ链接
在这里插入代码片

 //1.p和q在当前根节点的俩侧时，当前节点就是公共祖先
 //2.p或q其中一个是根节点时，公共节点就是当前根节点
// class Solution {
// public:
//     //查找pq位置
//     bool Find(TreeNode* tree,TreeNode* x)
//     {
//         if(tree==nullptr)
//             return false;

//         return tree == x || Find(tree->left,x) || Find(tree->right,x);
//     }
//     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
//     {
//         if(root==nullptr)
//             return nullptr;

//         //p或q其中一个与root相等，当前root就是公共祖先
//         if(root==p || root==q)
//             return root;

//         bool pinleft,pinright,qinleft,qinright;
//         pinleft = Find(root->left,p);
//         pinright = !pinleft;

//         qinleft = Find(root->left,q);
//         qinright = !qinleft;

//         //p和q在同一侧就继续递归查找，当p和q不在同一侧，当前root就是公共祖先
//         if(qinleft && pinleft)
//         {
//             //都在左边，继续找
//             return lowestCommonAncestor(root->left,p,q);
//         }
//         else if(pinright && qinright)
//         {
//             return lowestCommonAncestor(root->right,p,q);
//         }
//         else
//         {
//             //在根节点的左右侧，返回root
//             return root;
//         }
//     }
// };

//方法二
class Solution {
public:
    //查找路径函数，通过前序遍历，将路径放进栈中，注意栈中存放的是节点的地址
    bool FindPath(TreeNode* root, TreeNode* x, stack<TreeNode*>& path)
    {
        if(root == nullptr)
            return false;

        path.push(root);

        //root与x相等，找到节点，返回true
        if(root == x)
            return true;

        //在root节点左侧找到，返回ture
        if(FindPath(root->left,x,path))
            return true;
        //在root节点右侧找到，返回ture
        if(FindPath(root->right,x,path))
            return true;

        //走到这里，说明节点的左右都是空指针或者没有目标节点，将该节点从栈中删除
        path.pop();
        return false;    
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        stack<TreeNode*> Ppath;
        stack<TreeNode*> Qpath;

        FindPath(root,p,Ppath);
        FindPath(root,q,Qpath);

        //让俩条路径的size相等
        while(Ppath.size() > Qpath.size())
        {
            Ppath.pop();
        }

        while(Qpath.size()>Ppath.size())
        {
            Qpath.pop();
        }

        //将不相等的节点pop，当出现第一个相等的节点说明该节点就是最近公共节点
        while(Ppath.top()!=Qpath.top())
        {
            Ppath.pop();
            Qpath.pop();
        }

        return Qpath.top();
    }
};

5. 二叉树搜索树转换成排序双向链表。OJ链接

class Solution 
{
public: 
    void InOrder(TreeNode* cur,TreeNode*& prev)//prev要加上引用，因为前后的prev有关联
    {
        if(cur == nullptr)
            return;
        
        InOrder(cur->left,prev);
		//当前left指向前一个
		cur->left=prev;
		//前一个right指向当前节点
		if (prev) //第一次prev是空指针就不进入
		{
			prev->right = cur;
		}
		prev = cur;

        InOrder(cur->right,prev);
    }

    TreeNode* Convert(TreeNode* pRootOfTree) 
    {
        TreeNode* prev = nullptr;
		InOrder(pRootOfTree,prev);

		//找头节点
		TreeNode* head = pRootOfTree;
		while (head&&head->left) 
		{
			head=head->left;
		}

		return head;
    }
};
  1. 根据一棵树的前序遍历与中序遍历构造二叉树。 OJ链接
class Solution {
public:
    TreeNode* _build(vector<int>& preorder, vector<int>& inorder,
                        int& prei,int inbegin,int inend) 
    {
        if(inbegin > inend)
            return nullptr;

        TreeNode* root = new TreeNode(preorder[prei]);

        int rooti = inbegin;
        while(rooti < inend)
        {
            if(preorder[prei] == inorder[rooti])
                break;

            ++rooti;
        }

        //[inbegin,rooti-1] rooti [rooti+1,inend]
        prei++;

        //递归建立左树
        root->left = _build(preorder,inorder,prei,inbegin,rooti-1);
        //递归建立右树
        root->right = _build(preorder,inorder,prei,rooti+1,inend);

        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) 
    {
        int prei = 0;
        return _build(preorder,inorder,prei,0,preorder.size()-1);
    }
};
  1. 根据一棵树的中序遍历与后序遍历构造二叉树。OJ链接
class Solution {
public:
    TreeNode* _build(vector<int>& inorder, vector<int>& postorder,
                    int& posti,int inbegin,int inend) 
    {
        if(inbegin > inend)
            return nullptr;

        TreeNode* root = new TreeNode(postorder[posti]);

        int rooti = inbegin;
        while(rooti < inend)
        {
            if(postorder[posti] == inorder[rooti])
                break;

            ++rooti;
        }

        //[inbegin,rooti-1] rooti [rooti+1,inend]
        posti--;

        //递归建立右树
        root->right = _build(inorder,postorder,posti,rooti+1,inend);
        //递归建立左树
        root->left = _build(inorder,postorder,posti,inbegin,rooti-1);

        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) 
    {
        int posti = postorder.size()-1;

        return _build(inorder,postorder,posti,0,postorder.size()-1);
    }
};
  1. 二叉树的前序遍历，非递归迭代实现 。OJ链接
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) 
    {
        //栈用来存放左路节点，利用栈后进先出的特性依次访问右路的顺序
        stack<TreeNode*> st;
        TreeNode* cur = root;
        vector<int> v;
        while(cur || !st.empty())
        {
            //访问一棵树的开始
            //访问左路节点，将左路节点入栈
            while(cur)
            {
                v.push_back(cur->val);
                st.push(cur);
                cur = cur->left;
            }

            //依次访问右路
            TreeNode* top = st.top();
            st.pop();

            cur = top->right;
        }

        return v;
    }
};
  1. 二叉树中序遍历 ，非递归迭代实现。OJ链接
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root)
    {
        //栈用来存放左路节点，利用栈后进先出的特性依次访问右路的顺序
        stack<TreeNode*> st;
        TreeNode* cur = root;
        vector<int> v;
        while(cur || !st.empty())
        {
            //访问一棵树的开始
            //访问左路节点，将左路节点入栈，后续依次访问左路节点的右子树
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }

            //依次访问左路节点和左路节点的右子树
            TreeNode* top = st.top();
            st.pop();

            v.push_back(top->val);

            //子问题的方式访问右子树
            cur = top->right;
        }

        return v;
    }
};
  1. 二叉树的后序遍历 ，非递归迭代实现。OJ链接
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) 
    {
        stack<TreeNode*> st;
        vector<int> v;
        TreeNode* cur = root;
        TreeNode* prev = nullptr;

        while(cur || !st.empty())
        {
            //跳出循环说明左子树为空了，如果右子树为空就进行访问，访问完毕说明该节点的父节点的
            //左子树访问了，继续判断父节点的右子树是否为空或者上一个访问节点是否为父节点右子树的根
            while(cur)
            {
                st.push(cur);
                cur = cur->left;
            }
        
            //一个节点的右子树为空或者上一个访问节点是右子树的根
            //那么都说明相当于右树访问过了，可以访问当前根的节点
            TreeNode* top = st.top();
            if(top->right == nullptr || top->right == prev)
            {
                prev=top;//将访问完的节点存入到prev
                v.push_back(top->val);
                st.pop();
            }
            //继续将右子树放入栈中
            else
            {
                cur = top->right;
            }

        }
        return v;
    }
};
sy'ty
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树进阶
New_learner55的博客
12-28 301
在我看来，在数据结构中，存在三个最经典的树型结构，他们分别是二叉排序树（BST），二叉平衡树（AVL） 和 红黑树（BRT）。 二叉排序树又叫做二叉搜索树，它可以是一棵空树，也可以是具有三个性质的一棵二叉树。 性质一：若它的左子树不为空，则左子树上的所有结点的值均小于它的根结点的值 性质二： 若它的右子树不为空，则右子树上的所有结点的值均大于它的根结点的值 性质三： 左右子树也是二叉排序树。 构造二叉搜索树的目的是提高查找和插入删除关键字的速度。因为二叉排序树是一个排序好的有序数据集，查找的速度肯定是快于无
易语言二叉树遍历源码-易语言
06-13
易语言二叉树遍历源码
二叉树进阶问题
weixin_51970219的博客
01-02 987
二叉树进阶问题 1. package bin_tree.leetcode; import java.util.LinkedList; import java.util.Queue; public class IsCompleteTree { public boolean isCompleteTree(TreeNode root) { if (root == null) { return true; } // 层序遍历判断二叉
【数据结构从0到1】第七篇：二叉树进阶
Pass-by
04-30 167
文章目录一、搜索二叉树1.1 二叉搜索树概念1.2 二叉搜索树操作1.3 二叉搜索树的实现 一、搜索二叉树 1.1 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int a [] = {5,3,4,1,7,8,2,6,0,9}; 1.2 二叉搜索树操作 二叉搜索树的查找 2. 二叉搜索树的插入 插入的具体
C++二叉树进阶
weixin_53946312的博客
10-24 2135
二叉树进阶二叉搜索树二叉搜索树概念二级目录三级目录 二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 时间复杂度：O(N)，只有当树的形状接近完全二叉树或者满二叉树，才能达到 logN 搜索二叉树延伸：AVLTree 红黑树(对搜索二叉树左右高度提出要求，非常接近完全二叉树，效率可达到 O(logN))
二叉树进阶——二叉树OJ
m0_73802195的博客
04-08 990
为了巩固我们对于二叉树的理解本篇文章我们来练习一些二叉树的OJ题。
Java二叉树进阶面试题讲解
xinhang10的博客
03-29 614
本文章主要讲解了二叉树的进阶面试题，作者除了给予大家代码和习题链接外，还为大家带来了这些二叉树进阶面试题的具体思路，引导大家一步一步的解题。
二叉树进阶题目(超详解)
庖丁解牛，恢恢乎游刃有余
12-24 1727
二叉树进阶的题目不一定更复杂，但一定更适合用C++去写。这里的题目用C语言去做会非常恶心。
【C++】二叉树进阶
2301_79585944的博客
05-08 865
世上有两种耀眼的光芒，一种是正在升起的太阳，一种是正在努力学习编程的你!一个爱学编程的人。各位看官，我衷心的希望这篇博客能对你们有所帮助，同时也希望各位看官能对我的文章给与点评，希望我们能够携手共同促进进步，在编程的道路上越走越远！提示：以下是本篇文章正文内容，下面案例可供参考好了，本篇博客到这里就结束了，如果有更好的观点，请及时留言，我会认真观看并学习。不积硅步，无以至千里；不积小流，无以成江海。
二叉树进阶——搜索二叉树
zxj20041003的博客
07-02 128
插入的结点位置比是叶子结点。
LeetCode 1379. 找出克隆二叉树中的相同节点（二叉树遍历）
12-21
1. 题目 给你两棵二叉树，原始树 original 和克隆树 cloned，以及一个位于原始树 original 中的目标节点 target。...进阶：如果树中允许出现值相同的节点，你将如何解答？ 来源：力扣（LeetCode） 链接：htt
LeetCode–144,94,145,102 二叉树的前序、中序、后序、层序遍历(递归，迭代，栈，队列)
12-21
二叉树的前序、中序、后序、层序遍历(递归，迭代...这道题目是二叉树相关问题的基础类问题，利用递归是比较容易想到的方法，但是进阶问题要求用迭代算法来完成，这个需要好好想一下。但是关于二叉树的前序，中序，后序
基于左右旋平衡二叉树以及相关树的算法c源码+使用说明.zip
11-06
2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。...
6.15 c语言
jwh199694的博客
06-15 128
char类型的指针变量称为字符指针变量，字符指针变量与字符有着密切关系，他也被用来处理字符串。当一个字符指针指向一个字符串常量时，不能修改指针指向的对象的值。3、字符串常量//char *p = “welcome”;字符串常量不能被修改，因为存储在静态存储区//会发生段错误。初始化字符指针是把内存中字符串的首地址赋予指针。c语言通过使用字符数组来处理字符串。2、static局部变量。
c++ 6.11
Johan1111的博客
06-11 268
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 800
Deque（双端队列）是C++ STL中的一种序列容器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1021
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C语言猜输赢游戏
最新发布
qq_69383179的博客
06-15 1404
这里有关于C语言猜输赢游戏的程序
请用kotlin解决这个问题：101. 对称二叉树 给你一个二叉树的根节点 root ， 检查它是否轴对称。 示例 1： 输入：root = [1,2,2,3,4,4,3] 输出：true 示例 2： 输入：root = [1,2,2,null,3,null,3] 输出：false 提示： 树中节点数目在范围 [1, 1000] 内 -100 <= Node.val <= 100 进阶：你可以运用递归和迭代两种方法解决这个问题吗？
05-28
好的，下面是用 Kotlin 解决该问题的代码，其中包含了递归和迭代两种解法： ```kotlin class Solution { // 递归解法 fun isSymmetric(root: TreeNode?): Boolean { return isMirror(root, root) ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值