简单的几道算法题_About Binary Tree

最新推荐文章于 2023-02-09 19:00:32 发布
最新推荐文章于 2023-02-09 19:00:32 发布
阅读量358 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vinvcr/article/details/38961391
版权

存着 以免下次换电脑找不到，哈哈


#include<iostream>
#include<list>
using namespace std;

struct BinaryTreeNode
{
	int m_nValue;
	int m_nLeftMaxLength;  //存放的是左边最长叶子距离
	int m_nRigthMaxLength;
	BinaryTreeNode* m_pLeft;
	BinaryTreeNode* m_pRight;
};

//以前序和中序序列构建二叉树
BinaryTreeNode* ConstructBinaryTree(int preOrder[],int startPreOrder,int endPreOrder,int inOrder[],int startInOrder,int endInOrder)
{
	BinaryTreeNode* pRoot = new BinaryTreeNode();
	pRoot->m_nValue = preOrder[startPreOrder];
	pRoot->m_pRight = pRoot->m_pLeft = NULL;
	

	if(startPreOrder == endPreOrder)
	{
		if(startInOrder == endInOrder && preOrder[startPreOrder] == inOrder[startInOrder])
			return pRoot;
		else
			//cout<<"wrong"<<endl;
			throw std::exception("error!");
	}

	bool flag = false;
	for(int i = startInOrder; i <= endInOrder; ++i)
	{
		if(inOrder[i] == pRoot->m_nValue)
		{
			flag = true;
			break;
		}
	}

	if(flag)
	{
		int leftLength = i - startInOrder;

		if(leftLength > 0)
			pRoot->m_pLeft = ConstructBinaryTree(preOrder,startPreOrder+1,startPreOrder + leftLength,inOrder,startInOrder,startInOrder + leftLength-1);
		
		if(leftLength < endInOrder-startInOrder)
			pRoot->m_pRight = ConstructBinaryTree(preOrder,startPreOrder+leftLength+1,endPreOrder,inOrder,startInOrder+ leftLength+1,endInOrder );

		return pRoot;
	
	}
	else
		throw std::exception("error!");
		//return NULL;
	
}

BinaryTreeNode* ConstructBinaryTree(int preOrder[],int inOrder[],int length)
{
	if(preOrder == NULL || inOrder == NULL || length <= 0)
		return NULL;

	BinaryTreeNode *pRoot = ConstructBinaryTree(preOrder,0,length-1,inOrder,0,length-1);
	return pRoot;

}

//释放二叉树
void DestroyBinaryTree(BinaryTreeNode *pRoot)
{
	if(pRoot == NULL)
		return;

	DestroyBinaryTree(pRoot->m_pLeft);
	DestroyBinaryTree(pRoot->m_pRight);
	delete pRoot;
	pRoot = NULL;
}

//打印二叉树
void PrintLastOrder(BinaryTreeNode* root)
{
	if(root == NULL)
		return;
	if(root->m_pLeft)
		PrintLastOrder(root->m_pLeft);
	if(root->m_pRight)
		PrintLastOrder(root->m_pRight);
	cout<<root->m_nValue<<" ";
}

void PrintPreOrder(BinaryTreeNode* root)
{
	if(root == NULL)
		return;
	cout<<root->m_nValue<<" ";
	if(root->m_pLeft)
		PrintPreOrder(root->m_pLeft);
	if(root->m_pRight)
		PrintPreOrder(root->m_pRight);
	
}

void PrintInOrder(BinaryTreeNode* root)
{
	if(root == NULL)
		return;
	
	if(root->m_pLeft)
		PrintInOrder(root->m_pLeft);
	cout<<root->m_nValue<<" ";
	if(root->m_pRight)
		PrintInOrder(root->m_pRight);
	
}

//寻找二叉搜索树的两个结点的最近公共祖先
BinaryTreeNode* FindLastCommandFather_binaryResearchTree(BinaryTreeNode* pRoot, int n,int m)
{
	if(pRoot == NULL)
		return NULL;
	if(pRoot->m_nValue == n || pRoot->m_nValue == m)
		return pRoot;

	int min = n;
	int max = m;
	if(m < min)
	{
		min = m;
		max = n;
	}
	if(pRoot->m_nValue < min)
		return FindLastCommandFather_binaryResearchTree(pRoot->m_pRight,n,m);
	else if(pRoot->m_nValue > max)
		return FindLastCommandFather_binaryResearchTree(pRoot->m_pLeft,n,m);
	else
		return pRoot;

}

//寻找二叉树中两个结点间的最大差距。以边为单位衡量
int maxLength = 0;
int MaxPath(BinaryTreeNode* pRoot)
{
	if(pRoot == NULL)
		return 0;

	if(pRoot->m_pLeft == NULL)
		pRoot->m_nLeftMaxLength = 0;
	if(pRoot->m_pRight == NULL)
		pRoot->m_nRigthMaxLength = 0;

//	int tempLeft = 0; //左边根到叶子的最长路径长度

	//这里计算pRoot的左子树的最长路径长度
	if(pRoot->m_pLeft != NULL)
	{
		MaxPath(pRoot->m_pLeft);
		if(pRoot->m_pLeft->m_nLeftMaxLength > pRoot->m_pLeft->m_nRigthMaxLength)
			pRoot->m_nLeftMaxLength = pRoot->m_pLeft->m_nLeftMaxLength + 1;
		else
			pRoot->m_nLeftMaxLength = pRoot->m_pLeft->m_nRigthMaxLength + 1;

	}

//	int tempRight = 0;
	if(pRoot->m_pRight != NULL)
	{
		MaxPath(pRoot->m_pRight);
		if(pRoot->m_pRight->m_nLeftMaxLength > pRoot->m_pRight->m_nRigthMaxLength)
			pRoot->m_nRigthMaxLength = pRoot->m_pRight->m_nLeftMaxLength + 1;
		else
			pRoot->m_nRigthMaxLength = pRoot->m_pRight->m_nRigthMaxLength + 1;
	}

	if(maxLength < pRoot->m_nLeftMaxLength + pRoot->m_nRigthMaxLength )
		maxLength = pRoot->m_nLeftMaxLength + pRoot->m_nRigthMaxLength ;

	return maxLength;

}

//打印从根到叶子结点路径和为n的值
void FindPathofValueN(BinaryTreeNode *pRoot,unsigned int n,int curSum,list<int> &path)
{
	path.push_back(pRoot->m_nValue);
	curSum += pRoot->m_nValue;

	if(pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL)
	{
		if(curSum == n)
		{
			for(list<int>::iterator iter = path.begin();iter != path.end();iter++)
				cout<<*iter<<" ";
			cout<<endl;
			
		}
		path.pop_back();
	}
	if(pRoot->m_pLeft != NULL)
		FindPathofValueN(pRoot->m_pLeft,n,curSum,path);
	if(pRoot->m_pRight != NULL)
		FindPathofValueN(pRoot->m_pRight,n,curSum,path);

}
void FindPathofValueN(BinaryTreeNode *pRoot,unsigned int n)
{
	if(pRoot == NULL)
		return;
	list<int> path;
	int curSum = 0;
	FindPathofValueN(pRoot,n,curSum,path);
}

//树A是否树B的子树
bool IsEqualTree(BinaryTreeNode *pRoot1,BinaryTreeNode *pRoot2)
{
	if(pRoot1 == NULL && pRoot2 == NULL)
		return true;
	if(pRoot1 != NULL && pRoot2 != NULL && pRoot1->m_nValue == pRoot2->m_nValue)
	{
		return IsEqualTree(pRoot1->m_pLeft,pRoot2->m_pLeft) && IsEqualTree(pRoot1->m_pRight,pRoot2->m_pRight);
	}
	else
		return false;
}
bool IsSubTree(BinaryTreeNode *pRoot,BinaryTreeNode *pSubRoot)
{
	if(pRoot == NULL && pSubRoot == NULL)
		return true;
	if(pRoot == NULL && pSubRoot != NULL || pRoot != NULL && pSubRoot == NULL)
		return false;

	BinaryTreeNode *pNode = pRoot;

	bool flag = IsEqualTree(pNode,pSubRoot);

	if(pNode->m_pLeft != NULL && !flag)
	{
		flag = IsSubTree(pNode->m_pLeft,pSubRoot);
	//	pNode = pNode->m_pLeft;
	}

	if(pNode->m_pRight != NULL && !flag)
	{
		flag = IsSubTree(pNode->m_pRight,pSubRoot);
	//	pNode = pNode->m_pRight;
	}
	return flag;
}

//把二叉搜索树转换为双向链表
void ConvertBinarySearchTreeToDoubleList(BinaryTreeNode *pRoot,BinaryTreeNode **lastNode)
{
	if(pRoot->m_pLeft != NULL)
		ConvertBinarySearchTreeToDoubleList(pRoot->m_pLeft,lastNode);

	if( *lastNode != NULL)
		(*lastNode)->m_pRight = pRoot;

	pRoot->m_pLeft = (*lastNode);
	*lastNode = pRoot;

	if(pRoot->m_pRight != NULL)
		ConvertBinarySearchTreeToDoubleList(pRoot->m_pRight,lastNode);
}
BinaryTreeNode* ConvertBinarySearchTreeToDoubleList(BinaryTreeNode *pRoot)
{
	if(pRoot == NULL)
		return NULL;

	BinaryTreeNode *lastNode = NULL;
	ConvertBinarySearchTreeToDoubleList(pRoot,&lastNode);
	lastNode->m_pRight = NULL;
	BinaryTreeNode *pDoubleListHead = lastNode;
	while(pDoubleListHead->m_pLeft != NULL)
		pDoubleListHead = pDoubleListHead->m_pLeft;

	return pDoubleListHead;

}

//寻找二叉树中两个结点的值差值最大的绝对值
void Find(BinaryTreeNode *pRoot,int &min,int &max)
{

    int temp = pRoot->m_nValue;
    if(temp < min)
        min = temp;
    if(temp > max)
        max = temp;
    if(pRoot->m_pLeft != NULL)
    {
        Find(pRoot->m_pLeft,min,max);
    }

      if(pRoot->m_pRight != NULL)
    {
        Find(pRoot->m_pRight,min,max);
    }

}

int Find(BinaryTreeNode *pRoot)
{
     if (pRoot == NULL)
        return -1;

    int min = 32768;  //最大的整数
    int max = -32767;  //最小的整数
    Find(pRoot,min,max);
    return max - min;
}



void main()
{
	/*
	int pre[] = {10};
	int in[] = {10};
	int len = sizeof(pre)/sizeof(int);
	BinaryTreeNode* root = ConstructBinaryTree(pre,in,len);
	PrintPreOrder(root);
	cout<<endl;
	PrintInOrder(root);
	cout<<endl;
	PrintLastOrder(root);
	cout<<endl;

	BinaryTreeNode* node = FindLastCommandFather_binaryResearchTree(root,15,10);
	cout<<node->m_nValue<<endl;

	cout<<"max length of binary tree is: "<<MaxPath(root)<<endl;

	FindPathofValueN(root,14);
*/
	int pre1[] = {-1,9};
	int in1[] = {-1,9};
//	int pre2[] = {7};
//	int in2[] = {7};
	int len1 = sizeof(pre1)/sizeof(int);
//	int len2 = sizeof(pre2)/sizeof(int);
	BinaryTreeNode* root1 = ConstructBinaryTree(pre1,in1,len1);
	//BinaryTreeNode* root2 = ConstructBinaryTree(pre2,in2,len2);
	PrintPreOrder(root1);
	cout<<endl;
	PrintInOrder(root1);
	cout<<endl;
	PrintLastOrder(root1);
	cout<<endl;
    root1 = NULL;
	cout<<Find(root1)<<endl;
	DestroyBinaryTree(root1);
//	root1 = NULL;
//	root2 = NULL;
	/*
	if(IsSubTree(root1,root2))
		cout<<"Yes"<<endl;
	else
		cout<<"NO"<<endl;
		*/
/*
	BinaryTreeNode* p = ConvertBinarySearchTreeToDoubleList(root);
	while(p != NULL)
	{
		cout<<p->m_nValue<<" ";
		p = p->m_pRight;
	}
	cout<<endl;

*/

}


vinvcr
关注
1159 Structure of a Binary Tree – PAT甲级真题
柳婼 の blog
08-08 703
Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, a binary tree can be uniquely determined. Now given a sequence of statements about the structure of the resulting tree, you are
19年春季第四题 PAT甲级 1159 Structure of a Binary Tree（30分）
qiiingc的解题记录
02-24 1616
汇总贴 2020年3月PAT甲级满分必备刷题技巧 题目 Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, a binary tree can be uniquely determined....
关于算法面试中涉及Binary Tree的问题
lvhuayu的专栏
08-13 370
Binary Tree的定义这里就不用说啦，主要会涉及到下面几个问题: 1. 首先就是Binary Tree DFS Traver
常见算法题分类总结之二叉树(Binary-Tree)与经典问题
qq_57469718的博客
05-05 892
数据结构 二叉树 二叉搜索树 红黑树 算法 leetcode b树
剑指offer-第四章解决面试题的思路（二叉树的镜像）
denggu8595的博客
06-18 78
题目：请完成函数，输入一个二叉树，该函数输出它的镜像。 思路：可能没有听说过书的镜像，但是可以通过画图等来找灵感。就像照镜子一样，人的左边和右边交换了。 如图： 通过如下图变化就可以由左图得到右图： 总体来说：将所有的非叶子节点的左右子树交换。由于交换的过程惊人的一直，因此可以采用递归。 C++代码： #include<iostream> using...
算法竞赛基础训练题_选择题
国家一级致癌物
12-25 8059
算法竞赛基础训练题 选择题 For a sequentially stored linear list of length N, the time complexities for query and insertion are : 对于长度为N的顺序存储线性列表，查询和插入的时间复杂度为: B.O(1), O(N) If a linear list is represented by a linked list, the addresses of the elements in the memory :
PTA Advanced 1159 Structure of a Binary Tree C++
Trapped_beast的博客
02-09 409
1159 Structure of a Binary Tree
PAT甲级-Structure of a Binary Tree（中序+后序建树）
qq_51738428的博客
05-16 294
Question Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, a binary tree can be uniquely determined. Now given a sequence of statements about the structure of the resulting tree,
PAT 1159 Structure of a Binary Tree
weixin_45840763的博客
02-21 274
1159 Structure of a Binary Tree (30 分) Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, a binary tree can be uniquely determined. Now given a sequence of statements about the
玩转算法面试- Leetcode真题分门别类
10-24
玩转算法面试-- Leetcode真题分门别类 资源列表： 00-The-Opening 01-What-is-Algorithm-Interview ...07-Binary-Tree-and-Recursion 08-Recurion-and-Backstracking 09-Dynamic-Programming 10-Greedy-Algorithms
图像 异常检测算法_检测图像异常的算法
weixin_26750481的博客
08-27 5472
图像 异常检测算法Modern applications are generating enormous amounts of image data. And in the last years, researches began to apply some data mining algorithms to extract useful information from these images...
算法笔试题：（Python实现）------ 算法面试题汇总
热门推荐
Avery123123的博客
03-06 1万+
算法笔试题：（Python实现）------ 算法面试题汇总算法笔试题：（Python实现）------ 算法面试题汇总开始之前Python实现只出现一次的数字多数元素搜索二维矩阵 II合并两个有序数组鸡蛋掉落 算法笔试题：（Python实现）------ 算法面试题汇总 开始之前 Python实现 只出现一次的数字 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于...
CPPC++_低成本实现Wooting键盘的Rapid trigger功能不必为几个按键购买整个键盘人人都能做Wouo.zip
11-12
CPPC++_低成本实现Wooting键盘的Rapid trigger功能不必为几个按键购买整个键盘人人都能做Wouo
CPPC++_可能是世界上最快的协同程序库.zip
11-12
CPPC++_可能是世界上最快的协同程序库
ConsulHelper，.Net微服务基础框架，已支持.NetCore，具备服务发现、健康检查、服务分级、分布式配置.zip
11-12
ConsulHelper，.Net微服务基础框架，已支持.NetCore，具备服务发现、健康检查、服务分级、分布式配置、版本控制
各种三维模型（gltf，glb格式）
11-12
有卫星、警车、消防车、Cesium飞机、Cesium无人机等等。具体图片如下文章：https://blog.csdn.net/weixin_44857463/article/details/143721670?sharetype=blogdetail&sharerId=143721670&sharerefer=PC&sharesource=weixin_44857463&spm=1011.2480.3001.8118
yii2.0+admin后台以及rbac权限.zip
11-12
yii2.0+admin后台以及rbac权限
SpringBlade3.0架构核心工具包.zip
11-12
SpringBlade3.0架构核心工具包，SpringBlade是一个由商业级项目升级优化而来的SpringCloud分布
python各种项目代码.zip
最新发布
11-12
python各种项目代码
RFID防碰撞算法优化：结合ALOHA与BinaryTree
现有的RFID防碰撞算法主要包括两种主要类型：ALOHA算法和二进制树算法（Binary Tree Algorithm）。ALOHA算法分为纯ALOHA和时分ALOHA（TDMA）两种。纯ALOHA算法允许所有标签随机发送，但容易造成大量碰撞；而时分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值