给定BST先序遍历序列，不构造BST的情况下判断BST是否每个node都只有一个child

本文介绍了一种算法，用于判断给定的二叉搜索树（BST）的先序遍历序列中每个节点是否只有一个子节点。通过两种不同的实现方式，一种时间复杂度为O(n^2)，另一种优化后的实现达到了O(n)的时间复杂度。

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

// 给定BST先序遍历序列_判断BST是否每个node都只有一个child.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

bool isOnlyHaveOneChild(int A[], int len)
{
	for (int i = 0; i < len-1; i++)
	{
		if (A[i] < A[i+1])
		{
			for (int j = i+1; j < len; j++)
			{
				if (A[j] < A[i])
				{
					return false;
				}
			}
		}
		else
		{
			for (int k = i+1; k < len; k++)
			{
				if (A[k] > A[i])
				{
					return false;
				}
			}
		}
	}

	return true;
}


int _tmain(int argc, _TCHAR* argv[])
{

	int A1[] = {16,10,8,9,29,27,22};
	int A2[] = {10,19,17,14,15,16};

	bool a1 =  isOnlyHaveOneChild(A1, 7);
	bool a2 =  isOnlyHaveOneChild(A2, 6);

	printf("%d, %d\n", a1,a2);


	return 0;
}

上面的算法的时间复杂度为O(n^2), 原因是由左到右进行扫描，如果从右到左进行扫描，时间复杂度可以降为O(n)

bool isOnlyHaveOneChild2(int A[], int len)
{
	if (A == NULL || len == 0)
		return false;

	if (len == 1)
		return true;

	int MinNum;
	int MaxNum;

	MinNum = MaxNum = A[len-1];

	for (int idx = len-2; idx >=0; idx--)
	{
		if (A[idx] > MinNum && A[idx] < MaxNum)
			return false;

		if (A[idx] > MaxNum)
			MaxNum = A[idx];
		else if (A[idx] < MinNum)
			MinNum = A[idx];
	}
	return true;
}