二叉树知识总结（三）

发现总结相比初学，真是痛苦好多。。。

二叉树的表示：

• 二叉链表示法
  • 　数据data    指针left_child　　指针right_child

  • typedef struct TriTNode 
    {
        int data;
        //左右孩子指针
        struct TriTNode *lchild, *rchild;
        struct TriTNode *parent;
    }TriTNode, *TriTree;

     

• 三叉链表示法
  • 　数据data   指针left_child　　指针right_child    指针parent

  • typedef struct TriTNode 
    {
       int data;
       struct TriTNode *lchild, *rchild;
       struct TriTNode *parent;
    }TriTNode, *TriTree;

     

• 双亲表示法
  • 　每个节点都由一个数据结构组成，每个节点顺序排放在数组中

  • //双亲链表
    #define MAX_TREE_SIZE 100
    typedef struct BPTNode
    {
        int data;    // 数据
        int parentPosition; //指向双亲的指针，数组下标
        char LRTag; //左右孩子标志域
    }BPTNode;
    
    typedef struct BPTree
    {
    //因为节点之间是分散的，需要把节点存储到数组中
        BPTNode nodes[100]; 
        int num_node;  //节点数目
    //根结点的位置，注意此域存储的是父亲节点在数组的下标
        int root; 
    }BPTree;

     

树的遍历的本质：

• • 　　递归

    XXX (NODE *root)
    {  
    if(root) 
       {
    　　　　XXX(root->lchild);
           XXX(root->rchild);
       }
    }

树的非递归遍历：

• 　　中序遍历
  • 　　当左子树为空或者左子树已经访问完毕以后，再访问根。访问完毕根以后，再访问右子树。
  •        先走到的后访问、后走到的先访问，显然是栈结构　　

• //找最左边的节点
  BiTNode* findLeft(BiTNode* root, stack<BiTNode*> &st)
  {
      //空节点，直接返回
      if (root == NULL)
      {
          return NULL;
      }
      //寻找最左边的节点
      while (root->lchild != NULL)
      {
          //如果有左子树,该节点入栈
          st.push(root);
          //节点后移, 移到左子树根节点位置
          root = root->lchild;
      }
      return root;
  }

  //遍历函数
  

  void myOrder(BiTNode* root)
  {
      stack<BiTNode*> st;
      if (root == NULL)
      {
          return;
      }
      // 找到最左侧节点
      BiTNode* pNode = findLeft(root, st);
  
      while (pNode)
      {
          //如果没有左子树，打印该节点值
          cout << pNode->data << " ";
          //判断节点有没有右子树
          if (pNode->rchild != NULL)
          {
              // 如果有右子树，寻找右子树最左侧节点
              pNode = findLeft(pNode->rchild, st);
          }
          else
          {
              //没有右子树，判断栈是否为空
              if (!st.empty())
              {
                  //栈不为空
                  //取出栈顶元素
                  pNode = st.top();
                  //删除栈顶元素
                  st.pop();
              }
              else
              {
                  // 栈为空，遍历结束直接返回
                  return;
              }
          }
      }
  }

   

• 验证二叉搜索树（LeetCode）引用自 http://www.cnblogs.com/grandyang/p/4606334.html

• /**
   * 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:
      void inorder(TreeNode *root, vector<int> &vals) {
          if (!root) return;
          inorder(root->left, vals);
          vals.push_back(root->val);
          inorder(root->right, vals);
      }
      bool isValidBST(TreeNode* root) {
          if(!root) return true;
          vector<int> vals;
          inorder(root, vals);
          for (int i = 0; i < vals.size() - 1; ++i) {
              if (vals[i] >= vals[i + 1]) return false;
          }
          return true;          
          
      }
  };