一.树的概念及其相关

1.概念及特点

  • 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。
  • 特点：每个结点有零个或多个子结点；
    没有父结点的结点称为根结点；
    每一个非根结点有且只有一个父结点；

2. 相关定义：

  • 节点的度：一个节点含有的子树的个数称为该节点的度；
  • 叶子节点：度为0的节点称为叶节点；
  • 非叶子节点/分支节点：度不为0的节点；
  • 父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
  • 子节点：一个节点含有的子树的根节点称为该节点的子节点；
  • 树的度：一棵树中，最大的节点的度称为树的度；
  • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
  • 树的高度或深度：树中节点的最大层次；
  • 森林：由m（m>=0）棵互不相交的树的集合称为森林；

二.二叉树

1.二叉树的特点

  1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

2.特殊二叉树

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

3.二叉树的存储

  • 二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1.链式存储及其模拟实现

  • 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的结点地址 。
#include <vector>
#include <queue>
#include <stack>

template<class T>
struct BinaryTreeNode
{
    T _data;
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;

    BinaryTreeNode(const T& x)
        : _data(x)
        , _left(NULL)
        ,_right(NULL)
    {}
};


template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree(T *a, size_t n, const T& invalid)
    {
        size_t index = 0;
        _root = _CreateTree(a, n, invalid, index);
    }

    Node CopyTree(Node* root)
    {
        if (root == NULL)
            return NULL;
        Node* newRoot = new Node(root->_data);
        newRoot->_left = CopyTree(root->_left);
        newRoot->_right = CopyTree(root->_right);

        return newRoot;
    }

    BinaryTree(const BinaryTree<T>& t)
    {
        _root = CopyTree(t._root);
    }

    BinaryTree operator=(BinaryTree<T> t)
    {
        swap(_root, t._root);

        return *this;
    }

    ~BinaryTree()
    {
        Destory(_root);
        _root = NULL;
    }

    void Destory(Node* root)
    {
        if (root == NULL)
            return;
        Destory(root->_left);
        Destory(root->_right);
        delete root;
    }

    //前序遍历建树
    Node* _CreateTree(T* a, size_t n, const T& invalid, size_t& index)
    {
        Node* root = NULL;
        if (a[index] != invalid)
        {
            root = new Node(a[index]);
            root->_left = _CreateTree(a, n, invalid, ++index);
            root->_right = _CreateTree(a, n, invalid, ++index);
        }
        return root;
    }

    //前序遍历访问树

    void PrevOrder()
    {
        _PrevOrder(_root);
        cout << endl;
    }

    void _PrevOrder(Node* root)
    {
        if (root == NULL)
            return;

        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

    //中序遍历访问树

    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

    void _InOrder(Node* root)
    {
        if (root == NULL)
            return;
        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }

    void PostOrder()
    {
        _PostOrder(_root);
        cout << endl;
    }

    void _PostOrder(Node* root)
    {
        if (root == NULL)
            return;

        _PostOrder(root->_left);
        _PostOrder(root->_right);

        cout << root->_data << " ";

    }
//递归实现求二叉树的大小
    int Size()
    {
        size_t size = 0;
        Size(_root, size);
        return size;
    }


    void _Size(Node* root, size_t& size)
    {
        if (root == NULL)
            return;
        _Size(root->_left, size);
        ++size;
        _Size(root->_right,size);
    }
//求所有叶子节点的数量
    size_t LeafSize()
    {
        return _LeafSize(_root);
    }

    size_t _LeafSize(Node* root)
    {
        if (root == NULL)
            return 0;
        if (root->_left == NULL && root->_right == NULL)
            return 1;
        return _LeafSize(root->_left) + _LeafSize(root->_right);

    }
    //求树的高度
    size_t Height()
    {
        return _Height(_root);
    }

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

        size_t leftHeight = _Height(root->_left);
        size_t rightHeight = _Height(root->_right);

        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;

    }

    //获取第K层的节点数
    size_t GetKLevel(size_t k)
    {

        size_t Num = _GetKLevel(_root, k);
        cout << Num << endl;
        return Num;
    }

    size_t _GetKLevel(Node* root, size_t k)
    {
        if (root == NULL)
            return 0;
        if (k == 1)
            return 1;
        return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
    }

    //判断是不是完全二叉树
    bool IsCompleteTree()
    {
        queue<Node*> q;

        if (_root)
            q.push(_root);
        bool flag = true;

        while (!q.empty())
        {
            Node* front = q.front();
            q.pop();
            if (front->_left)
            {
                if (flag == false)
                    return flag;
                q.push(front->_left);
            }
            else
            {
                flag == false;
            }
            if (front->_right)
            {
                if (flag == false)
                    return flag;
                q.push(front->_right);
            }
            else
            {
                flag = false;
            }
        }
        return true;
    }
//查找指定的节点
    Node* Find(const T& x)
    {
        return _Find(_root, x);
    }

    Node* _Find(Node* root, const T& x)
    {
        if (root == NULL)
            return NULL;
        if (root->_data == x)
            return root;

        Node* cur = _Find(root->_left, x);
        if (cur)
            return cur;
        Node* tem = _Find(root->_right, x);
        if (tem)
            return tem;
    }

private:
    Node* _root;
};



void TestTree()
{
    int array[] = { 1, 2, 3, '#', '#', 4, 40, '#', '#', '#', 5, 6, '#', '#', '#' };
    BinaryTree<int> t(array, sizeof(array) / sizeof(int), '#');

    //t.PrevOrder();
    //t.PostOrder();
    t.GetKLevel(1);
}

2.顺序存储
一般用于完全二叉树的存储实现。下篇博客！

四.常见面试题

填坑中…