[数据结构]二叉树

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<queue>
using namespace std;
struct TreeNode;
typedef struct TreeNode *BinTree;
typedef int ElementType;
struct TreeNode{
	ElementType Data;
	BinTree Left;
	BinTree Right;
};
//二叉树的创建 
TreeNode* CreatBinTree(){
	TreeNode* PNode;
	int ch;
	cin>>ch;
	if(ch==0){
		PNode=NULL;//0表示子树为空。令指针指向NULL 
	}
	else{
		PNode=(BinTree)malloc(sizeof(struct TreeNode));
		PNode->Data=ch;
		PNode->Left=CreatBinTree();//递归创建左子树 
		PNode->Right=CreatBinTree();//递归创建右子树 
	}
	return PNode;
}
//先序遍历
void PreOrderTraversal(BinTree root){
    if(root){
        cout<<root->Data<<' ';
        PreOrderTraversal(root->Left);
        PreOrderTraversal(root->Right);
    }
}
//中序遍历
void InOrderTraversal(BinTree root){
    if(root){
        InOrderTraversal(root->Left);
        cout<<root->Data<<' ';
        InOrderTraversal(root->Right);
    }
}
//后序遍历
void PostOrderTraversal(BinTree root){
    if(root){
        PostOrderTraversal(root->Left);
        PostOrderTraversal(root->Right);
        cout<<root->Data<<' ';
    }
}
//层序遍历
void LevelOrderTraversal(BinTree root){
    queue<BinTree>Q;
    if(root)
        Q.push(root);//根节点入队
    while(!Q.empty()){
        root=Q.front();//节点出队
        Q.pop();
        cout<<root->Data<<' ';//访问当前节点
        if(root->Left)
            Q.push(root->Left);//左子树进队
        if(root->Right)
            Q.push(root->Right);//右子树进队
    }
}
//计算二叉树叶子结点数目 
int GetLeaf(TreeNode* root){
	if(!root)
		return 0;
	else if(!root->Left&&!root->Right)
		return 1;//表示该结点为叶子结点，返回1 
	else
		return (GetLeaf(root->Left)+GetLeaf(root->Right));//叶子结点总数等于每一棵左子树和右子树的叶子结点之和 
}
//计算二叉树的高度 
//max{左子树高度，右子树高度} 
int GetHeight(TreeNode* root){
	if(root)
		return (GetHeight(root->Left)>GetHeight(root->Right)?GetHeight(root->Left)+1:GetHeight(root->Right)+1);
	else
	return 0;
} 
//计算二叉树结点总数
//结点总数=左子树结点数+右子树结点数+根节点 
int GetNodenum(TreeNode* root){
	if(!root)
		return 0;
	else{
		return GetNodenum(root->Left)+GetNodenum(root->Right)+1;
	}
} 
int main(){
	TreeNode* p=NULL;
	p=CreatBinTree();
	cout<<"先序遍历的结果为：";
	PreOrderTraversal(p);
	cout<<endl;
	cout<<"中序遍历的结果为："; 
	InOrderTraversal(p);
	cout<<endl;
	cout<<"后序遍历的结果为："; 
	PostOrderTraversal(p);
	cout<<endl;
	cout<<"层序遍历的结果为：";
	LevelOrderTraversal(p);
	cout<<endl;
	cout<<"二叉树叶子结点数为："<<GetLeaf(p)<<endl; 
	cout<<"二叉树的高度为："<<GetHeight(p)<<endl; 
	cout<<"二叉树的结点总数为："<<GetNodenum(p)<<endl;
	return 0;
}

输出二叉树的叶子结点

void PreOrderTraversal(BinTree root){
    if(root){
        if(!root->Left&&!root->Right)//如果该结点左右子树为空
            cout<<root->Data;//那么输出的结点就是叶子结点
        PreOrderTraversal(root->Left);
        PreOrderTraversal(root->Right);
    }
}

求二叉树的高度

//height=max(左子树高度，右子树高度）+1
void PostOrderTraversal(BinTree root){
    int HeightLeft,HieghtRight,MaxHeight;
    if(!root)
        return 0;
    else{
        HeightLeft=PostOrderTraversal(root->Left);//求左子树高度
        HeightRight=PostOrderTraversal(root->Right);//求右子树高度
        MaxHeight=(HeightLeft>HieghtRight)?HeightLeft:HieghtRight;
        return (MaxHeight+1);
    }
}

合并二叉树：给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
typedef struct TreeNode* PtrToNode;
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(t1==nullptr)
            return t2;
        if(t2==nullptr)
            return t1;
        PtrToNode ans=new TreeNode(t1->val+t2->val);
        ans->left=mergeTrees(t1->left,t2->left);
        ans->right=mergeTrees(t1->right,t2->right);
        return ans;
    }
};

从上到下打印二叉树：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>res;
        queue<TreeNode*>Q;
        if(root)
            Q.push(root);
        while(!Q.empty()){
            int j=Q.size();//记录这一层中的节点数量
            vector<int>level;
            for(int i=0;i<j;i++){
                root=Q.front();
                Q.pop();
                level.push_back(root->val);
                if(root->left)
                    Q.push(root->left);
                if(root->right)
                    Q.push(root->right);
            }
            res.push_back(level);
        }
        return res;
    }
};