普通二叉树的函数复习

数据结构二叉树的复习汇总

（一）概念

• leaf: 度为0
• internal node: 度为1或2
• full binary tree: 不存在度为1的结点
• complete tree：从左到右依次填满的树
  除了最后一层，其余层全为满；
• height: height= depth+1
• depth: 结点M的深度就是从根节点到M的路径长度
• level: 从根节点开始是第0层
  高度、深度、层数示例：
  

（二）二叉树的性质

• n0=n2+1 [ 对于任意二叉树：度为1的结点数 = 度为2的结点数+1 ]
• 非空 满二叉树 的叶节点数目等于其分支节点数+1

（三）二叉树的遍历

在所有代码之前：声明类和结构体！

template <class E>struct BTNode{
E data;
BTNode<E> *left;
BTNode<E> *right;
};

template <typename E>
class BiTree{
private:
//创建二叉树
void Create(BTNode<E>* root, E data[], int i, int n); //在这里BTNode<E> &R的意思和*root其实是一个意思

//释放二叉树
void Release(BTNode<E> *root);

public:
BTNode<E> *root; //根节点
BiTree(E data[], int n); //构造函数 constructor
void PreOrder(Binode<T>*Root);           //前序遍历
void InOrder(Binode<T>*Root);            //中序遍历
void PostOrder(Binode<T>*Root);         //后序遍历
void LevelOrder(Binode<T>*Root);        //层序遍历
bool Path(Binode<T>*R, T e);         //指定结点到根节点的路径
int Count(Binode<T>*R);             //结点总数
int Depth(Binode<T>*R);               //树的深度
~BiTree();            //析构函数
}

1. preorder：先遍历该结点，在访问左子树，再遍历右子树

template <typename E>
void preorder(BTNode<E>* root){
	if (root==NULL){return;}
	visit(root);  //自己写一个结点值打印函数
    //eg: cout<< root->data;
    preorder(root->left);
    preorder(root->right);
}

2. inorder 中序遍历： 先遍历左子树，再遍历根节点，再遍历右子树

template <typename E>
void inorder (BTNode<E> *root){
if (root==NULL){return;}

inorder(root->left);
visit(root); //cout<<root->data 
inorder(root->right);
}

3. postorder 后序遍历： 先访问左子树，再访问右子树，再访问根结点
   –> 可根据该性质找到根节点：即最后一个是根节点

template <typename E>
void postorder(BTNode<E> *root){
if(root=NULL){return;}
postorder(root->left);
postorder(root->right);
visit(root);//cout<<root->data;
}

4. 计算一个二叉树中的所有结点数目

template <typename E>
int NodeCount(BTNode<E> *root){
if(root==NULL){return 0;}
return 1 + NodeCount(root->left) + NodeCount(root->right);
}

5. 计算二叉树中叶子结点的数目

template <typename E>
int countLeaf(BTNode<E> *root){
if(root==NULL) return 0;
if(root -> lc == NULL && root->rc == NULL){  return 1;} //如果该点的度为0，则返回1
return countLeaf(root->left)+countLeaf(root->right);
}

6. 计算二叉树中非叶子结点的数目

template <typename E>
int countNonLeaf(BTNode<E> *root){}
 if (root == NULL || ((root->lc==NULL)&&(root->rc==NULL))) { return 0; }//如果该节点是叶节点或为空，return 0
    return 1+countNonLeaf(root->lc) + countNonLeaf(root->rc);

7. 计算二叉树的高度

int countHeight(BTNode<E>* root){
int RightHeight=1;
int LeftHeight=1;

if(root==NULL){return 0;}
else{
RightHeight=countHeight(root->right)+1;
LeftHeight-countHeight(root->left)+1;
}

if(left<right){return RightHeight;}
else{return LeftHeight;}

}

8.打印各节点的值及所在层次

template <typename E>
void printBTNode(BTNode<E>* root, int level)
{
    if (root == NULL) { return; }
    printBTNode(root->rc, level + 1);
    for (int i = 0; i < level; i++) {
        cout << " ";
    }
    cout << root->data << "\n";
    printBTNode(root->lc, level + 1);
}

9. 查找二叉树中K的值

template <typename E,typename Key>//两个模板
bool searchK(BTNode<E>* root,Key k){
if(root==NULL){return false;}
if(root->data==k){return true;}
return searchK(root->left) || searchK(root->right);
}

10. 交换二叉树中每个结点的左子女和右子女

template <typename E>     //先序 
void swap(BTNode<E>* root)
{
    BTNode<E>* tmp;
    if (root == NULL) { return; }
    if ((root->lc == NULL && root->rc == NULL))
    {
        return;
    }
    else {
        tmp = root->lc;
        root->lc = root->rc;
        root->rc = tmp;
    }
    swap(root->lc);
    swap(root->rc);