Advertisement
ltdpaste

Binary Tree 2

Jun 16th, 2019
123
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 3.85 KB | None | 0 0
  1. #include <iostream>
  2. #include <fstream>
  3. #include <stdio.h>
  4. using namespace std;
  5.  
  6. typedef struct Node
  7. {
  8. int data;
  9. struct Node* pLeft;
  10. struct Node* pRight;
  11. }NODE;
  12. typedef NODE* Tree;
  13.  
  14. void Init(Tree& t)
  15. {
  16. t = NULL;
  17. }
  18.  
  19. Node* CreateNode(int newdata)
  20. {
  21. Node* p = new Node;
  22. if (!p)
  23. {
  24. return NULL;
  25. }
  26. else
  27. {
  28. p->data = newdata;
  29. p->pLeft = p->pRight = NULL;
  30. }
  31. return p;
  32. }
  33.  
  34. void AddNode(Tree& t, Node* p)
  35. {
  36. if (t == NULL)
  37. {
  38. t = p;
  39. t->pLeft = t->pRight = NULL;
  40. }
  41. else
  42. {
  43. if (p->data < t->data)
  44. {
  45. AddNode(t->pLeft, p);
  46. }
  47. else
  48. {
  49. AddNode(t->pRight, p);
  50. }
  51. }
  52. }
  53.  
  54. void Input(Tree& t)
  55. {
  56. ifstream inp;
  57. inp.open("input.txt");
  58. if (!inp.is_open())
  59. {
  60. cout << "ERROR: Cannot open the input file!";
  61. }
  62. else
  63. {
  64. int newdata;
  65. Node* p = new Node;
  66. while (inp >> newdata)
  67. {
  68. p = CreateNode(newdata);
  69. AddNode(t, p);
  70. }
  71. }
  72. }
  73.  
  74. void LNR(Tree t)
  75. {
  76. if (t != NULL)
  77. {
  78. LNR(t->pLeft);
  79. cout << t->data << " ";
  80. LNR(t->pRight);
  81. }
  82. }
  83.  
  84. bool Search(const Tree t, int value)
  85. {
  86. if (t == NULL)
  87. return false;
  88. if (t->data == value)
  89. {
  90. return true;
  91. }
  92. else if (t->data > value)
  93. {
  94. return Search(t->pLeft, value);
  95. }
  96. else if (t->data < value)
  97. {
  98. return Search(t->pRight, value);
  99. }
  100. }
  101.  
  102. int MostLeft(Tree t)
  103. {
  104. while (t->pLeft != NULL)
  105. {
  106. t = t->pLeft;
  107. }
  108. return t->data;
  109. }
  110. //
  111. //Node* Delete(Tree &t, int value)
  112. //{
  113. // if (t == NULL)
  114. // return t;
  115. // if (t->data > value)
  116. // t->pLeft = Delete(t->pLeft, value);
  117. // else if (t->data < value)
  118. // t->pRight = Delete(t->pRight, value);
  119. // else
  120. // {
  121. // if (t->pLeft == NULL)
  122. // {
  123. // Node* newRoot = t->pRight;
  124. // t = NULL;
  125. // return newRoot;
  126. // }
  127. // if (t->pRight == NULL)
  128. // {
  129. // Node* newRoot = t->pLeft;
  130. // t = NULL;
  131. // return newRoot;
  132. // }
  133. // t->data = MostLeft(t->pRight);
  134. // t->pRight = Delete(t->pRight, t->data);
  135. // }
  136. // return t;
  137. //}
  138.  
  139.  
  140. //Node* Delete(Tree& t, int value)
  141. //{
  142. // if (t == NULL)
  143. // return t;
  144. // if (t->data > value)
  145. // t->pLeft = Delete(t->pLeft, value);
  146. // if (t->data < value)
  147. // t->pRight = Delete(t->pRight, value);
  148. // else
  149. // {
  150. // if (t->pLeft == NULL)
  151. // {
  152. // Node* newRoot = t->pRight;
  153. // t = NULL;
  154. // return newRoot;
  155. // }
  156. // if (t->pRight == NULL)
  157. // {
  158. // Node* newRoot = t->pLeft;
  159. // t == NULL;
  160. // return newRoot;
  161. // }
  162. // t->data = MostLeft(t->pRight);
  163. // t->pRight = Delete(t->pRight, t->data);
  164. // }
  165. // return t;
  166. //}
  167. //
  168. //Node* Delete(Tree& t, int value)
  169. //{
  170. // if (t == NULL)
  171. // return t;
  172. // if (t->data > value)
  173. // t->pLeft = Delete(t->pLeft, value);
  174. // if (t->data < value)
  175. // t->pRight = Delete(t->pRight, value);
  176. // else
  177. // {
  178. // if (t->pLeft == NULL)
  179. // {
  180. // Node* newRoot = t->pRight;
  181. // t = NULL;
  182. // return newRoot;
  183. // }
  184. // if (t->pRight == NULL)
  185. // {
  186. // Node* newRoot = t->pLeft;
  187. // t = NULL;
  188. // return newRoot;
  189. // }
  190. // t->data = MostLeft(t->pRight);
  191. // t->pRight = Delete(t->pRight, t->data);
  192. // }
  193. // return t;
  194. //}
  195.  
  196. Node* Delete(Tree& t, int value)
  197. {
  198. if (t == NULL)
  199. return t;
  200. if (t->data > value)
  201. t->pLeft = Delete(t->pLeft, value);
  202. if (t->data < value)
  203. t->pRight = Delete(t->pRight, value);
  204. else
  205. {
  206. if (t->pLeft == NULL)
  207. {
  208. Node* newRoot = t->pRight;
  209. t = NULL;
  210. return newRoot;
  211. }
  212. if (t->pRight == NULL)
  213. {
  214. Node* newRoot = t->pLeft;
  215. t = NULL;
  216. return newRoot;
  217. }
  218. t->data = MostLeft(t->pRight);
  219. t->pRight = Delete(t->pRight, t->data);
  220. }
  221. return t;
  222. }
  223.  
  224. int main()
  225. {
  226. Tree t;
  227. int x, m;
  228. Init(t);
  229. Input(t);
  230. LNR(t);
  231. cout << "\nNhap x= ";
  232. cin >> x;
  233. if (Search(t, x))
  234. {
  235. cout << "Tim thay " << x << endl;
  236. }
  237. else
  238. {
  239. cout << "Khong tim thay " << x << endl;
  240. }
  241. cout << "Nhap m= ";
  242. cin >> m;
  243. Delete(t, m);
  244. cout << "Da xoa node: " << m << endl;
  245. LNR(t);
  246. return 0;
  247. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement