重写数据结构--二叉树

二叉树

过了太久猛一遇到还真不知道写些什么好，只记得建树，三种遍历方式，插入结点删除结点好像就变得很麻烦，但是还是要啃一下。

先实现三种遍历方式，练一下手。

前序遍历：
很简单的递归的使用，没什么难的吧，直接上代码：

void frontTraversal (BinaryTreeNode* root) {
    if (root == NULL) {
        return;
    } else {
        cout << root->value << ' ';
        frontTraversal(root->pLeft);
        frontTraversal(root->pRight);
    }
}

中序遍历：

void InOrderTraversal (BinaryTreeNode* root) {
    if (root == NULL) {
        return;
    } else {
        InOrderTraversal(root->pLeft);
        cout << root->value << ' ';
        InOrderTraversal(root->pRight);
    }
}

后序遍历：

void PostOrderTraversal (BinaryTreeNode* root) {
    if (root == NULL) {
        return;
    } else {
        PostOrderTraversal(root->pLeft);
        PostOrderTraversal(root->pRight);
        cout << root->value << ' ';
    }
}

建树的话，根据前序遍历和中序遍历可以建树

理一下思路：
思想是递归，先创建一个根节点来存前序的第一个元素，然后找到中序中前序第一个元素的位置k，然后中序里 0 ~ k-1是左子树，k - 1到结束是右子树
那么我们就知道了相对于根节点的左子树和右子树的元素的个数，然后再在前序里面进行拆分：第0个元素为根节点，从第1(index为1)个元素开始的k个元素是左子树，剩下的是右子树，然后分别对左右子树进行创建。
终止条件：
可以定义一个cnt,参数表里传入它的引用，每次创建节点就加1，每次进入函数判断一下cnt是否等于前序数组的长度，如果等于，则退出；
不过网上盛传的版本是另外一种：
传入的参数是前序和中序数组的首地址，和从首地址开始的长度，当指针为空或者长度为0时终止。

BinaryTreeNode* buildByPreAndIn(int* pre_order, int* in_order, int num) {
    if (pre_order == NULL || in_order == NULL || num <= 0)  return NULL;

    BinaryTreeNode* root = new BinaryTreeNode;
    root->value = *pre_order;
    root->pLeft = root->pRight = NULL;

    int rootPositionInOrder = -1;
    for (int i = 0; i < num; i++) {
        if (in_order[i] == root->value) {
            rootPositionInOrder = i;
            break;
        }
    }

    int num_Left  = rootPositionInOrder;
    int num_Right = num - num_Left - 1;

    int* pre_order_left  = pre_order + 1;
    int* in_order_left   = in_order;
    root->pLeft          = buildByPreAndIn(pre_order_left, in_order_left, num_Left);

    int* pre_order_right = pre_order + num_Left + 1;
    int* in_order_right  = in_order + num_Left + 1;
    root->pRight         = buildByPreAndIn(pre_order_right, in_order_right, num_Right);

    return root;
}

如果知道后序和中序，思路是一样的,直接贴代码：

BinaryTreeNode* buildByPostAndIn(int* post_order, int* in_order, int num) {
    if (post_order == NULL || in_order == NULL || num <= 0) return NULL;

    BinaryTreeNode* root = new BinaryTreeNode;
    root->value = post_order[num - 1];
    root->pLeft = root->pRight = NULL;

    int rootPositionInOrder = -1;
    for (int i = 0; i < num; i++) {
        if (in_order[i] == root->value) {
            rootPositionInOrder = i;
            break;
        }
    }

    int num_Left  = rootPositionInOrder;
    int num_Right = num - num_Left - 1;

    int* post_order_left = post_order;
    int* in_order_left   = in_order;
    root->pLeft          = buildByPostAndIn(post_order_left, in_order_left, num_Left);

    int* post_order_right = post_order + num_Left;
    int* in_order_right   = in_order + num_Left + 1;
    root->pRight          = buildByPostAndIn(post_order_right, in_order_right, num_Right);  

    return root;
}

求二叉树节点的个数：
递归就好

int getNumOfElements(BinaryTreeNode* root) {
    if (root == NULL) {
        return 0;
    } else {
        return getNumOfElements(root->pLeft) +
               getNumOfElements(root->pRight) + 1;
    }
}

求二叉树的深度：

int getDepth(BinaryTreeNode* root) {
    if (root == NULL) {
        return 0;
    } else {
        return max(getDepth(root->pLeft), getDepth(pRight)) + 1;
    }
}

求叶子节点的个数：
我自己想的是找出所有的节点的个数，然后再找出所有非叶子节点的个数然后减一下，但是看了网上的版本，这个显然更好：

int getNumOfLeaf(BinaryTreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    if (root->pLeft == root->pRight == NULL) {
        return 1;
    }
    return getNumOfLeaf(root->pLeft) + getNumOfLeaf(root->pRight);
}

基础的大概就是这些。

推荐一篇博文讲到的更详细：
http://blog.csdn.net/luckyxiaoqiang/article/details/7518888/#topic7