給定一個前序序列陣列構造一個二叉樹

思路：首先序列中要有給定的非法值，也就是二叉樹中對應的空節點；對於構造一個二叉樹可以使用遞迴的思想：先構造當前節點，再構造左子樹，再右子樹，直到遇到非法值時，將NULL返回，使得上一個節點的一端連結到NULL，圖示如下：

    /*  int arr[] = { 1,2,3,'#','#',4,'#','#',5,6 ,'#','#','#' };
    BinaryTree<int> tree1(arr, sizeof(arr) / sizeof(arr[0]), '#');*/

    BinaryTree(const T* arr, size_t sz, const T& invalid)
    {
        size_t index
 
 = 0;
        _root = _CreatTree(arr, sz, index, invalid);
    }

    Node* _CreatTree(const T* arr, size_t sz, size_t& index, const T& invalid)
    {
        Node* node = NULL;
        if (arr[index] != invalid)
        {
            node = new Node(arr[index]);
            node->_left = _CreatTree(arr, sz, ++index
 
, invalid);
            node->_right = _CreatTree(arr, sz, ++index, invalid);
        }
        return node;
    }

前、中、後序遍歷遞迴寫法：

前序遍歷：先遍歷根節點，再遍歷左子樹，再遍歷右子樹；所以最先輸出根節點；

中序遍歷：先遍歷根節點左子樹，再遍歷根節點，再遍歷右子樹；

後序遍歷：先遍歷左子樹，再右子樹，最後根節點。

//前序
    void PrevOrederR()
    {
        _PrevOrederR(_root);
        cout<<
 
endl;
    }

    void _PrevOrderR(Node* node)
    {
        if (node == NULL)
            return;

        cout << node->_data << " ";
        _PrevOrderR(node->_left);
        _PrevOrderR(node->_right);
    }

//中序
    void MidOrderR()
    {
        _MidOrderR(_root);
        cout<<endl;
    }

    void _MidOrderR(Node* node)
    {
        if (node == NULL)
            return;

        _MidOrder(node->_left);
        cout << node->_data << " ";
        _MidOrder(node->_right);
    }

//後序
    void BackOrderR()
    {
        _BackOrderR(_root);
        cout<<endl;
    }


    void _BackOrderR(Node* node)
    {
        if (node == NULL)
            return;

        _BackOrderR(node->_left);
        _BackOrderR(node->_right);
        cout << node->_data << " ";
    }

輸出結果：拿一開始構造的二叉樹為例

前、中、後序遍歷非遞迴寫法：

思路：將遞迴轉遞迴無非就是轉為迴圈或者使用棧來模擬遞迴的過程；前序和後序比較簡單，在後序遍歷時需要注意加判斷當前節點的右子樹是否已經遍歷過，只有當左右子樹都遍歷過後，才可輸出當前根節點。

    //遍歷非遞迴
    void PrevOrderNR()
    {
        stack<Node*> s;
        Node* cur = _root;
        while (cur || !s.empty())
        {
            while (cur != NULL)
            {
                s.push(cur);
                cout << cur->_data << " ";
                cur = cur->_left;
            }
            //到最左根節點，該回溯了
            if (!s.empty())
            {
                cur = s.top();
                s.pop();
                cur = cur->_right;
            }
        }
        cout << endl;
    }

    void MidOrderNR()
    {
        stack<Node*> s;
        Node* cur = _root;

        while (cur != NULL || !s.empty())
        {
            while (cur != NULL)
            {
                s.push(cur);
                cur = cur->_left;
            }

            //到最左節點
            if (!s.empty())
            {
                cur = s.top();
                cout << cur->_data << " ";
                s.pop();
                cur = cur->_right;
            }
        }
        cout << endl;
    }

    void BackOrderNR()
    {
        stack<Node*> s;
        Node* cur = _root;
        Node* prev = NULL;

        while (cur != NULL || !s.empty())
        {
            while (cur != NULL)
            {
                s.push(cur);
                cur = cur->_left;
            }

            Node* top = s.top();

            if (top->_right == NULL || top->_right == prev)
            {
                cout << top->_data << " ";
                s.pop();
            }
            else
            {   //說明此時右子樹還沒判斷，不可直接pop
                cur = top->_right;
            }
            prev = top;
        }
        cout << endl;
    }

輸出結果：

層序遍歷：

思路：利用佇列先進先出的特性完成

    void LevelOrder()
    {
        queue<Node*> q;
        Node* node = _root;
        if (node != NULL)
            q.push(node);

        while (!q.empty())
        {
            Node* cur = q.front();
            cout << cur->_data << " ";
            q.pop();
            if (cur->_left != NULL)
                q.push(cur -> _left);
            if (cur->_right != NULL)
                q.push(cur->_right);
        }
        cout << endl;
    }

//輸出結果：1 2 5 3 4 6

求節點數目：

思路一：利用子問題的思想：左子樹節點個數加右子樹節點個數加自己的一個，如果當前節點為NULL，則返回0；

    int SizeByChildQue()
    {
        return _SizeByChildQue(_root);
    }

    int _SizeByChildQue(Node* node)
    {
        if (node == NULL)
            return 0;
        return _SizeByChildQue(node->_left) + _SizeByChildQue(node->_right) + 1;
    }

思路二：利用遍歷的思想：給定一個引數，遍歷所有節點，只要不為NULL，節點個數加1

    int SizeByTrav()
    {
        size_t size = 0;
        _SizeByTrav(_root, size);
        return size;
    }

    void _SizeByTrav(Node* node, size_t& size)
    {
        if (node == NULL)
            return;

        size++;
        _SizeByTrav(node->_left, size);
        _SizeByTrav(node->_right,size);
    }

求葉子節點數目：如同求節點數目，只不過在統計數目時需要判斷是否左右都為NULL，所以也可分為兩種寫法：

思路一：子問題：左子樹葉子節點個數加右子樹葉子節點個數，同時還要注意如果只有一個節點。

    int LeafSizeByChildQue()
    {
        return _LeafSizeByChildQue(_root);
    }

    int _LeafSizeByChildQue(Node* node)
    {
        if (node == NULL)
            return 0;

        //進行判斷，只有當左右都為空時才算做一個葉子節點
        if (node->_left == NULL && node->_right == NULL)
        {
            return 1;
        }
        return _LeafSizeByChildQue(node->_left) + _LeafSizeByChildQue(node->_right);
    }

思路二：遍歷思想，只有噹噹前節點為葉子節點時，才對計數+1；切記size要傳引用，否則回到第一個棧幀時size仍為0！

    int LeafSizeByTrav()
    {
        size_t size = 0;
        _LeafSizeByTrav(_root, size);
        return size;
    }

    void _LeafSizeByTrav(Node* node, size_t& size)
    {
        if (node == NULL)
            return;

        if (node->_left == NULL && node->_right == NULL)
            size++;

        _LeafSizeByTrav(node->_left, size);
        _LeafSizeByTrav(node->_right, size);
    }

二叉樹的高度：

思路：需要注意的是，高度是最長的那條路；劃分為子問題為：該節點的高度等於左子樹和右子樹高度中大的那個再加上1。

    size_t Height()
    {
        return _Height(_root);
    }

    size_t _Height(Node* node)
    {
        if (node == NULL)
            return 0;

        size_t lHeight = _Height(node->_left);
        size_t rHeight = _Height(node->_right);
        //注意返回時要加上當前的高度1
        return lHeight > rHeight ? lHeight + 1 : rHeight + 1;
    }