Công cụ bảo vệ mã nguồn .NET mạnh nhất, không thể unpack, miễn phí cho các khách hàng đầu tiên đăng ký.
Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 11 kết quả

Đề tài: Duyệt cây nhị phân không đệ quy - Viết bằng C++

  1. #1
    Ngày gia nhập
    10 2007
    Nơi ở
    Lang thang
    Bài viết
    7

    Mặc định Duyệt cây nhị phân không đệ quy - Viết bằng C++

    Đây là đoạn mã mình đã viết duyệt cây nhị phân không đệ quy.Việc duyệt cây theo thứ tự trước và giữa là tương tự nên mình chỉ xin trình bày duyệt theo thứ tự trước và thứ tự sau.

    Duyệt cây theo thứ tự trước không đề quy
    Việc duyệt trước một cây nhị phân được tiến hành như sau: In ra key của nút gốc,sau đó chuyển sang con trái, in ra khóa của nút con trái,...Quá trình thực hiện cho tới khi con trái là rỗng.Lúc này chương trình chuyển sang con phải của nút cận dưới,và duyệt theo sơ đồ trên,cứ như thế việc duyệt cây con phải được tiến hành.

    Nhận thấy rằng nút càng được thăm muộn thì con phải của nó càng được duyệt trước.Chính vì thế sau khi in ra nút,ta phải đưa địa chỉ của nó vào Stack,sau đó mới chuyển sang con trái,để sau này khôi phục lại duyệt con phải của nó.Quá trình đưa địa chỉ vào Stack kết thúc khi con trái là rỗng.Và lúc này ta bắt đầu lấy địa chỉ từ Stack ra thực hiện duyệt cây con phải tương ứng.Việc duyệt cây con phải cũng tương tự,nghĩa là cũng in ra key,rồi đưa địa chỉ nút vào Stack....

    Như vậy quá trình đưa vào Stack và lấy ra khỏi Stack được thực hiện trong cùng một vòng lặp.Mà khi cả vòng lặp đó kết thúc thì cây được duyệt xong.

    Duyệt cây theo thứ tự sau
    Việc duyệt cây theo thứ tự sau rõ ràng không thể tiến hành theo cách thức tương tự như trên được,vì tại mỗi thời điểm lấy từ Stack ra ta cần phải biết được liệu phải đưa vào Stack địa chỉ con phải hay là được phép in ra key của nút.Chính vì thế tại thời điểm đưa vào Stack ngoài việc đưa vào Stack địa chỉ của nút ta còn phải đưa vào một biến hướng dẫn phân biệt hai trường hợp trên.
    Để đơn giản mỗi phần tử của Stack sẽ là một cấu trúc gồm hai thành phần :thành phần con trỏ chứa địa chỉ nút,thành phần boolean chỉ dẫn hai trường hợp trên.

    C++ Code:
    1. struct Info
    2. {
    3.     TreeNode *ptr;
    4.     bool instruct;
    5. };

    để các bạn dễ biên dịch mình cung cấp toàn bộ code về các hàm cơ bản của cây nhị phân tìm kiếm,trong đó có các phép duyệt không đệ quy, là các hàm mang tên PrintPreOrder, PrintInOrder, PrintPostOrder, trong file TreeType.cpp

    Khai báo lớp Stack dùng để chứa địa chỉ các nút trong file StackTreeNode.h

    C++ Code:
    1. struct Info;
    2. struct StackNode;
    3.  
    4. #ifndef STACKTREENODE_H
    5. #define STACKTREENODE_H
    6.  
    7. class StackTreeNode
    8. {
    9. public:
    10.     StackTreeNode();
    11.     ~StackTreeNode();
    12.     bool IsEmpty();
    13.     bool IsFull();
    14.     void Push(Info);
    15.     void Pop();
    16.     Info Top();
    17. private:
    18.     StackNode *topPtr;
    19. };
    20.  
    21. #endif

    Định nghĩa các hàm của Stack trong file StackTreeNode.cpp

    C++ Code:
    1. #include<iostream>
    2. #include<cstddef>
    3.  
    4. using namespace std;
    5.  
    6. #include "StackTreeNode.h"
    7. #include "TreeType.h"
    8.  
    9. struct Info
    10. {
    11.     TreeNode *ptr;
    12.     bool instruct;
    13. };
    14.  
    15. struct StackNode
    16. {
    17.     Info info;
    18.     StackNode *next;
    19. };
    20.  
    21. StackTreeNode::StackTreeNode()
    22. {
    23.     topPtr = NULL;
    24. }
    25.  
    26. StackTreeNode::~StackTreeNode()
    27. {
    28.     while(topPtr != NULL)
    29.     {
    30.         StackNode *temPtr;
    31.  
    32.         temPtr = topPtr;
    33.         topPtr = topPtr->next;
    34.         delete temPtr;
    35.     }
    36. }
    37.  
    38. bool StackTreeNode::IsEmpty()
    39. {
    40.     return(topPtr == NULL);
    41. }
    42.  
    43. bool StackTreeNode::IsFull()
    44. {
    45.     StackNode *location;
    46.  
    47.     location = new StackNode;
    48.  
    49.     if(location == NULL)
    50.     {
    51.         delete location;
    52.         return true;
    53.     }
    54.     else
    55.     {
    56.         delete location;
    57.         return false;
    58.     }
    59. }
    60.  
    61. void StackTreeNode::Push( Info newItem )
    62. {
    63.     if(IsFull())
    64.     {
    65.         cout << "Out of the memory!";
    66.         return;
    67.     }
    68.  
    69.     else
    70.     {
    71.         StackNode *location;
    72.  
    73.         location = new StackNode;
    74.        
    75.         location->info = newItem;
    76.         location->next = topPtr;
    77.         topPtr = location;
    78.     }
    79. }
    80.  
    81. void StackTreeNode::Pop()
    82. {
    83.     if(IsEmpty())
    84.     {
    85.         cout << "Stack is empty!";
    86.         return;
    87.     }
    88.  
    89.     else
    90.     {
    91.         StackNode *temPtr;
    92.  
    93.         temPtr = topPtr;
    94.         topPtr = topPtr->next;
    95.         delete temPtr;
    96.     }
    97. }
    98.  
    99. Info StackTreeNode::Top()
    100. {
    101.     if(IsEmpty())
    102.     {
    103.         cout << "Stack is empty!";
    104.         exit(1);
    105.     }
    106.  
    107.     else
    108.         return topPtr->info;
    109. }

    Khai báo các hàm của lớp cây nhị phân tìm kiếm trong file TreeType.h

    C++ Code:
    1. // Khai bao lop ADT Cay nhi phan tim kiem.
    2. #include<iostream>
    3.  
    4. struct TreeNode;
    5.  
    6. enum OrderType { PRE_ORDER, IN_ORDER, POST_ORDER };
    7.  
    8. typedef int ItemType;
    9. // Gia su rang thanh phan key chua trong moi nut co kieu don gian int
    10. // Doi voi nhung kieu phuc tap hon ta co the dinh nghia tuong tu.
    11.  
    12. #ifndef TREETYPE_H
    13. #define TREETYPE_H
    14.  
    15. class TreeType
    16. {
    17. public:
    18.     TreeType(); // Constructor.
    19.     ~TreeType(); // Destructor.
    20.     TreeType( const TreeType& originalTree );// Copy Constructor.
    21.     void operator=( const TreeType& originalTree ); // Ham nap chong toan tu.
    22.     void MakeEmpty(); // Dua cay ve trang thai rong.
    23.     bool IsEmpty() const; // Kiem tra xem cay co rong hay khong.
    24.     bool IsFull() const; // Kiem tra xem cay co day hay khong.
    25.     int LengthTree();// Ham tra lai so phan tu co tren cay.
    26.     int DepthTree(); // Ham tra lai chieu sau cua cay.
    27.     void RetrieveItem( ItemType& item,bool &found );
    28.     // Ham truy luc toi phan tu tren cay co key giong voi key cua item.
    29.     void InsertItem( ItemType item ); // Chen mot phan tu vao cay.
    30.     void DeleteItem( ItemType item);
    31.     // Xoa phan tu tren cay co key giong voi key cua item.
    32.     void Print( std::ofstream& outFile);
    33.     // In ra outFile cac phan tu theo thu tu tang dan.
    34.     void PrintOrderTree( OrderType order );
    35.     // In ra noi dung cac nut theo kieu duyet order.
    36. private:
    37.     TreeNode *root;
    38. };
    39.  
    40. #endif

    Định nghĩa các hàm của lớp trong file TreeType.cpp

    C++ Code:
    1. #include<iostream>
    2. #include<cstddef>
    3. #include<iomanip>
    4. #include<fstream>
    5.  
    6. using namespace std;
    7.  
    8. #include "TreeType.h"
    9. #include "StackTreeNode.h"
    10.  
    11.  
    12. struct TreeNode
    13. {
    14.     ItemType info;// Thong tin tren node;
    15.     TreeNode *left;// Con tro toi cay con trai.
    16.     TreeNode *right;// Con tro toi cay con  phai.
    17. };
    18.  
    19. struct Info
    20. {
    21.     TreeNode *ptr;
    22.     bool instruct;
    23. };
    24.  
    25. // Nguyen mau cua cac ham bo tro.
    26.  
    27. void Destroy(TreeNode*& tree);
    28. void CopyTree( TreeNode*& copy,const TreeNode *originalTree );
    29. int  CountNodes(TreeNode *tree);
    30. int  Depth(TreeNode *tree);
    31. void Retrieve( TreeNode *tree, ItemType& item, bool& found);
    32. void Insert( TreeNode*& tree, ItemType item);
    33. void Delete( TreeNode*& tree, ItemType item);
    34. void DeleteNode(TreeNode*& tree);
    35. void GetPredecessor(TreeNode *tree, ItemType& data);
    36. void PrintTree( TreeNode *tree, std::ofstream& outFile );
    37. void PrintPreOrder( TreeNode *tree );
    38. void PrintInOrder( TreeNode *tree );
    39. void PrintPostOrder( TreeNode *tree );
    40.  
    41.  
    42. // Dinh nghia cac ham cua lop.
    43.  
    44. TreeType::TreeType()
    45. {
    46.     root = NULL;
    47. }
    48.  
    49. TreeType::~TreeType()
    50. {
    51.     Destroy(root);
    52. }
    53.  
    54. TreeType::TreeType( const TreeType& originalTree )
    55. {
    56.     CopyTree( root, originalTree.root );
    57. }
    58.  
    59. void TreeType::operator=( const TreeType& originalTree )
    60. {
    61.     if(&originalTree == this)
    62.         return;
    63.    
    64.     Destroy(root);
    65.     CopyTree(root,originalTree.root);
    66. }
    67.  
    68. void TreeType::MakeEmpty()
    69. {
    70.     Destroy(root);
    71.     root = NULL;
    72. }
    73.  
    74. bool TreeType::IsEmpty() const
    75. {
    76.     return(root == NULL);
    77. }
    78.  
    79. bool TreeType::IsFull() const
    80. {
    81.     TreeNode *location;
    82.  
    83.     location = new TreeNode;
    84.  
    85.     if(location == NULL)
    86.         return true;
    87.     else
    88.         return false;
    89.     delete location;
    90. }
    91.  
    92. int TreeType::LengthTree()
    93. {
    94.     return CountNodes(root);
    95. }
    96.  
    97. int TreeType::DepthTree()
    98. {
    99.     return Depth(root);
    100. }
    101.  
    102. void TreeType::RetrieveItem( ItemType& item, bool& found)
    103. {
    104.     Retrieve(root,item,found);
    105. }
    106.  
    107. void TreeType::InsertItem(ItemType item)
    108. {
    109.     if( IsFull() )
    110.     {
    111.         cout << "Het bo nho de cap phat !\n";
    112.         exit(1);
    113.     }
    114.  
    115.     Insert(root,item);
    116. }
    117.  
    118. void TreeType::DeleteItem( ItemType item)
    119. {
    120.     if( IsEmpty() )
    121.     {
    122.         cout << setw(25) << " " << "Cay rong !\n";
    123.         return;
    124.     }
    125.    
    126.     Delete(root,item);
    127. }
    128.  
    129. void TreeType::Print(std::ofstream& outFile)
    130. {
    131.     PrintTree(root,outFile);
    132. }
    133.  
    134. void TreeType::PrintOrderTree( OrderType order )
    135. {
    136.     switch(order)
    137.     {
    138.     case PRE_ORDER: PrintPreOrder(root);
    139.                     break;
    140.     case IN_ORDER:
    141.                     PrintInOrder(root);
    142.                     break;
    143.     case POST_ORDER : PrintPostOrder(root);
    144.                       break;
    145.     }
    146. }
    147.                          
    148.                      
    149. // Dinh nghia cac ham ho tro.
    150.  
    151.  
    152. void Destroy(TreeNode*& tree)
    153. {
    154.     if(tree != NULL)
    155.     {
    156.         Destroy(tree->left);
    157.         Destroy(tree->right);
    158.         delete tree;
    159.     }
    160. }
    161.  
    162. void CopyTree( TreeNode*& copy,const TreeNode *originalTree )
    163. {
    164.     if(originalTree == NULL )
    165.         copy = NULL;
    166.     else
    167.     {
    168.         copy = new TreeNode;
    169.         copy->info = originalTree->info;
    170.  
    171.         CopyTree(copy->left,originalTree->left);
    172.         CopyTree(copy->right,originalTree->right);
    173.     }
    174. }
    175.  
    176. int CountNodes(TreeNode *tree)
    177. {
    178.     if(tree == NULL)
    179.         return 0;
    180.     else
    181.         return CountNodes(tree->left) + CountNodes(tree->right) + 1;
    182. }
    183.  
    184. int Depth(TreeNode *tree)
    185. {
    186.     if(tree == NULL)
    187.         return 0;
    188.     int leftSubTreeDepth = Depth(tree->left);
    189.     int rightSubTreeDepth = Depth(tree->right);
    190.  
    191.     return (1 + (leftSubTreeDepth > rightSubTreeDepth ? leftSubTreeDepth : rightSubTreeDepth));
    192. }
    193.  
    194. void Retrieve( TreeNode *tree, ItemType& item, bool& found)
    195. {
    196.     if(tree == NULL)
    197.         found = false;
    198.     else if(item < tree->info)
    199.         Retrieve(tree->left,item,found);
    200.     else if(item > tree->info)
    201.         Retrieve(tree->right,item,found);
    202.     else
    203.     {
    204.         found = true;
    205.         item = tree->info;
    206.     }
    207. }
    208.  
    209. void Insert( TreeNode*& tree, ItemType item)
    210. {
    211.     if(tree == NULL)
    212.     {
    213.         tree = new TreeNode;
    214.  
    215.         tree->info = item;
    216.         tree->left = NULL;
    217.         tree->right = NULL;
    218.     }
    219.  
    220.     else if(item < tree->info)
    221.         Insert(tree->left,item);// Chen vao cay con trai.
    222.     else if(item > tree->info)
    223.         Insert(tree->right,item);// Chen vao cay con phai.
    224. }
    225.  
    226. void Delete( TreeNode*& tree, ItemType item )
    227. {
    228.     if(item < tree->info)
    229.         Delete(tree->left,item);
    230.     else if(item > tree->info)
    231.         Delete(tree->right,item);
    232.     else
    233.         DeleteNode(tree);
    234. }
    235.  
    236. void DeleteNode(TreeNode*& tree)
    237. {
    238.     ItemType data;
    239.     TreeNode *temPtr;
    240.  
    241.     temPtr = tree;
    242.  
    243.     if(tree->left == NULL)
    244.     {
    245.         tree = tree->right;
    246.         delete temPtr;
    247.     }
    248.     else if(tree->right == NULL)
    249.     {
    250.         tree = tree->left;
    251.         delete temPtr;
    252.     }
    253.         GetPredecessor(tree->left,data);
    254.        
    255.         tree->info = data;
    256.         Delete(tree->left,data);
    257.     }
    258. }
    259.  
    260. void GetPredecessor( TreeNode *tree, ItemType& data )
    261. {
    262.     while(tree->right != NULL)
    263.         tree = tree->right;
    264.    
    265.     data = tree->info;
    266. }
    267.  
    268. void PrintTree( TreeNode *tree, std::ofstream& outFile )
    269. {
    270.     if(tree != NULL)
    271.     {
    272.         PrintTree(tree->left,outFile);
    273.         outFile << tree->info;
    274.         PrintTree(tree->right,outFile);
    275.     }
    276. }
    277.  
    278. /*void PrintPreOrder( TreeNode *tree )
    279. {
    280.     if( tree != NULL )
    281.     {
    282.         cout << setw(3) << tree->info;
    283.         PrintPreOrder( tree->left );
    284.         PrintPreOrder( tree->right );
    285.     }
    286.  
    287.     cout << endl;
    288. }*/
    289.  
    290. /*void PrintInOrder( TreeNode *tree )
    291. {
    292.     if( tree != NULL )
    293.     {
    294.         PrintInOrder( tree->left );
    295.         cout << setw(3) << tree->info;
    296.         PrintInOrder( tree-> right );
    297.     }
    298. }*/
    299.  
    300. /*void PrintPostOrder( TreeNode *tree )
    301. {
    302.     if( tree != NULL )
    303.     {
    304.         PrintPostOrder( tree->left );
    305.         PrintPostOrder( tree->right );
    306.         cout << setw(3) << tree->info;
    307.     }
    308. }*/
    309.  
    310. [COLOR="Red"]void PrintPreOrder( TreeNode *tree )
    311. {
    312.     StackTreeNode stackPre;
    313.     Info element;
    314.    
    315.     while((tree != NULL) || (!stackPre.IsEmpty()))
    316.     {
    317.         while( tree != NULL )
    318.         {
    319.             cout << setw(3) << tree->info;
    320.  
    321.             element.ptr = tree;
    322.             element.instruct = true;
    323.             stackPre.Push(element);
    324.            
    325.             tree = tree->left;
    326.         }
    327.  
    328.         element = stackPre.Top();
    329.         stackPre.Pop();
    330.        
    331.         tree = element.ptr;
    332.         tree = tree->right;
    333.     }
    334. }
    335.  
    336. void PrintInOrder( TreeNode *tree )
    337. {
    338.     StackTreeNode stackIn;
    339.     Info element;
    340.  
    341.     while((tree != NULL) || (!stackIn.IsEmpty()))
    342.     {
    343.         while( tree != NULL )
    344.         {
    345.             element.ptr = tree;
    346.             element.instruct = true;
    347.  
    348.             stackIn.Push(element);
    349.             tree = tree->left;
    350.         }
    351.  
    352.         element = stackIn.Top();
    353.         stackIn.Pop();
    354.         tree = element.ptr;
    355.  
    356.         cout << setw(3) << tree->info;
    357.         tree = tree->right;
    358.     }
    359. }
    360.  
    361. void PrintPostOrder( TreeNode * tree )
    362. {
    363.     StackTreeNode stackPost;
    364.     Info element;
    365.  
    366.     while((tree != NULL) || (!stackPost.IsEmpty()))
    367.     {
    368.         while( tree != NULL )
    369.         {
    370.             element.ptr = tree;
    371.             element.instruct = true;
    372.  
    373.             stackPost.Push(element);
    374.             tree = tree->left;
    375.         }
    376.  
    377.         element = stackPost.Top();
    378.         stackPost.Pop();
    379.         tree = element.ptr;
    380.  
    381.         if( element.instruct )
    382.         {
    383.             element.instruct = false;
    384.             element.ptr = tree;
    385.  
    386.             stackPost.Push(element);
    387.             tree = tree->right;
    388.         }
    389.         else
    390.         {
    391.             cout << setw(3) << tree->info;
    392.             tree = NULL;
    393.         }
    394.     }[/COLOR]
    395. }

    Và cuối cùng là hàm main để check

    C++ Code:
    1. // Test thu cac ham thao tac tren Cay nhi phan tim kiem.
    2. #include<iostream>
    3. #include<iomanip>
    4.  
    5. using namespace std;
    6.  
    7. #include "TreeType.h"
    8.  
    9. int main()
    10. {
    11.     TreeType myTree;
    12.     ItemType item;
    13.     OrderType order;
    14.     int choice,option;
    15.     bool found;
    16.  
    17.     cout << setw(15) << " " << "CHUONG TRINH TEST THU CAY NHI PHAN TIM KIEM\n"
    18.          << setw(15) << " " << "==========================================="
    19.          << "\n\n\n";
    20.     cout << setw(20) << " " << "1:Tao cay BST\n"
    21.          << setw(20) << " " << "2:Chen phan tu moi vao cay BST\n"
    22.          << setw(20) << " " << "3:Xoa phan tu khoi cay BST\n"
    23.          << setw(20) << " " << "4:Truy tim phan tu\n"
    24.          << setw(20) << " " << "5:In ra tong so phan tu\n"
    25.          << setw(20) << " " << "6:In ra chieu sau cua cay\n"
    26.          << setw(20) << " " << "7:In ra cac phan tu theo kieu duyet\n"
    27.          << setw(20) << " " << "8:Huy cay da duoc tao\n"
    28.          << setw(20) << " " << "9:Thoat khoi chuong trinh\n\n";
    29.  
    30.     while(1)
    31.     {
    32.         cout << "\nNhap vao lua chon cua ban:";
    33.         cin >> choice;
    34.  
    35.         switch(choice)
    36.         {
    37.         case 1: int number;
    38.                
    39.                 cout << "Nhap vao so nut: ";
    40.                 cin >> number;
    41.  
    42.                 while( number > 0 )
    43.                 {
    44.                     cout << "Nhap gia tri: ";
    45.                     cin >> item;
    46.                     myTree.InsertItem(item);
    47.                     number--;
    48.                 }
    49.                 break;
    50.  
    51.         case 2: cout << "Nhap vao mot so nguyen :";
    52.                 cin >> item;
    53.            
    54.                 myTree.InsertItem(item);
    55.                 break;
    56.    
    57.         case 3: cout << "Nhap vao phan tu can xoa :";
    58.                 cin >> item;
    59.                 myTree.DeleteItem(item);
    60.                 break;
    61.    
    62.         case 4: cout << "Nhap phan tu can tim kiem :";
    63.                 cin >> item;
    64.            
    65.                 myTree.RetrieveItem(item,found);
    66.            
    67.                 if( found == true)
    68.                     cout << "Phan tu co mat tren cay !\n";
    69.                 else
    70.                     cout << "Phan tu khong co tren cay !\n";
    71.                 break;
    72.    
    73.         case 5: cout << "So phan tu hien co tren cay la: "
    74.                      << myTree.LengthTree() << endl;
    75.                 break;
    76.    
    77.         case 6: cout << "Chieu sau cua cay la: "
    78.                      << myTree.DepthTree() << endl;
    79.                 break;
    80.    
    81.         case 7: cout << setw(20) << " " << "1:Duyet theo thu tu truoc\n"
    82.                      << setw(20) << " " << "2:Duyet theo thu tu giua\n"
    83.                      << setw(20) << " " << "3:Duyet theo thu tu sau\n";
    84.            
    85.                  cout << "Nhap vao lua chon cua ban:";
    86.                  cin >> option;
    87.            
    88.                  order = (OrderType) (option-1);
    89.            
    90.                  if( myTree.IsEmpty() )
    91.                  {
    92.                      cout << "Cay rong!\n";
    93.                      break;
    94.                  }
    95.            
    96.                  else
    97.                      myTree.PrintOrderTree(order);
    98.                  break;
    99.        
    100.         case 8: myTree.MakeEmpty();
    101.                 break;
    102.  
    103.         case 9: return 0;
    104.    
    105.         }
    106.     }
    107.     return 0;
    108. }

    hic mong các bác thông cảm nhá,tại em đang bận thi,nên không thể trình bày hẳn hoi được,tạ lỗi,tạ lỗi
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

  2. #2
    Ngày gia nhập
    05 2012
    Nơi ở
    Hà Nội
    Bài viết
    1

    bạn pro về cây nhị phân thế,có thể giúp mình cái này ko:
    Hãy sử dụng cấu trúc cây nhị phân tìm kiếm lưu trữ danh sách hàng hóa(tên hàng, mã hàng, dùng mà hàng làm khóa, khối lượng, năm sản xuất.
    1.Nhập cây mới
    2.Duyệt theo thứ tự giữa không dùng đệ quy
    3.thêm nút mới
    4.xóa một nút của cây
    5.tìm kiếm một nút khi biết mã.

  3. #3
    Ngày gia nhập
    04 2010
    Nơi ở
    Binh Thanh, Hồ Chí Minh, Vietnam, Vietnam
    Bài viết
    504

    Đoạn code này nhìn vui nhỉ?
    C++ Code:
    1. bool TreeType::IsFull() const
    2. {
    3.     TreeNode *location;
    4.  
    5.     location = new TreeNode;
    6.  
    7.     if(location == NULL)
    8.         return true;
    9.     else
    10.         return false;
    11.     delete location;
    12. }
    Kết bạn với tôi <3
    Skype: giautm
    Facebook:
    https://fb.com/giautm.duongntt
    Email:
    giau.tmg@gmail.com

  4. #4
    Ngày gia nhập
    11 2010
    Bài viết
    589

    ^
    Ngoài "vui" ra thì đoạn code trên còn chả giải quyết được cái gì, vì mặc định operator new nếu không thành công sẽ throw một std::bad_alloc chứ không phải là trả về NULL.

  5. #5
    Ngày gia nhập
    04 2010
    Nơi ở
    Binh Thanh, Hồ Chí Minh, Vietnam, Vietnam
    Bài viết
    504

    Trích dẫn Nguyên bản được gửi bởi boss14420 Xem bài viết
    ^
    Ngoài "vui" ra thì đoạn code trên còn chả giải quyết được cái gì, vì mặc định operator new nếu không thành công sẽ throw một std::bad_alloc chứ không phải là trả về NULL.
    "Vui" vì nó chẳng làm đc gì. ~>"<~. giả sử có cấp phát đc đi nữa, mà lại không giải phóng, gọi hàm này kiểm tra chừng vài trăm, hay vài nghìn gì đó là OS toi chắc.
    Kết bạn với tôi <3
    Skype: giautm
    Facebook:
    https://fb.com/giautm.duongntt
    Email:
    giau.tmg@gmail.com

  6. #6
    Ngày gia nhập
    10 2006
    Nơi ở
    In Your Bugs
    Bài viết
    823

    Mặc định Duyệt cây nhị phân không đệ quy - Viết bằng C++

    Có cách nào viết cho location về NULL ko bạn ?

  7. #7
    Ngày gia nhập
    04 2010
    Nơi ở
    Binh Thanh, Hồ Chí Minh, Vietnam, Vietnam
    Bài viết
    504


    Ủa, bài post của bác boss14420 đâu rồi. Bác ấy trả lời cho bạn rồi mà? ~>"<~
    __http://www.cplusplus.com/reference/std/new/nothrow/
    Kết bạn với tôi <3
    Skype: giautm
    Facebook:
    https://fb.com/giautm.duongntt
    Email:
    giau.tmg@gmail.com

  8. #8
    Ngày gia nhập
    12 2009
    Nơi ở
    bế quan tu lại
    Bài viết
    846

    nếu a kidkid đã hỏi vậy thì chắc là anh có cách, chia sẻ cho mọi người tham khảo đi anh ^^

  9. #9
    Ngày gia nhập
    04 2010
    Nơi ở
    Binh Thanh, Hồ Chí Minh, Vietnam, Vietnam
    Bài viết
    504

    Trích dẫn Nguyên bản được gửi bởi aydada Xem bài viết
    nếu a kidkid đã hỏi vậy thì chắc là anh có cách, chia sẻ cho mọi người tham khảo đi anh ^^
    Chưa xem qua link tôi để lại sao?? ~>"<~
    Kết bạn với tôi <3
    Skype: giautm
    Facebook:
    https://fb.com/giautm.duongntt
    Email:
    giau.tmg@gmail.com

  10. #10
    Ngày gia nhập
    02 2012
    Nơi ở
    Thủ Đức
    Bài viết
    19

    hjx anh nào pro giúp em xuất LNR trong C ko dùng đệ quy

    Code:
    typedef struct tagtnode
    {
    	int info;
    	struct tagtnode *left,*right;
    }tnode;
    typedef tnode* tree;
    tree t;
    void outputNLR(tree t)
    {
    	tree p=t,stack[50];
    	int numofele=0,conti=1;
    	while(p&&conti)
    	{
    		printf("%d",p->info);
    		if(p->right)stack[numofele++]=p->right;
    		if(p->left)p=p->left;
    		else
    		{
    			if(numofele==0)conti=0;
    			else p=stack[numofele--];
    		}
    	}
    }
    void outputLNR(tree t)
    {
    	tree stack1[50],stack2[50],p=t;
    	int numofele1=0,numofele2=0,conti=1;
    	while(p&&conti)
    	{
    		if(p->right)stack1[numofele1++]=p->right;
    		if(p->left)
    		{
    			stack2[numofele2++]=p;
    			p=p->left;
    		}
    		else
    		{
    			printf("%d",p->info);
    			if(p->right==NULL)printf("%d",stack2[--numofele2]->info);
    			if(numofele1!=0)p=stack1[--numofele1];
    			else conti=0;
    		}
    	}
    }
    NLR thì em làm đc chứ cái LNR em bó tai rồi.ai giúp em với
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

Các đề tài tương tự

  1. Hải Phòng Cần tìm người có thể viết được phần mềm duyệt mail
    Gửi bởi stksonstk trong diễn đàn Việc làm IT(tự do)
    Trả lời: 2
    Bài viết cuối: 10-11-2013, 04:45 PM
  2. Trình duyệt web viết bằng C#, làm thế nào để tạo link mở trên cửa sổ mới?
    Gửi bởi kendy92 trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 4
    Bài viết cuối: 10-04-2013, 07:28 PM
  3. Trình duyệt Opera, giúp bạn trải nghiệm tốt hơn khi duyệt wap
    Gửi bởi hailuacuibep trong diễn đàn Software (Phần mềm) | Ebooks
    Trả lời: 2
    Bài viết cuối: 02-01-2013, 12:12 PM
  4. Duyệt các controls bằng foreach thì control nào sẽ được duyệt trước
    Gửi bởi chitviv trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 4
    Bài viết cuối: 05-10-2011, 10:01 PM
  5. mã nguồn duyệt cây nhị phân viết bằng C
    Gửi bởi trần trân trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 27-10-2009, 05:55 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn