算法学习28-树的算法补充

void.bug

于 2020-02-22 23:19:47 发布

阅读量133

点赞数

分类专栏：算法学习笔记

空数据

本文链接：https://blog.csdn.net/qq_45205390/article/details/104452812

版权

算法学习笔记专栏收录该内容

35 篇文章 1 订阅

订阅专栏

树的算法补充

文章目录

树的算法补充

判断一棵二叉树是否是平衡二叉树

算法实习

解法一

解题思路：

根据二叉树的定义，我们可以递归遍历二叉树的每一个节点来，求出每个节点的左右子树的高度，如果每个节点的左右子树的高度相差不超过1，按照定义，它就是一颗平衡二叉树。

代码实现

//求二叉树的高度
int treeDepth(BinaryTreeNode* root){
    if(root==NULL){
        return 0;
    }
    int nLeft=treeDepth(root->m_pLeft);
    int nRight=treeDepth(root->m_pRight);
    return nLeft>nRight?nLeft+1:nRight+1;
}

bool isBalanced(BinaryTreeNode* root){
    if(root==NULL)
        return true;//空树是平衡二叉树
    int left= treeDepth(root->m_pLeft);
    int right= treeDepth(root->m_pRight);
    int diff=left-right;
    if(diff>1||diff<-1)
        return false;
    return isBalanced(root->m_pLeft)&&isBalanced(root->m_pRight);
}

**优点：**只要求出给定二叉树的高度，就可以方便的判断出二叉树是平衡二叉树，思路简单，代码简洁。

**缺点：**由于每个节点都会被重复遍历多次，这造成时间效率不高。例如在上面的函数输入isBalanced()函数中输入如下二叉树：

我们首先判断根节点1是不是平衡的，此时我们需要调用treeDepth()函数求根节点左子树的高度，需要遍历节点4、5、7。接下来需要判断以节点2为根节点的子树是不是平衡树的时候，分别求以节点2为根节点的左子树的高度和右子树的高度，这时又遍历了节点4、5、7。

很显然，节点的重复遍历会造成性能的下降，下面将给出每个节点只遍历一次的解法。

解法二

解题思路：

采用后序遍历的方式遍历二叉树的每一个节点，在遍历到一个节点之前我们就已经遍历了它的左右字数。此时，记录每个节点为根节点的树的高度，就可以一边遍历一边判断每个节点是不是平衡的。

代码实现

bool IsBalanced(BinaryTreeNode* pRoot, int* depth){  
    if(pRoot== NULL){  
        *depth = 0;  
        return true;  
    }  

    int nLeftDepth,nRightDepth;  
    bool bLeft= IsBalanced(pRoot->m_pLeft, &nLeftDepth);  
    bool bRight = IsBalanced(pRoot->m_pRight, &nRightDepth);  

    if (bLeft && bRight){  
        int diff = nRightDepth-nLeftDepth;  
        if (diff<=1 && diff>=-1) //左右字树高度差绝对值不超过1  
        {  
            *depth = 1+(nLeftDepth > nRightDepth ? nLeftDepth : nRightDepth);  
            return true;  
        }  
    }   
    return false;  
}  

bool IsBalanced(BinaryTreeNode* pRoot)  
{  
    int depth = 0;  

    return IsBalanced(pRoot, &depth);  
}

判断一棵树是否是搜索二叉树、判断一棵树是否是完全二叉树

基础知识

1.完全二叉树的定义？

判断一棵树是否是完全二叉树，首先要知道什仫是完全二叉树？完全二叉树就是除最后一层外，每一层上的结点数均达到最大值；在最后一层上只缺少右边的若干结点。

若设二叉树的深度为h，除第 h 层外，其它各层 (1~h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

一棵二叉树至多只有最下面的两层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。

2.如何判断一棵树是完全二叉树？

在了解了完全二叉树的概念之后，相信读者应该都会判定一颗树是否是完全二叉树了，根据完全二叉树的定义，我们知道完全二叉树的前h-1是满二叉树，而最后一层又是从左到右没有间隔的，如果对这棵树进行层序遍历会发生什仫情况呢？详细介绍见下。在这里我提到两种判断完全二叉树的方法：

1).标记法

设置标记flag=false,如上图所示，从根结点开始层序遍历入队列，如果队列不为空，一直循环。遇到第一个没有左孩子或者右孩子的结点，设置标记位flag=true,如果继续入队列再次遇到存在孩子的结点一定不是完全二叉树。

	//设置标志位的方法
	bool IsCompleteBinaryTree1()
	{
		bool flag=false;
		queue<Node *>q;
		q.push(_root);
		Node *cur=q.front();
		while (cur)
		{
			//有右孩子无左孩子
			if(cur->_left == NULL && cur->_right != NULL)
				return false;
			//标志位为true并且当前结点存在孩子
			if(flag == true && (cur->_left || cur->_right))
				return false;
			//如果当前结点少一个孩子
			if(cur->_left == NULL || cur->_right == NULL)
				flag=true;
			if(cur->_left)
				q.push(cur->_left);
			if(cur->_right)
				q.push(cur->_right);
			q.pop();
			if(!q.empty())
				cur=q.front();
			else
				cur=NULL;
		}
		return true;
	}

2).剩余队列判空法

突然发现使用上述标记法要考虑的情况很多，不太方便，于是又提出了另一种方法，就是剩余队列判空法

这个方法同样的用到了队列这种辅助结构，那仫如何只通过队列这个结构来判断一棵树是否是完全二叉树呢？试想一下，如果我们把一棵树的所有结点，包括叶子结点的左右空孩子都通过层序遍历入队列会发生什仫情况？详细的分析见下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P6C4YXle-1582384755547)(E:\one\20170208172326251.png)]

代码实现

template<class T>
struct BinaryTreeNode
{
	T _data;
	BinaryTreeNode<T> *_left;
	BinaryTreeNode<T> *_right;
	BinaryTreeNode(const T& data)
		:_data(data)
		,_left(NULL)
		,_right(NULL)
	{}
};
template<class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		:_root(NULL)
	{}
	BinaryTree(const T*a,size_t size,const T& invalid)
	{
		size_t index=0;
		_root=_CreatTree(a,size,index,invalid);
	}
	//设置标志位的方法
	bool IsCompleteBinaryTree1()
	{
		bool flag=false;
		queue<Node *>q;
		q.push(_root);
		Node *cur=q.front();
		while (cur)
		{
			//有右孩子无左孩子
			if(cur->_left == NULL && cur->_right != NULL)
				return false;
			//标志位为true并且当前结点存在孩子
			if(flag == true && (cur->_left || cur->_right))
				return false;
			//如果当前结点少一个孩子
			if(cur->_left == NULL || cur->_right == NULL)
				flag=true;
			if(cur->_left)
				q.push(cur->_left);
			if(cur->_right)
				q.push(cur->_right);
			q.pop();
			if(!q.empty())
				cur=q.front();
			else
				cur=NULL;
		}
		return true;
	}
	//利用辅助队列的办法
	bool IsCompleteBinaryTree2()
	{
		queue<Node *>q;
		q.push(_root);
		Node *cur=q.front();
		//按照层序遍历的办法入队列直到遇到第一个NULL停止
		while (cur)
		{
			q.push(cur->_left);
			q.push(cur->_right);
			q.pop();
			cur=q.front();
		}
		//如果队列中全为NULL则是完全二叉树，否则不是
		while(!q.empty())
		{
			if(q.front())
				return false;
			q.pop();
		}
		return true;
	}
protected:
	Node* _CreatTree(const T*a,size_t size,size_t& index,const T& invalid)
	{
		assert(a);
		Node *root=NULL;
		if(index < size && a[index] != invalid)
		{
			root=new Node(a[index]);
			root->_left=_CreatTree(a,size,++index,invalid);
			root->_right=_CreatTree(a,size,++index,invalid);
		}
		return root;
	}
protected:
	Node *_root;
};
void testIsCompleteTree()
{
	//int array[]={0,1,3,'#','#','#',2,4,'#','#',5};    //false
	//int array[]={0,1,3,'#','#',4,'#','#',2,5,'#','#','#'}; //true
	//int array[]={0,1,3,'#','#',4,'#','#',2};  //true
	int array[]={0,1,3,'#','#','#',2};
	size_t size=sizeof(array)/sizeof(array[0]);
	BinaryTree<int> bt(array,size,'#');
	bool ret=bt.IsCompleteBinaryTree2();
	if(ret == true)
		cout<<"是完全二叉树"<<endl;
	else
		cout<<"不是完全二叉树"<<endl;
}

已知一棵完全二叉树，求其节点的个数要求：时间复杂度低于O(N)，N为这棵树的节点个数

算法思路

思路：因为满树的节点数2h−12^{h} - 12
h
−1

如果一个节点的右子树的最左节点到达完全二叉树的最后一层，则左子树为满树，节点个数等于左子树的节点数+递归求右子树的节点数+本节点，如果此节点的右子树的最左节点没有到完全二叉树的最后一层，则右子树为满树，节点个数等于右子树的节点数+递归求左子树的节点+本节点。

代码实现

#include <iostream>
#include <stack>

struct Node {
    int value;
    Node* left;
    Node* right;
    Node(int value):
        value(value), left(nullptr), right(nullptr) {}
};

void preOrderRecur(Node* head) {
    if (head == nullptr) {
        return;
    }
    std::cout << head->value << ",";
    preOrderRecur(head->left);
    preOrderRecur(head->right);
}

int getMostLevel(Node* node, int curlevel) {
    while (node != nullptr) {
        curlevel++;
        node = node->left;
    }
    return curlevel - 1;
}

int cbtNode(Node* node, int curlevel, int depth) {
    if (curlevel == depth) {
        return 1;
    }
    if (getMostLevel(node->right, curlevel + 1) == depth) {
        return (1 << (depth - curlevel)) + cbtNode(node->right, curlevel + 1, depth);
    } else {
        return (1 << (depth - curlevel - 1)) + cbtNode(node->left, curlevel + 1, depth);
    }

}
int cbtTotalNode(Node* head) {
    if (head == nullptr) {
        return 0;
    }
    return cbtNode(head, 1, getMostLevel(head, 1));
}

int main() {
    Node* head = new Node(1);
    head->left = new Node(2);
    head->right = new Node(3);
    head->left->left = new Node(4);
    head->left->right = new Node(5);
    head->right->left = new Node(6);

    std::cout << "==============recursive==============";
    std::cout << "\npre-order: ";
    preOrderRecur(head);
    std::cout << "\n";
    int cbt_total_nodes = cbtTotalNode(head);
    std::cout << cbt_total_nodes << std::endl;
    return 0;
}