二叉树构建与遍历

1. 通过输入的数据构建二叉树，并利用前序遍历输出二叉树

   #include <iostream>
   #include <unordered_map>
   #include <vector>
   #include <string>
   using namespace std;
   
   struct TreeNode
   {
       char val;
       TreeNode* left;
       TreeNode* right;
       TreeNode(char val): val(val), left(left), right(right){};
   };
   
   TreeNode* buildTree(unordered_map<char, pair<char, char>>& codemap, char rootValue){
       if(rootValue == '0') return nullptr;
   
       TreeNode* root = new TreeNode(rootValue);
       char leftChild = codemap[rootValue].first;
       char rightChild = codemap[rootValue].second;
   
   
       root->left = buildTree(codemap, leftChild);
       root->right = buildTree(codemap, rightChild);
   
       return root;
   }
   
   // 前序遍历
   void preTraversal(TreeNode* root, string &res){
       if(root == nullptr)  return;
       res += root->val;
       cout << root->val;
       preTraversal(root->left, res);
       preTraversal(root->right, res);
   }
   
   
   int main(){
       unordered_map<char, pair<char, char>> codemap;
       int m;
       cin >> m;
       vector<char> index(m + 1, '0');
       vector<vector<int>> codeValue(m + 1, vector<int>(2, 0));
       for(int i = 1; i <= m; i++){
           cin >> index[i] >> codeValue[i][0] >> codeValue[i][1];
       }
   
       for (int i = 1; i <= m; i++)
       {
           codemap[index[i]] = make_pair(index[codeValue[i][0]], index[codeValue[i][1]]);
   
       }
       
   
       TreeNode* root = buildTree(codemap, index[1]);
       string res;
   
       preTraversal(root, res);
       // if(res.size() == 0){
       //     cout << "kong" ;
       // }
       // for(char ch: res){
       //     cout << ch;
       // }
       return 0;
   
   }
   

   2. 通过前序，中序构建二叉树，并以后序遍历输出二叉树

   #include<iostream>
   #include<string>
   #include<vector>
   #include<map>
   
   using namespace std;
   
   struct TreeNode{
       char val;
       TreeNode* left;
       TreeNode* right;
       TreeNode(char val): val(val), left(nullptr), right(nullptr){};
       
   };
   
   // int findChar(map<int, char>mp, char ch){
   //     for(map<int, char>::iterator it = mp.begin(); it != mp.end(); it++){
   //         if (it->second == ch) return it->first; 
   //     }
   //     return -1;
   // }
   
   TreeNode* buildBinaryTree(map<char, int>mp, string preorder, int preorderLeft, int preordeRight, string inorder, int inorderLeft, int inorderRight){
       if(preorderLeft == preordeRight) return NULL;
   
       char rootValue = preorder[preorderLeft];
    
       TreeNode* root = new TreeNode(rootValue);
   
      // if(preordeRight - preorderLeft == 1) return root; 这句代码会直接跳过右子树的东西，为什么呢？
   
       int delimiterIndex = mp[rootValue];
   
       //处理中序遍历两数组
       //左子树
       int inleftTreeBegin = inorderLeft;
       int inleftTreeEnd = delimiterIndex;
   
       //中序遍历右子树
       int inRightTreeBegin = delimiterIndex + 1;
       int inRightTreeEnd = inorderRight;
   
       //处理前序遍历左子树
       int preLeftTreeBegin = preorderLeft + 1;
       int preLeftTreeEnd = preLeftTreeBegin + delimiterIndex - inleftTreeBegin;
   
       //处理前序遍历右子树
       int preRightTreeBegin = preLeftTreeBegin + delimiterIndex - inleftTreeBegin;
       int preRightTreeEnd = preordeRight;
   
       root->left = buildBinaryTree(mp, preorder, preLeftTreeBegin, preLeftTreeEnd, inorder, inleftTreeBegin, inleftTreeEnd);
       root->right = buildBinaryTree(mp, preorder, preRightTreeBegin, preRightTreeEnd, inorder, inRightTreeBegin, inRightTreeEnd);
   
       return root;
   
   }
   
   void postTraversal(TreeNode* root){
       if(root == nullptr) return;
       
       postTraversal(root->left);
       postTraversal(root->right);
       cout << root->val; 
   }
   
   
   
   int main(){
       string preInput1;
       string inorderInput1;
   
       string preInput2;
       string inorderInput2;
   
       cin >> preInput1 >> inorderInput1 >> preInput2 >> inorderInput2;
   
       int size1 = preInput1.size();
       int size2 = preInput2.size();
   
       map<char, int>mp1;
   
       for(int i = 0; i < size1; i++){
           mp1[inorderInput1[i]] = i;
       }
   
       map<char, int> mp2;
   
       for(int i = 0; i < size2; i++){
           mp2[inorderInput2[i]] = i;
       }
   
       TreeNode* root1 = buildBinaryTree(mp1, preInput1, 0, size1, inorderInput1, 0, size1);
       TreeNode* root2 = buildBinaryTree(mp2, preInput2, 0, size2, inorderInput2, 0, size2);
   
       postTraversal(root1);
       cout << endl;
       postTraversal(root2);
   
       return 0;
   
   }