树的基本操作的非递归实现

2024年5月8日 245次阅读

树结点

 
 
    
  
  
  1. struct TreeNode { 
    2. 
  
  
  2.  
    3. 
  
  
  3.         int val; 
    4. 
  
  
  4.         struct TreeNode *left; 
    5. 
  
  
  5.         struct TreeNode *right; 
    6. 
  
  
  6.         TreeNode(int x):val(x),left(NULL),right(NULL){} 
    7. 
  
  
  7. }; 
    8. 
  
  
  8. typedef struct TreeNode TreeNode; 
    9.

访问函数  

 
 
    
  
  
  1. void visit(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         if(root) 
    4. 
  
  
  4.                 cout <<root->val<<" "; 
    5. 
  
  
  5. } 
    6.

    前序递归



 
 
    
  
  
  1. void preorder(TreeNode *root)
    2. 
  
  
  2. { 
    3. 
  
  
  3.         if(root) 
    4. 
  
  
  4.         { 
    5. 
  
  
  5.                 visit(root); 
    6. 
  
  
  6.                 preorder(root->left); 
    7. 
  
  
  7.                 preorder(root->right); 
    8. 
  
  
  8.         } 
    9. 
  
  
  9. } 
    10. 
 
 

 
  前序非递归 
  
 
 
 
 
    
  
  
  1. void preorder1(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         stack<TreeNode*> s; 
    4. 
  
  
  4.         while(root || !s.empty()) 
    5. 
  
  
  5.         { 
    6. 
  
  
  6.                 if(root) 
    7. 
  
  
  7.                 { 
    8. 
  
  
  8.                         visit(root); 
    9. 
  
  
  9.                         s.push(root->right); 
    10. 
  
  
  10.                         root = root->left; 
    11. 
  
  
  11.                 } 
    12. 
  
  
  12.                 else 
    13. 
  
  
  13.                 { 
    14. 
  
  
  14.                         root = s.top(); 
    15. 
  
  
  15.                         s.pop(); 
    16. 
  
  
  16.                 } 
    17. 
  
  
  17.         } 
    18. 
  
  
  18. } 
    19.

  中序递归  

 
 
    
  
  
  1. void inorder(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         if(root) 
    4. 
  
  
  4.         { 
    5. 
  
  
  5.                 inorder(root->left); 
    6. 
  
  
  6.                 visit(root); 
    7. 
  
  
  7.                 inorder(root->right); 
    8. 
  
  
  8.         } 
    9. 
  
  
  9. } 
    10.

中序非递归  

 
 
    
  
  
  1. void inorder1(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         stack<TreeNode*> s; 
    4. 
  
  
  4.         while(root || !s.empty()) 
    5. 
  
  
  5.         { 
    6. 
  
  
  6.                 if(root) 
    7. 
  
  
  7.                 { 
    8. 
  
  
  8.                         s.push(root); 
    9. 
  
  
  9.                         root = root->left; 
    10. 
  
  
  10.                 } 
    11. 
  
  
  11.                 else 
    12. 
  
  
  12.                 { 
    13. 
  
  
  13.                         root = s.top(); 
    14. 
  
  
  14.                         s.pop(); 
    15. 
  
  
  15.                         visit(root); 
    16. 
  
  
  16.                         root = root->right; 
    17. 
  
  
  17.                 } 
    18. 
  
  
  18.         } 
    19. 
  
  
  19. } 
    20.

    后序递归  

 
 
    
  
  
  1. void postorder(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         if(root) 
    4. 
  
  
  4.         { 
    5. 
  
  
  5.                 postorder(root->left); 
    6. 
  
  
  6.                 postorder(root->right); 
    7. 
  
  
  7.                 visit(root); 
    8. 
  
  
  8.         } 
    9. 
  
  
  9. } 
    10.

后序非递归1，使用双栈  

 
 
    
  
  
  1. void postorder1(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         stack<TreeNode*> s1; 
    4. 
  
  
  4.         stack<TreeNode*> s2; 
    5. 
  
  
  5.         if(!root) return; 
    6. 
  
  
  6.         s1.push(root); 
    7. 
  
  
  7.         while(!s1.empty()) 
    8. 
  
  
  8.         { 
    9. 
  
  
  9.                 s2.push(s1.top()); 
    10. 
  
  
  10.                 s1.pop(); 
    11. 
  
  
  11.                 if(s2.top()->left) 
    12. 
  
  
  12.                         s1.push(s2.top()->left); 
    13. 
  
  
  13.                 if(s2.top()->right) 
    14. 
  
  
  14.                         s1.push(s2.top()->right); 
    15. 
  
  
  15.         } 
    16. 
  
  
  16.         while(!s2.empty()) 
    17. 
  
  
  17.         { 
    18. 
  
  
  18.                 visit(s2.top()); 
    19. 
  
  
  19.                 s2.pop(); 
    20. 
  
  
  20.         } 
    21. 
  
  
  21. } 
    22.

后序非递归2，使用一个pre指针  

 
 
    
  
  
  1. void postorder2(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         stack<TreeNode*> s; 
    4. 
  
  
  4.         TreeNode *pre = NULL; 
    5. 
  
  
  5.         TreeNode *cur; 
    6. 
  
  
  6.         if(!root) return; 
    7. 
  
  
  7.         s.push(root); 
    8. 
  
  
  8.         while(!s.empty()) 
    9. 
  
  
  9.         { 
    10. 
  
  
  10.                 cur = s.top(); 
    11. 
  
  
  11.                 if(!pre || (pre != cur->right && pre != cur->left)) 
    12. 
  
  
  12.                 { 
    13. 
  
  
  13.                         if(!cur->left && !cur->right) 
    14. 
  
  
  14.                         { 
    15. 
  
  
  15.                                 visit(cur); 
    16. 
  
  
  16.                                 s.pop(); 
    17. 
  
  
  17.                                 pre = cur; 
    18. 
  
  
  18.                         } 
    19. 
  
  
  19.                         if(cur->right) 
    20. 
  
  
  20.                                 s.push(cur->right); 
    21. 
  
  
  21.                         if(cur->left) 
    22. 
  
  
  22.                                 s.push(cur->left); 
    23. 
  
  
  23.                 } 
    24. 
  
  
  24.  
    25. 
  
  
  25.                 else if( pre == cur->left) 
    26. 
  
  
  26.                 { 
    27. 
  
  
  27.                         if(cur->right) 
    28. 
  
  
  28.                                 s.push(cur->right); 
    29. 
  
  
  29.                         else 
    30. 
  
  
  30.                         { 
    31. 
  
  
  31.                                 visit(cur); 
    32. 
  
  
  32.                                 s.pop(); 
    33. 
  
  
  33.                                 pre = cur; 
    34. 
  
  
  34.                         } 
    35. 
  
  
  35.                 } 
    36. 
  
  
  36.                 else if(pre == cur->right) 
    37. 
  
  
  37.                 { 
    38. 
  
  
  38.                         visit(cur); 
    39. 
  
  
  39.                         s.pop(); 
    40. 
  
  
  40.                         pre = cur; 
    41. 
  
  
  41.                 } 
    42. 
  
  
  42.         } 
    43. 
  
  
  43. } 
    44.

层次遍历，使用队列  

 
 
    
  
  
  1. void level_traversal(TreeNode *root) 
    2. 
  
  
  2. { 
    3. 
  
  
  3.         queue<TreeNode*> q; 
    4. 
  
  
  4.         if(!root) return; 
    5. 
  
  
  5.         q.push(root); 
    6. 
  
  
  6.         while(!q.empty()) 
    7. 
  
  
  7.         { 
    8. 
  
  
  8.                 if(q.front()->left) 
    9. 
  
  
  9.                         q.push(q.front()->left); 
    10. 
  
  
  10.                 if(q.front()->right) 
    11. 
  
  
  11.                         q.push(q.front()->right); 
    12. 
  
  
  12.                 visit(q.front()); 
    13. 
  
  
  13.                 q.pop(); 
    14. 
  
  
  14.         } 
    15. 
  
  
  15. } 
    16. 
 
 
(更新中)
点赞