二叉树总结_getnearestcommonfather-CSDN博客

本文链接：https://blog.csdn.net/LHW0621/article/details/38388473

<span style="font-family: Arial, Helvetica, sans-serif;">#include<iostream></span>

#include<queue>
#include<stack>
using namespace std;

struct BinaryTreeNode{
    char val;
    BinaryTreeNode* left;
    BinaryTreeNode* right;
    BinaryTreeNode(char num):val(num),left(NULL),right(NULL){}
};

void print(BinaryTreeNode* root){
    if(root == NULL)
        return;
    cout << root->val-'a' << "  ";//为了方便输入一个二叉树，使得一个字符串转化为二叉树，所以这里在打印时加了-‘a’
}

int NumOfKthLevel(BinaryTreeNode* root,int k){
	if(root == NULL || k <= 0)
		return 0;
	if(k == 1)
		return 1;

	return NumOfKthLevel(root->left,k-1)+NumOfKthLevel(root->right,k-1);
}

/*********二叉树的深度***********/
int DepthOfTree(BinaryTreeNode* root)
{
	if(root == NULL)
		return 0;
	return max(DepthOfTree(root->left),DepthOfTree(root->right))+1;
}

/************层序打印二叉树*****************/
void levelOrder(BinaryTreeNode* root){
    if(root == NULL)
        return;
    queue<BinaryTreeNode*> q;
    q.push(root);
    while(!q.empty()){
        BinaryTreeNode* curNode = q.front();
        print(curNode);
        //cout << curNode->val << "  ";
        q.pop();
        if(curNode->left != NULL)
            q.push(curNode->left);
        if(curNode->right != NULL)
            q.push(curNode->right);
    }
}
/************层序按层打印二叉树****************/
void levelOrderByLevel(BinaryTreeNode* root){
    if(root == NULL)
        return;
    queue<BinaryTreeNode*> q;
    BinaryTreeNode* dummy = new BinaryTreeNode('\0');
    q.push(root);
    q.push(dummy);
    while(!q.empty()){
        if(q.front() == dummy){
            q.pop();
            if(!q.empty())
                q.push(dummy);
            cout << endl;
            continue;
        }
        BinaryTreeNode* curNode = q.front();
        print(curNode);
        q.pop();
        if(curNode->left != NULL)
            q.push(curNode->left);
        if(curNode->right != NULL)
            q.push(curNode->right);
    }
}
/***********层序S形打印--一个栈一个队列的解法************/
void levelOrderByLevelInQueueAndStack(BinaryTreeNode* root){
    if(root == NULL)
        return;
    queue<BinaryTreeNode*> q;
    stack<BinaryTreeNode*> sta;
    BinaryTreeNode* dummy = new BinaryTreeNode('\0');
    q.push(root);
    q.push(dummy);
    bool flag = true;
    while(!q.empty()){
        if(q.front() == dummy){
            q.pop();
            if(!q.empty())
                q.push(dummy);
            while(flag == false && !sta.empty()){
                BinaryTreeNode* curNode = sta.top();
                print(curNode);
                sta.pop();
            }
            cout << endl;
            flag = !flag;
            continue;
        }
        BinaryTreeNode* curNode = q.front();
        if(flag == true)
            print(curNode);
        else
            sta.push(curNode);
        q.pop();
        if(curNode->left != NULL)
            q.push(curNode->left);
        if(curNode->right != NULL)
            q.push(curNode->right);
    }
}
/*********层序S形打印--两个栈的解法***********/
void levelOrderInS(BinaryTreeNode* root){
    if(root == NULL)
        return;
    stack<BinaryTreeNode*> sta1;
    stack<BinaryTreeNode*> sta2;
    sta1.push(root);
    while(!sta1.empty() || !sta2.empty()){
        while(!sta1.empty()){
            BinaryTreeNode* curNode = sta1.top();
            print(curNode);
            sta1.pop();
            if(curNode->left != NULL)
                sta2.push(curNode->left);
            if(curNode->right != NULL)
                sta2.push(curNode->right);
        }
        cout << endl;
        while(!sta2.empty()){
            BinaryTreeNode* curNode = sta2.top();
            print(curNode);
            sta2.pop();
            if(curNode->right != NULL)
                sta1.push(curNode->right);
            if(curNode->left != NULL)
                sta1.push(curNode->left);
        }
        cout << endl;
    }
}

/**********前序遍历**********/
void PreOrder(BinaryTreeNode* root){
	if(root == NULL)
		return;

	stack<BinaryTreeNode*> sta;
	BinaryTreeNode* p = root;
	while(p != NULL || !sta.empty())
	{
		while(p != NULL){
			sta.push(p);
			p = p->left;
			cout << p->val << " ";
		}
		if(!sta.empty()){
			p = sta.top();
			sta.pop();
			p = p->right;
		}
	}
}

/********中序遍历********/
void InOrder(BinaryTreeNode* root)
{
	if(root == NULL)
		return;

	stack<BinaryTreeNode*> sta;
	BinaryTreeNode* p = root;
	while(p != NULL || !sta.empty())
	{
		while(p != NULL){
			sta.push(p);
			p = p->left;
		}
		if(!sta.empty()){
			p = sta.top();
			cout << p->val << " ";
			sta.pop();
			p = p->right;
		}
	}
}

/**********后续遍历************/
void PostOrder(BinaryTreeNode* root){
	BinaryTreeNode *CurNode,*PreNode;
	stack<BinaryTreeNode*> sta;
	sta.push(root);
	while(!sta.empty()){
		CurNode = sta.top();
		if(CurNode->left == NULL && CurNode->right == NULL ||(PreNode != NULL && (PreNode == CurNode->left || PreNode == CurNode->right))){
			cout << CurNode->val << " ";
			PreNode = CurNode;
			sta.pop();
		}
		else{
			if(CurNode->left != NULL)
				sta.push(CurNode->left);
			if(CurNode->right != NULL)
				sta.push(CurNode->right);
		}
	}
}

/***********子结构问题************/
bool IsChildOfThisNode(BinaryTreeNode* root,BinaryTreeNode* child){
	if(child == NULL)
		return true;
	else if(root == NULL)
		return false;
	if(root->val != child->val)
		return false;
	return IsChildOfThisNode(root->left,child->left) && IsChildOfThisNode(root->right,child->right);
}

bool IsChildTree(BinaryTreeNode* root,BinaryTreeNode* child){
	if(child == NULL)
		return true;
	if(root == NULL)
		return false;
	if(IsChildOfThisNode(root,child))
		return true;
	return IsChildTree(root->left,child) || IsChildTree(root->right,child);
}

/***********镜像问题**********/
void Mirror(BinaryTreeNode* root){
	if(root == NULL)
		return;
	BinaryTreeNode* tmp = root->left;
	root->left = root->right;
	root->right = tmp;

	if(root->left != NULL)
		Mirror(root->left);
	if(root->right != NULL)
		Mirror(root->right);
}

/***********是否树的节点**************/
bool IsChildNode(BinaryTreeNode* root,BinaryTreeNode* node){
    if(node == NULL)
        return true;
    if(root == NULL)
        return false;

    if(root->val == node->val)
        return true;
    return IsChildNode(root->left,node) || IsChildNode(root->right,node);
}

/************最邻近公共祖先************/
BinaryTreeNode* getNearestCommonFather(BinaryTreeNode* root,BinaryTreeNode* pNode1,BinaryTreeNode* pNode2){
    BinaryTreeNode* CommonFather;
    if(!IsChildNode(root,pNode1) || !IsChildNode(root,pNode2))
        return CommonFather;
    if(IsChildNode(root->left,pNode1) && IsChildNode(root->left,pNode2))
        return getNearestCommonFather(root->left,pNode1,pNode2);
    else if(IsChildNode(root->right,pNode1) && IsChildNode(root->right,pNode2))
        return getNearestCommonFather(root->right,pNode1,pNode2);
    else return root;
}

/*********是否为平衡二叉树（AVL树）**********/
bool IsBalancedBinaryTree(BinaryTreeNode* root){
    if(root == NULL)
        return true;
    int Left = DepthOfTree(root->left);
    int Right = DepthOfTree(root->right);
    if(Left - Right < -1 || Left - Right > 1)
        return false;
    return IsBalancedBinaryTree(root->left) && IsBalancedBinaryTree(root->right);
}

/**********根节点到叶子节点的和等于target***********/
void dfs(vector<vector<int> > &Res,vector<int> vec,BinaryTreeNode* root,int target,int sum){
    if(root == NULL)
        return;
    if(root->left == NULL && root->right == NULL){
        if(sum+root->val-'a' == target){
            vec.push_back(root->val-'a');
            Res.push_back(vec);
        }
        return;
    }

    vec.push_back(root->val-'a');
    if(root->left != NULL)
        dfs(Res,vec,root->left,target,sum+root->val-'a');
    if(root->right != NULL)
        dfs(Res,vec,root->right,target,sum+root->val-'a');
    vec.pop_back();
}

vector<vector<int> > SumFromRootToLeaves(BinaryTreeNode* root,int target){
    vector<vector<int> > Res;
    vector<int> vec;
    dfs(Res,vec,root,target,0);
    return Res;
}

/**********是不是二叉搜索树的后序遍历***********/
bool IsPostOrder(int* input,int len,int start,int end){
    if(input == NULL || len <= 0)
        return false;
    int i = start;
    while(input[i] < input[end])
        i++;
    int tmp = i;
    while(input[i] > input[end])
        i++;
    if(i != end)
        return false;

    int left = true,right = true;
    if(tmp>start)
        left = IsPostOrder(input,tmp-start,start,tmp-1);
    if(end>tmp)
        right = IsPostOrder(input,end-tmp,tmp,end-1);
    return left && right;
}

/**********已知中序和后序求二叉树***********/
BinaryTreeNode* buildBinaryTreeByInOrderAndPostOrder(int* InOrder,int* PostOrder,int len){
    BinaryTreeNode* Node = NULL;
    if(InOrder == NULL || PostOrder == NULL)
        return Node;
    int rootNode = PostOrder[len-1],i;
    for(i = 0;InOrder[i] != rootNode;i++);
    Node = new BinaryTreeNode(rootNode);
    if(i > 0)
        Node->left = buildBinaryTreeByInOrderAndPostOrder(InOrder,PostOrder,i);
    if(i < len-1)
        Node->right = buildBinaryTreeByInOrderAndPostOrder(InOrder+i+1,PostOrder+i,len-i-1);
    return Node;
}

/**********判断一个二叉树是否对称*************/
bool IsSymmetry(BinaryTreeNode* left,BinaryTreeNode* right){
    if(left == NULL && right == NULL)
        return true;
    else if(left == NULL || right == NULL)
        return false;
    if(left->val != right->val)
        return false;
    return IsSymmetry(left->left,right->right) && IsSymmetry(left->right,right->left);
}

bool IsSymmetry(BinaryTreeNode* root){
    if(root == NULL)
        return false;
    return IsSymmetry(root->left,root->right);
}

BinaryTreeNode* MakeTree(string str){
    BinaryTreeNode* root;
    if(str.empty())
        return root;
    queue<BinaryTreeNode* > q;
    root = new BinaryTreeNode(str[0]);
    q.push(root);
    for(int i = 1,len = str.size();i < len;i++){
        BinaryTreeNode* curNode = q.front();
        BinaryTreeNode* pNewNode = NULL;
        if(str[i] != '#')
            pNewNode = new BinaryTreeNode(str[i]);
        if(i%2 == 1){
            curNode->left = pNewNode;
            if(pNewNode != NULL)
                q.push(pNewNode);
        }
        else {
            curNode->right = pNewNode;
            if(pNewNode != NULL)
                q.push(pNewNode);
            q.pop();
        }
    }
    return root;
}


void DeleteTree(BinaryTreeNode* root){
    if(root == NULL)
        return;
    queue<BinaryTreeNode*> q;
    q.push(root);
    while(!q.empty()){
        BinaryTreeNode* curNode = q.front();
        q.pop();
        if(curNode->left != NULL)
            q.push(curNode->left);
        if(curNode->right != NULL)
            q.push(curNode->right);
        delete curNode;
    }
}

int main(void){
    string str = "abcdefghijklmnopqrstuvwxyz";
    BinaryTreeNode* root = MakeTree(str);
    levelOrderByLevelInQueueAndStack(root);
    cout << endl;
    Mirror(root);
    levelOrderByLevel(root);
    vector<vector<int> > vec = SumFromRootToLeaves(root,26);
    for(int i = 0;i < vec.size();i++){
        for(int j = 0;j < vec[i].size();j++)
            cout << vec[i][j] << " ";
        cout << endl;
    }
    int depth = DepthOfTree(root);
    bool bal = IsBalancedBinaryTree(root);
    cout << "bal = " << bal << endl;
    DeleteTree(root);

    int arr[] = {2,3,4,6,2,8,5};
    int len = sizeof(arr)/sizeof(int);
    cout << "len = " << len << endl;
    bool postOrder = IsPostOrder(arr,len,0,len-1);
    cout << postOrder << endl;

    int InOrder[] = {2,4,2};
    int PostOrder[] = {2,2,4};
    BinaryTreeNode* tmp = buildBinaryTreeByInOrderAndPostOrder(InOrder,PostOrder,sizeof(PostOrder)/sizeof(int));
    levelOrderByLevel(tmp);

    int symmetry = IsSymmetry(tmp);
    cout << symmetry << endl;
    return 0;
}