二叉搜索树的后序遍历序列

最新推荐文章于 2022-01-02 09:37:43 发布

reading_code_man

最新推荐文章于 2022-01-02 09:37:43 发布

阅读量367

点赞数 1

CC 4.0 BY-SA版权

分类专栏：剑指offer

本文链接：https://blog.youkuaiyun.com/u013243314/article/details/80290309

剑指offer 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一个算法，用于验证一个整数数组是否为某个二叉搜索树的后序遍历结果。通过递归地检查左子树和右子树的所有节点值与根节点的关系来实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

#include <iostream>
#include <vector>
#include <string.h>
#include <stdlib.h>
#include <algorithm> 
#include <stack>
#include <queue>

using namespace std;

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

	}

};

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence);
    TreeNode* CreateTree();
    void PreOrderTree(TreeNode* root);
};

void PrintVector(vector<int> vec){
	
	if (vec.empty())
		return;
	
	vector<int>::iterator it = vec.begin();
	
	for(; it != vec.end(); it++){
		cout << *it << " ";
	}
	
	cout << endl;
}

int VecMax(vector<int> vec){
	if (vec.empty())
		return -1;
	
	vector<int>::iterator it = vec.begin();
	int max = *it;
	
	for(; it != vec.end(); it++){
		if (max < *it){
			max = *it;
		}
	}
	cout << "max : " << max << endl;
	return max;
}

int VecMin(vector<int> vec){
	if (vec.empty())
		return -1;
	
	vector<int>::iterator it = vec.begin();
	int min = *it;
	
	for(; it != vec.end(); it++){
		if (min > *it){
			min = *it;
		}
	}
	cout << "min : " << min << endl;
	return min;
}

bool Solution::VerifySquenceOfBST(vector<int> sequence){
	bool result;
	
	if (sequence.empty())
		return false;
	
	if (sequence.size() == 1)
		return true;
		
	vector<int>::iterator begin = sequence.begin();
	vector<int>::reverse_iterator rbegin = sequence.rbegin();
	vector<int> lhs, rhs;
	
	cout << "root rbegin = " << *rbegin << endl;
	
    while(begin != sequence.end() && *begin < *rbegin)
    	begin++;
    
    lhs.assign(sequence.begin(), begin);
    cout << "lhs : " << endl;
    PrintVector(lhs);

    rhs.assign(begin, sequence.end()-1);
    cout << "rhs : " << endl;
    PrintVector(rhs);
    
    
    if (( lhs.empty() || VecMax(lhs) < *rbegin) && (rhs.empty() || VecMin(rhs) > *rbegin)){
		result = true;
	} else {
		result = false;
	}
    
    if (result == true && !lhs.empty()) {
    	result = VerifySquenceOfBST(lhs);
	}
	
	if (result == true && !rhs.empty()) {
    	result = VerifySquenceOfBST(rhs);
	}
	
	return result;
}


TreeNode* Solution::CreateTree(){
	int idata;
	TreeNode* root;
	
	cin >> idata;
	if (idata == 0)
		return NULL;
	
	root = new TreeNode();
	root->val = idata;
	root->left = CreateTree();
	root->right = CreateTree();
	
	return root;
}

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

int main(void)
{	
	Solution* sl = new Solution();
	TreeNode* root;
	
	//int data[] = {5,7,6,9,11,10,8};
	int data[] = {4,6,7,5};
	vector<int> vec(data, data+4);
    bool ret = sl->VerifySquenceOfBST(vec);
	
	cout << "ret = " << ret << endl;
	
	return 0;
}