Skip to content

Commit 08a3d0c

Browse files
ksundongksundong
authored
Merge pull request #41 from Data-Structure-Study/yoonexample
AVL 트리 구현... (미완성)
2 parents b3d8abf + eef99ac commit 08a3d0c

File tree

3 files changed

+209
-1
lines changed

3 files changed

+209
-1
lines changed

‎yoonexample/src/main/java/search/binarysearchtree/AVLTreeNode.java

+106
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
package search.binarysearchtree;
2+
3+
import java.util.Comparator;
4+
import tree.binarytree.BinaryTreeNode;
5+
6+
public class AVLTreeNode<E> extends LinkedBinarySearchTreeNode<E> {
7+
8+
public AVLTreeNode(E data, Comparator<E> comparator) {
9+
super(data, comparator);
10+
}
11+
12+
@Override
13+
public void insert(E data) {
14+
super.insert(data);
15+
rebalance();
16+
}
17+
18+
@Override
19+
public BinaryTreeNode<E> remove(E target) {
20+
BinaryTreeNode<E> removeNode = super.remove(target);
21+
rebalance();
22+
return removeNode;
23+
}
24+
25+
private int getHeight(BinaryTreeNode<E> binaryTreeNode) {
26+
if (binaryTreeNode == null) {
27+
return 0;
28+
}
29+
int leftHeight = getHeight(binaryTreeNode.getLeftSubTree());
30+
int rightHeight = getHeight(binaryTreeNode.getRightSubTree());
31+
32+
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; // 큰 쪽의 높이 반환
33+
}
34+
35+
private int getEquilibriumFactor(BinaryTreeNode<E> binaryTreeNode) {
36+
if (binaryTreeNode == null) {
37+
return 0;
38+
}
39+
40+
int leftHeight = getHeight(binaryTreeNode.getLeftSubTree());
41+
int rightHeight = getHeight(binaryTreeNode.getRightSubTree());
42+
43+
return leftHeight - rightHeight;
44+
}
45+
46+
private BinaryTreeNode<E> rotateLL(BinaryTreeNode<E> binaryTreeNode) {
47+
// LL 회전을 위한 준비
48+
BinaryTreeNode<E> parentNode = binaryTreeNode;
49+
BinaryTreeNode<E> childNode = parentNode.getLeftSubTree();
50+
51+
// LL 회전
52+
parentNode.changeLeftSubTree(childNode.getRightSubTree());
53+
childNode.changeRightSubTree(parentNode);
54+
55+
return childNode; // 변경된 루트 노드 반환
56+
}
57+
58+
private BinaryTreeNode<E> rotateRR(BinaryTreeNode<E> binaryTreeNode) {
59+
// RR 회전을 위한 준비
60+
BinaryTreeNode<E> parentNode = binaryTreeNode;
61+
BinaryTreeNode<E> childNode = parentNode.getRightSubTree();
62+
63+
// RR 회전
64+
parentNode.changeRightSubTree(childNode.getLeftSubTree());
65+
childNode.changeLeftSubTree(parentNode);
66+
67+
return childNode; // 변경된 루트 노드 반환
68+
}
69+
70+
private BinaryTreeNode<E> rotateLR(BinaryTreeNode<E> binaryTreeNode) {
71+
// LR 회전을 위한 준비
72+
BinaryTreeNode<E> parentNode = binaryTreeNode;
73+
BinaryTreeNode<E> childNode = parentNode.getLeftSubTree();
74+
75+
parentNode.changeLeftSubTree(rotateRR(childNode)); // 부분적 RR회전
76+
return rotateLL(parentNode); // LL회전
77+
}
78+
79+
private BinaryTreeNode<E> rotateRL(BinaryTreeNode<E> binaryTreeNode) {
80+
// RL 회전을 위한 준비
81+
BinaryTreeNode<E> parentNode = binaryTreeNode;
82+
BinaryTreeNode<E> childNode = parentNode.getLeftSubTree();
83+
84+
parentNode.changeRightSubTree(rotateLL(childNode)); // 부분적 LL회전
85+
return rotateRR(parentNode); // RR회전
86+
}
87+
88+
private void rebalance() {
89+
int equilibriumFactor = getEquilibriumFactor(super.node);
90+
91+
if (equilibriumFactor > 1) { // LL OR LR
92+
if (getEquilibriumFactor(super.node.getLeftSubTree()) > 0) {
93+
super.node = rotateLL(super.node);
94+
} else {
95+
super.node = rotateLR(super.node);
96+
}
97+
}
98+
if (equilibriumFactor < -1) { // RR OR RL
99+
if (getEquilibriumFactor(super.node.getRightSubTree()) < 0) {
100+
super.node = rotateRR(super.node);
101+
} else {
102+
super.node = rotateRL(super.node);
103+
}
104+
}
105+
}
106+
}

‎yoonexample/src/main/java/search/binarysearchtree/LinkedBinarySearchTreeNode.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
public class LinkedBinarySearchTreeNode<E> implements BinarySearchTreeNode<E> {
88

99
private final Comparator<E> comparator;
10-
private BinaryTreeNode<E> node;
10+
protected BinaryTreeNode<E> node;
1111

1212
public LinkedBinarySearchTreeNode(E data, Comparator<E> comparator) {
1313
this.node = new LinkedBinaryTreeNode<>(data);

‎yoonexample/src/test/java/search/binarysearchtree/BinarySearchTreeNodeTest.java

+102
Original file line numberDiff line numberDiff line change
@@ -104,4 +104,106 @@ class BinarySearchTreeNodeTest {
104104
assertThat(bstRoot.search(8).getData())
105105
.isEqualTo(bstRoot.remove(8).getData());
106106
}
107+
108+
@Test
109+
@DisplayName("AVL_트리_테스트")
110+
void AVL_트리_테스트() {
111+
BinarySearchTreeNode<Integer> bstRoot = new AVLTreeNode<>(1, (Comparator.comparingInt(o -> o)));
112+
BinaryTreeNode<Integer> searchNode;
113+
114+
bstRoot.insert(5);
115+
bstRoot.insert(6);
116+
bstRoot.insert(2);
117+
bstRoot.insert(8);
118+
bstRoot.insert(3);
119+
bstRoot.insert(9);
120+
121+
searchNode = bstRoot.search(1);
122+
assertThat(searchNode).isNotNull();
123+
assertThat(searchNode.getData()).isEqualTo(1);
124+
125+
searchNode = bstRoot.search(4);
126+
assertThat(searchNode).isNull();
127+
128+
searchNode = bstRoot.search(6);
129+
assertThat(searchNode).isNotNull();
130+
assertThat(searchNode.getData()).isEqualTo(6);
131+
132+
searchNode = bstRoot.search(7);
133+
assertThat(searchNode).isNull();
134+
135+
// BinaryTreeNode<Integer> rootNode = bstRoot.search(5);
136+
// BinaryTreeNode<Integer> rootNodeLeftSubTree = rootNode.getLeftSubTree();
137+
// BinaryTreeNode<Integer> rootNodeRightSubTree = rootNode.getRightSubTree();
138+
//
139+
// assertThat(rootNode.getData()).isEqualTo(5);
140+
// assertThat(rootNodeLeftSubTree.getData()).isEqualTo(2);
141+
// assertThat(rootNodeRightSubTree.getData()).isEqualTo(8);
142+
// assertThat(rootNodeLeftSubTree.getLeftSubTree().getData()).isEqualTo(1);
143+
// assertThat(rootNodeLeftSubTree.getRightSubTree().getData()).isEqualTo(3);
144+
// assertThat(rootNodeRightSubTree.getLeftSubTree().getData()).isEqualTo(6);
145+
// assertThat(rootNodeRightSubTree.getRightSubTree().getData()).isEqualTo(9);
146+
}
147+
148+
@Test
149+
@DisplayName("AVL_트리_제거_테스트")
150+
void AVL_트리_제거_테스트() {
151+
BinarySearchTreeNode<Integer> bstRoot = new AVLTreeNode<>(5, (Comparator.comparingInt(o -> o)));
152+
153+
bstRoot.insert(1);
154+
bstRoot.insert(2);
155+
bstRoot.insert(3);
156+
bstRoot.insert(7);
157+
bstRoot.insert(8);
158+
bstRoot.insert(9);
159+
160+
// BinaryTreeNode<Integer> rootNode = bstRoot.search(2);
161+
// BinaryTreeNode<Integer> rootNodeLeftSubTree = rootNode.getLeftSubTree();
162+
// BinaryTreeNode<Integer> rootNodeRightSubTree = rootNode.getRightSubTree();
163+
// BinaryTreeNode<Integer> rootNodeRightSubTreeLeftSubTree = rootNodeRightSubTree.getLeftSubTree();
164+
//
165+
// assertThat(rootNode.getData()).isEqualTo(2);
166+
// assertThat(rootNodeLeftSubTree.getData()).isEqualTo(1);
167+
// assertThat(rootNodeRightSubTree.getData()).isEqualTo(8);
168+
// assertThat(rootNodeRightSubTreeLeftSubTree.getData()).isEqualTo(5);
169+
// assertThat(rootNodeRightSubTree.getRightSubTree().getData()).isEqualTo(9);
170+
// assertThat(rootNodeRightSubTreeLeftSubTree.getLeftSubTree().getData()).isEqualTo(3);
171+
// assertThat(rootNodeRightSubTreeLeftSubTree.getRightSubTree().getData()).isEqualTo(7);
172+
173+
assertThat(bstRoot.search(2).getData()).isEqualTo(bstRoot.remove(2).getData());
174+
assertThat(bstRoot.search(7).getData()).isEqualTo(bstRoot.remove(7).getData());
175+
assertThat(bstRoot.search(8).getData()).isEqualTo(bstRoot.remove(8).getData());
176+
assertThat(bstRoot.search(5).getData()).isEqualTo(bstRoot.remove(5).getData());
177+
}
178+
179+
@Test
180+
@DisplayName("AVL_트리_제거_테스트2")
181+
void AVL_트리_제거_테스트2() {
182+
BinarySearchTreeNode<Integer> bstRoot = new AVLTreeNode<>(1, (Comparator.comparingInt(o -> o)));
183+
184+
bstRoot.insert(3);
185+
bstRoot.insert(4);
186+
bstRoot.insert(5);
187+
bstRoot.insert(7);
188+
bstRoot.insert(8);
189+
bstRoot.insert(9);
190+
191+
// BinaryTreeNode<Integer> rootNode = bstRoot.search(3);
192+
// BinaryTreeNode<Integer> rootNodeLeftSubTree = rootNode.getLeftSubTree();
193+
// BinaryTreeNode<Integer> rootNodeRightSubTree = rootNode.getRightSubTree();
194+
//
195+
// assertThat(rootNode.getData()).isEqualTo(3);
196+
// assertThat(rootNodeLeftSubTree.getData()).isEqualTo(1);
197+
// assertThat(rootNodeRightSubTree.getData()).isEqualTo(7);
198+
// assertThat(rootNodeRightSubTree.getLeftSubTree().getData()).isEqualTo(5);
199+
// assertThat(rootNodeRightSubTree.getRightSubTree().getData()).isEqualTo(8);
200+
201+
assertThat(bstRoot.search(1).getData()).isEqualTo(bstRoot.remove(1).getData());
202+
assertThat(bstRoot.search(3).getData()).isEqualTo(bstRoot.remove(3).getData());
203+
assertThat(bstRoot.search(5).getData()).isEqualTo(bstRoot.remove(5).getData());
204+
assertThat(bstRoot.search(4).getData()).isEqualTo(bstRoot.remove(4).getData());
205+
assertThat(bstRoot.search(7).getData()).isEqualTo(bstRoot.remove(7).getData());
206+
assertThat(bstRoot.search(9).getData()).isEqualTo(bstRoot.remove(9).getData());
207+
assertThat(bstRoot.search(8).getData()).isEqualTo(bstRoot.remove(8).getData());
208+
}
107209
}

0 commit comments

Comments
 (0)