时间限制

100 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. Figures 1-4 illustrate the rotation rules.

 

 

Now given a sequence of insertions, you are supposed to tell the root of the resulting AVL tree.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (<=20) which is the total number of keys to be inserted. Then N distinct integer keys are given in the next line. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print ythe root of the resulting AVL tree in one line.

Sample Input 1:

588 70 61 96 120

Sample Output 1:

70

Sample Input 2:

788 70 61 96 120 90 65

Sample Output 2:

88

来源： <>

 

1. #include <iostream>
2. #include <fstream>
4. using namespace std;
6. struct Node
7. {
8. int value;
9. Node* leftChild;
10. Node* rightChild;
11. int height; //左子树高度 - 右子树高度
12. Node(int v):value(v),leftChild(NULL),rightChild(NULL),height(0){}
13. };
15. int getHeight(Node* node)
16. {
17. if(node == NULL)return -1;
18. return node->height;
20. }
22. bool isBalanced(Node* parent)
23. {
24. return abs(getHeight(parent->leftChild) - getHeight(parent->rightChild)) < 2;
25. }
27. Node* rotate_LL(Node* parent)
28. {
29. Node* child = parent->leftChild;
30. parent->leftChild = child->rightChild;
31. child->rightChild = parent;
33. parent->height = max(getHeight(parent->leftChild),getHeight(parent->rightChild)) + 1;
34. child->height = max(getHeight(child->leftChild),getHeight(child->rightChild)) + 1;
35. return child;
36. }
38. Node* rotate_RR(Node* parent)
39. {
40. Node* child = parent->rightChild;
41. parent->rightChild = child->leftChild;
42. child->leftChild = parent;
44. parent->height = max(getHeight(parent->leftChild),getHeight(parent->rightChild)) + 1;
45. child->height = max(getHeight(child->leftChild),getHeight(child->rightChild)) + 1;
46. return child;
47. }
49. Node* rotate_LR(Node* parent)
50. {
51. Node* child = parent->leftChild;
52. parent->leftChild = rotate_RR(child);
53. return rotate_LL(parent);
54. }
56. Node* rotate_RL(Node* parent)
57. {
58. Node* child = parent->rightChild;
59. parent->rightChild = rotate_LL(child);
60. return rotate_RR(parent);
61. }
63. Node* InsertNode(Node* root,int newValue)
64. {
65. if(root!=NULL)
66. {
67. if(newValue > root->value) //R
68. {
69. root->rightChild = InsertNode(root->rightChild,newValue);
70. if(!isBalanced(root))
71. {
72. if(newValue > root->rightChild->value) //R-R
73. {
74. root = rotate_RR(root);
75. }else //R-L
76. {
77. root = rotate_RL(root);
78. }
79. }
80. }else //L
81. {
82. root->leftChild = InsertNode(root->leftChild,newValue);
83. if(!isBalanced(root))
84. {
85. if(newValue > root->leftChild->value) //L-R
86. {
87. root = rotate_LR(root);
88. }else //L-L
89. {
90. root = rotate_LL(root);
91. }
92. }
93. }
94. }else
95. {
96. root = new Node(newValue);
97. }
98. root->height = max(getHeight(root->leftChild),getHeight(root->rightChild)) + 1;
99. return root;
100. }
102. void PrintTree(Node* root)
103. {
104. if(root != NULL)
105. {
106. cout<<root->value<<"--";
107. PrintTree(root->leftChild);
108. PrintTree(root->rightChild);
109. }
110. }
112. int main()
113. {
114. int n;
115. cin>>n;
117. Node *root = NULL;
119. int x;
120. int i;
121. for(i=0;i<n;i++)
122. {
123. cin>>x;
124. root = InsertNode(root,x);
125. }
126. cout<<root->value<<endl;
127. system("PAUSE");
128. return 0;
129. }