C++ 判断是否为2叉树的子树

最新推荐文章于 2020-07-31 11:05:14 发布
最新推荐文章于 2020-07-31 11:05:14 发布
阅读量614 收藏
点赞数
分类专栏： C++ 文章标签： C++ BiinaryTree IsSubTree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxin_003/article/details/39317757
版权

题目：

输入A.B 两棵树，判断B是否为A的子树：

IsSubTree.cpp:

#include <iostream>
#include <stdio.h>
#include "BinaryTree.h"
using namespace std;

bool IsSubTree(TreeNode* pRoot_s, TreeNode* pRoot_t);
bool HasSubtree(TreeNode* pRoot_s, TreeNode* pRoot_t)
{
	bool result = false;
	if(pRoot_t != NULL && pRoot_s != NULL)
	{
		if(pRoot_s -> m_value == pRoot_t -> m_value)
			result = IsSubTree(pRoot_s,pRoot_t);
		
		if(!result)
			result = HasSubtree(pRoot_s ->pLeft, pRoot_t);
		if(!result)
			result = HasSubtree(pRoot_s ->pRight, pRoot_t);
	}
	return result;
}
bool IsSubTree(TreeNode* pRoot_s, TreeNode* pRoot_t)
{
	if(pRoot_t == NULL)
		return true;
	if(pRoot_s == NULL)
		return false;
			
	if(pRoot_s ->m_value == pRoot_t -> m_value)
		return IsSubTree(pRoot_s -> pLeft , pRoot_t -> pLeft) && IsSubTree(pRoot_s -> pRight, pRoot_t -> pRight);
	else
		return false;
}
// ====================测试代码====================  
void Test(char* testName, TreeNode* pRoot1, TreeNode* pRoot2, bool expected)  
{  
    if(HasSubtree(pRoot1, pRoot2) == expected)  
        printf("%s passed.\n", testName);  
    else  
        printf("%s failed.\n", testName);  
}  
  
// 树中结点含有分叉，树B是树A的子结构  
//                  8                8  
//              /       \           / \  
//             8         7         9   2  
//           /   \  
//          9     2  
//               / \  
//              4   7  
void Test1()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(8);  
    TreeNode* pNodeA3 = CreateNode(7);  
    TreeNode* pNodeA4 = CreateNode(9);  
    TreeNode* pNodeA5 = CreateNode(2);  
    TreeNode* pNodeA6 = CreateNode(4);  
    TreeNode* pNodeA7 = CreateNode(7);  
  
    ConnectNodes(pNodeA1, pNodeA2, pNodeA3);  
    ConnectNodes(pNodeA2, pNodeA4, pNodeA5);  
    ConnectNodes(pNodeA5, pNodeA6, pNodeA7);  
  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(2);  
  
    ConnectNodes(pNodeB1, pNodeB2, pNodeB3);
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test1", pNodeA1, pNodeB1, true);  
  
    DestroyTree(pNodeA1);  
    DestroyTree(pNodeB1);  
}  
  
// 树中结点含有分叉，树B不是树A的子结构  
//                  8                8  
//              /       \           / \  
//             8         7         9   2  
//           /   \  
//          9     3  
//               / \  
//              4   7  
void Test2()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(8);  
    TreeNode* pNodeA3 = CreateNode(7);  
    TreeNode* pNodeA4 = CreateNode(9);  
    TreeNode* pNodeA5 = CreateNode(3);  
    TreeNode* pNodeA6 = CreateNode(4);  
    TreeNode* pNodeA7 = CreateNode(7);  
  
    ConnectNodes(pNodeA1, pNodeA2, pNodeA3);  
    ConnectNodes(pNodeA2, pNodeA4, pNodeA5);  
    ConnectNodes(pNodeA5, pNodeA6, pNodeA7);  
  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(2);  
  
    ConnectNodes(pNodeB1, pNodeB2, pNodeB3); 
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test2", pNodeA1, pNodeB1, false);  
  
    DestroyTree(pNodeA1);  
    DestroyTree(pNodeB1);  
}  
  
// 树中结点只有左子结点，树B是树A的子结构  
//                8                  8  
//              /                   /   
//             8                   9     
//           /                    /  
//          9                    2  
//         /        
//        2          
//       /  
//      5  
void Test3()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(8);  
    TreeNode* pNodeA3 = CreateNode(9);  
    TreeNode* pNodeA4 = CreateNode(2);  
    TreeNode* pNodeA5 = CreateNode(5);  
  
    ConnectNodes(pNodeA1, pNodeA2, NULL);  
    ConnectNodes(pNodeA2, pNodeA3, NULL);  
    ConnectNodes(pNodeA3, pNodeA4, NULL);  
    ConnectNodes(pNodeA4, pNodeA5, NULL);  
  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(2);  
  
    ConnectNodes(pNodeB1, pNodeB2, NULL);  
    ConnectNodes(pNodeB2, pNodeB3, NULL); 
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test3", pNodeA1, pNodeB1, true);  
  
    DestroyTree(pNodeA1);  
    DestroyTree(pNodeB1);  
}  
  
// 树中结点只有左子结点，树B不是树A的子结构  
//                8                  8  
//              /                   /   
//             8                   9     
//           /                    /  
//          9                    3  
//         /        
//        2          
//       /  
//      5  
void Test4()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(8);  
    TreeNode* pNodeA3 = CreateNode(9);  
    TreeNode* pNodeA4 = CreateNode(2);  
    TreeNode* pNodeA5 = CreateNode(5);  
  
    ConnectNodes(pNodeA1, pNodeA2, NULL);  
    ConnectNodes(pNodeA2, pNodeA3, NULL);  
    ConnectNodes(pNodeA3, pNodeA4, NULL);  
    ConnectNodes(pNodeA4, pNodeA5, NULL);  
  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(3);  
  
    ConnectNodes(pNodeB1, pNodeB2, NULL);  
    ConnectNodes(pNodeB2, pNodeB3, NULL);  
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test4", pNodeA1, pNodeB1, false);  
  
    DestroyTree(pNodeA1);  
    DestroyTree(pNodeB1);  
}  
  
// 树中结点只有右子结点，树B是树A的子结构  
//       8                   8  
//        \                   \   
//         8                   9     
//          \                   \  
//           9                   2  
//            \        
//             2          
//              \  
//               5  
void Test5()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(8);  
    TreeNode* pNodeA3 = CreateNode(9);  
    TreeNode* pNodeA4 = CreateNode(2);  
    TreeNode* pNodeA5 = CreateNode(5);  
  
    ConnectNodes(pNodeA1, NULL, pNodeA2);  
    ConnectNodes(pNodeA2, NULL, pNodeA3);  
    ConnectNodes(pNodeA3, NULL, pNodeA4);  
    ConnectNodes(pNodeA4, NULL, pNodeA5);  
  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(2);  
  
    ConnectNodes(pNodeB1, NULL, pNodeB2);  
    ConnectNodes(pNodeB2, NULL, pNodeB3);  
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test5", pNodeA1, pNodeB1, true);  
  
    DestroyTree(pNodeA1);  
    DestroyTree(pNodeB1);  
}  
  
// 树A中结点只有右子结点，树B不是树A的子结构  
//       8                   8  
//        \                   \   
//         8                   9     
//          \                 / \  
//           9               3   2  
//            \        
//             2          
//              \  
//               5  
void Test6()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(8);  
    TreeNode* pNodeA3 = CreateNode(9);  
    TreeNode* pNodeA4 = CreateNode(2);  
    TreeNode* pNodeA5 = CreateNode(5);  
  
    ConnectNodes(pNodeA1, NULL, pNodeA2);  
    ConnectNodes(pNodeA2, NULL, pNodeA3);  
    ConnectNodes(pNodeA3, NULL, pNodeA4);  
    ConnectNodes(pNodeA4, NULL, pNodeA5);  
  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(3);  
    TreeNode* pNodeB4 = CreateNode(2);  
  
    ConnectNodes(pNodeB1, NULL, pNodeB2);  
    ConnectNodes(pNodeB2, pNodeB3, pNodeB4);  
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test6", pNodeA1, pNodeB1, false);  
  
    DestroyTree(pNodeA1);  
    DestroyTree(pNodeB1);  
}  
  
// 树A为空树  
void Test7()  
{  
    TreeNode* pNodeB1 = CreateNode(8);  
    TreeNode* pNodeB2 = CreateNode(9);  
    TreeNode* pNodeB3 = CreateNode(3);  
    TreeNode* pNodeB4 = CreateNode(2);  
  
    ConnectNodes(pNodeB1, NULL, pNodeB2);  
    ConnectNodes(pNodeB2, pNodeB3, pNodeB4);  
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(NULL);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(pNodeB1);
	cout <<endl;
  
    Test("Test7", NULL, pNodeB1, false);  
  
    DestroyTree(pNodeB1);  
}  
  
// 树B为空树  
void Test8()  
{  
    TreeNode* pNodeA1 = CreateNode(8);  
    TreeNode* pNodeA2 = CreateNode(9);  
    TreeNode* pNodeA3 = CreateNode(3);  
    TreeNode* pNodeA4 = CreateNode(2);  
  
    ConnectNodes(pNodeA1, NULL, pNodeA2);  
    ConnectNodes(pNodeA2, pNodeA3, pNodeA4);  
  //后序遍历
	cout << "The source tree is: ";
	PrintTree(pNodeA1);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(NULL);
	cout <<endl;
    Test("Test8", pNodeA1, NULL, false);  
  
    DestroyTree(pNodeA1);  
}  
  
// 树A和树B都为空  
void Test9()  
{  
	//后序遍历
	cout << "The source tree is: ";
	PrintTree(NULL);
	cout <<endl;
	cout << "The test tree is: ";
	PrintTree(NULL);
	cout <<endl;
    Test("Test9", NULL, NULL, false);  
}  
  
int main()  
{  
    Test1();  
    Test2();  
    Test3();  
    Test4();  
    Test5();  
    Test6();  
    Test7();  
    Test8();  
    Test9();  
	system("PAUSE");
    return 0;  
}

BinaryTree.h: 

#include <iostream>
#include <stdio.h>
using namespace std;
struct TreeNode
{
	TreeNode* pLeft;
	TreeNode* pRight;
	int m_value;
};
TreeNode* CreateNode(int value);  
void ConnectNodes(TreeNode* pParent, TreeNode* pLeft, TreeNode* pRight);  
void PrintNode(TreeNode* pNode);  
void PrintTree(TreeNode* pRoot);  
void DestroyTree(TreeNode* pRoot);

BinaryTree.cpp: 

#include <iostream>
#include <stdio.h>
#include "BinaryTree.h"
using namespace std;
TreeNode* CreateNode(int value)
{
	TreeNode* pNode = new TreeNode;
	pNode -> pLeft = NULL;
	pNode -> pRight = NULL;
	pNode -> m_value = value;
	return pNode;
}
void ConnectNodes(TreeNode* parent,TreeNode* pleft,TreeNode* pright)
{
	if(parent != NULL)
	{
		parent -> pLeft = pleft;
		parent -> pRight = pright;
	}else
		return ;		
}
void PrintNode(TreeNode* pNode)
{
	if(pNode != NULL)
	{
		cout << pNode->m_value;
		if(pNode -> pLeft != NULL)
			cout<<"The left child of this node is:"<<pNode -> pLeft ->m_value;
		else
			cout<< "The left child of this node is null";
		if(pNode ->pRight != NULL)
			cout<<"The right child of this node is "<<pNode ->pRight ->m_value;
		else
			cout <<"The right child of this node is null";

	}
	else
		cout <<"The node is null"<<endl;
}
void PrintTree(TreeNode* pRoot)
{
	if(pRoot != NULL)
	{
		if(pRoot ->pLeft != NULL)
			PrintTree(pRoot -> pLeft);
		if(pRoot -> pRight != NULL)
			PrintTree(pRoot->pRight);
		cout << pRoot->m_value;
	}else
		return;
}
void DestroyTree(TreeNode* pRoot)
{
	if(pRoot -> pLeft != NULL)
		DestroyTree(pRoot ->pLeft);
	if(pRoot -> pRight != NULL)
		DestroyTree(pRoot -> pRight);
	if(pRoot)
	{
		delete pRoot;
		pRoot = NULL;
	}
	else
		return;
}

运算结果：


chenxin_003
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
四叉树quadtree的c++实现
06-06
在C++中实现四叉树，首先需要定义四叉树节点的结构。节点通常包含以下几个部分： 1. 数据域：存储每个节点所代表的区域内的点信息。 2. 四个子节点指针：分别指向上、下、左、右四个子区域的四叉树节点。 3. 存储...
c++的二叉树
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
C++二叉树（子树判断）
W_king_9的博客
07-06 712
树的子结构（递归）问题描述结果知识点代码总结 问题描述 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 结果 运行时间：3ms 占用内存：468k 知识点 递归思想对树的基本操作 代码 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; Tree...
剑指offer（17）——C++实现判断树的子树
fengwenpei的博客
08-22 456
题目 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 考察点 树、指针、递归 解题思路 二叉树的遍历常用递归实现。先从A的根节点开始判断，若相同再去判断A的左右子树节点。 完整代码 /*17-树的子结构*/ #include<iostream> using namespace std; //树的创建 struct TreeNode { ...
判断一个树是否为二叉树的子树（力扣习题）
weixin_45755718的博客
04-22 345
题目描述： 给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。 示例： 来源：力扣（LeetCode） 代码： /** * Definition for a binary tree node. * public class TreeNode { * int ...
C++语言实现多叉树功能
qq_38733782的博客
03-06 6020
参考了这篇文章https://segmentfault.com/a/1190000002451356CTreeData 为插入节点数据，用户可以根据自身情况自定义tree.h#ifndef _TREE_H_ #define _TREE_H_ #include&lt;stdlib.h&gt; #include&lt;string.h&gt; class CNode { public: C...
四叉树_C++_四叉树_
10-01
文件名为"四叉树"，可能是一个源代码文件或数据文件，用于演示如何在C++中构建和操作四叉树。 总结来说，四叉树是计算机科学中一种强大的数据结构，尤其适用于处理网格状数据。在C++中实现四叉树，需要定义节点类，...
C++四叉树图像模糊.zip
10-29
本项目"利用四叉树对颜色相近的区域进行模糊"旨在通过C++实现，将四叉树与图像模糊技术结合，以高斯模糊为例，优化对图像的模糊处理。 首先，我们需要理解四叉树的概念。四叉树（Quadtree）是一种分形数据结构，每...
C++实现四叉树效果(附源码下载)
01-21
什么是四叉树？ 如图，设想， 红框表示地图，星星表示单位，黄框表现范围， 要处理地图中范围内的单位，最直接的做法是筛选所有单位。 通过上图可以看到一个显而易见的问题，大部分单位都不需要被处理。 如果把地图...
C++实现二叉树的插入、删除、查询、遍历
远走的兔子博客
04-09 4万+
1.二叉树的概念        树是一些节点的集合，节点之间用边链接，节点之间不能有环路。上层的节点称为父节点，下层节点称为子节点。最上层的节点称为根节点。       二叉树是特殊的树。对于每个节点而言，与之直接相连的子节点不能超过两个（可以为0）。左边的子节点称为左子树，右边的子节点称为右子树。如下图就是一颗二叉树： 与树相关的一些概念：          没有任何子节点的节点
两个二叉树，判断A与B的关系，是否存在子树 或子结构情况 C++ 实现
因每天学习而伟大
08-06 730
#include &lt;iostream&gt; #include &lt;string&gt; #include &lt;vector&gt; using namespace std; struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : v...
C++二叉树
p=f/s
07-31 3032
本篇主要写二叉树的结构，中序、前序、后序、层序遍历算法。 二叉树的结构，本篇以如下这个二叉树进行遍历： 中序遍历：左子节点---->中间节点---->右子节点 前序遍历：中间节点----->左子节点---->右子节点 后序遍历: 左子节点----->右子节点----->中间节点 层序遍历：一层一层的从上往下遍历 以上图二叉树结构为例，开始编写代码： #include <iostream> #include <queue> us.
二叉树的C++实现
Ajay666的博客
08-05 2万+
数据结构与二叉树类的定义我采用链式存储结构来表示二叉树，每一个二叉树节点包含树节点的值、树的左孩子指针、树的右孩子指针：class BiNode{ public: char data; struct BiNode *lchild,*rchild; };那么对于一个二叉树来说，只需要存放指向树根节点的指针即可，另外还需要声明二叉树的一些功能，比如遍历方法、求树高等（BiTree.h）：
C++ 数据结构 二叉排序树/二叉查找树
weixin_44062380的博客
06-16 3305
数据结构 二叉排序树前言概念介绍二叉排序树存在意义的思考操作以及代码展示插入元素查找元素删除元素二叉排序树的优缺点及解决方法优点缺点解决方案 前言 今天在学习红黑树的时候，看到了引导课拿二叉排序树举例，想到之前还没写过二叉排序树的代码，所以这次特地写了一下，这里把二叉排序树的性质和写代码时出现的问题做一个分享。 概念 介绍 在写之前，要先了解什么是二叉排序树 二叉查找树，它有一个根节点，且每个节点下最多有只能有两个子节点，左子节点的值小于其父节点，右子节点的值大于其父节点。 我们依次插入数据：43,98,
二叉树(二叉树相关的算法c++实现)
kissablemt的博客
03-07 3322
二叉树是什么? 二叉树就是每个节点(Node)最多只有两个子节点的树结构,且子树有左右之分,不能任意颠倒顺序. 根据二叉树的特性,便有了二叉排序树. 一般数据以二叉树作为数据结构储存时,都是按照二叉排序树的一般规则("小放左,大放右"). 为了各位检验,main()函数和测试数据在最后给出. 二叉树节点定义 struct Node { int va...
多叉树：判断某个子树是否属于某个父树，如果属于，从父树中删除子树
橙子wj的博客
09-29 2649
如果只想直接看算法的，可以跳到第3个标题；其他几个标题的内容作为背景铺垫，介绍为什么要写这个算法，以及可以解决什么实际问题，解决之后的效果如何。因为如果不联系实际，一些人会认为树之类的数据结构没什么用武之地，太抽象。结合其他几个标题的内容可以帮助理解。1 问题背景分析最近在公司做一个知识库分享平台的用户权限的后台功能，大概是这样的： 权限分为很多级，如下图所示：当然所有权限不止这些，分类下面还有软
C++二叉树的建立与遍历
热门推荐
KarlDoenitz的专栏
11-13 5万+
从别处找来几个例子，感觉还可以，同学们拿回去看看吧，有什么地方不懂可以下可以后来实验室问我。//==========================================定义头部 #include using namespace std; struct BiTNode{ char data; struct BiTNode *lchild, *rchild;//左右孩子 }; BiT
二叉树简介及C++实现
网络资源是无限的
10-21 1万+
二叉树是每个结点最多有两个子树的树结构，即结点的度最大为2。通常子树被称作”左子树”和”右子树”。二叉树是一个连通的无环图。 二叉树是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态：(1)、空二叉树；(2)、只有一个根结点的二叉树；(3)、只有左子树；(4)、只有右子树；(5)、完全二叉树。 二叉树类型： (1)、满二叉树：深度(层数)为k，且有2^k-1个结点的二叉树。这种树...
数据结构（树，二叉搜索树，平衡二叉树 C++实现）
konglongdanfo的博客
07-22 1505
树 树（Tree）是n（n&gt;=0）个结点的有限集合。n = 0时称为空树。在任意一颗非空树中：(1)有且仅有一个特定的称为根（Root）的结点；（2）当n &gt; 1时，其余结点可分为m （m &gt; 0）个互不相交的有限集 T1T1T_1 、 T2T2T_2 、 …… 、 TmTmT_m ，其中每一个集合本身又是一个树，并且称为根的子树（SubTree），如下图所示： 树的结点...
c++判断一棵树是否为二叉排序树
最新发布
04-23
判断一棵树是否为二叉排序树，需要遵循以下规则： 1. 左子树的所有节点都比根节点小； 2. 右子树的所有节点都比根节点大； 3. 左右子树本身也都是二叉排序树。 因此，对于一棵树来说，如果满足以上条件，则它就是一个二叉排序树。 为了判断一棵树是否为二叉排序树，可以采用以下方法： 1. 采用中序遍历（左子树-根节点-右子树）的方式遍历整棵树； 2. 遍历过程中，利用一个变量记录当前遍历到的最后一个节点的值； 3. 如果当前节点的值小于等于前一个节点的值，则说明不满足排序要求，该树不是二叉排序树，否则继续遍历； 4. 如果遍历到最后一个节点，且都满足排序要求，则说明该树是二叉排序树。 以上就是判断一棵树是否为二叉排序树的方法。希望能对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值