Transcript บทที่ 7 ทรี

บทที ่ 7 ทรี (Tree)
1
บทที่ 7 ทรี (Tree)
•
•
•
•
•
•
•
•
•
•
รูจ้ กั กับทรี (Tree)
รูจ้ กั กับไบนารีทรี (Binary Tree)
การสร้างและการจัดการไบนารีทรี
การจัดการข้อมูลในไบนารีทรี
รูจ้ กั กับ AVL Tree
รูจ้ กั กับทรีสมดุลแบบ 2-3 Trees
รูจ้ กั กับทรีสมดุลแบบ 2-3-4 Trees
รูจ้ กั กับ red-black Tree
รูจ้ กั กับ B-Tree
สรุปเนื้อหาบทที่ 7
2
รูจ้ กั กับทรี (Tree)
• การพัฒนารูปแบบโครงสร้างทีไ่ ม่เป็ นเชิงเส้น (NonLinear) เป็ นการพัฒนาในรูแบบของ
ทรี (Trees)
• การพัฒนาโครงสร้างในรูปแบบของทรีเหมือนการการเขียนผังโครงสร้างขององค์กรทีม่ ี
ความสัมพันธ์ภายในโครงสร้างทีเ่ ป็ นแบบลาดับชัน้ (Hierarchical) คือมีผบู้ ริหารลาดับสูง
และลดลัน้ ลงไปจนถึงลาดับล่างสุดและมีความสัมพันธ์กนั ในสายการทางาน
3
รูจ้ กั กับทรี (Tree)
คุณสมบัติเฉพาะของทรี (Terminology of Tree)
• ข้อมูลในทรีทุกแบบจะมีโครงสร้างแบบลาดับชัน้ (Hierarchical)
• ข้อมูลภายในทรีมคี วามสัมพันธ์ระหว่างข้อมูลเป็ นแบบแม่กบั ลูก (Parent-child)
• ภายในความสัมพันธ์แม่กบั ลูกนี้จะถูกเชื่อมด้วยเส้นความสัมพันธ์ (Edge) ระหว่างโหนดแม่
กับโหนดลูก
4
รูจ้ กั กับทรี (Tree)
คุณสมบัติเฉพาะของทรี (Terminology of Tree)
อธิบายโครงสร้างทรี
โหนดแม่(Parent Node) คือ โหนดทีอ่ ยูใ่ นลาดับบนของอีกโหนดหนึ่ง เมือ่ พิจารณา
โครงสร้างทรี ตาแหน่งของโหนด A อยูใ่ นตาแหน่งบนของโหนด B
ดังนัน้ เรียกโหนด A ว่า โหนดแม่ของโหนด B
โหนดลูก(Child Node) คือ โหนดที่อ ยู่ ใ นล าดับ ล่ า งของอีก โหนดหนึ่ ง เมื่อ พิจ ารณา
โครงสร้างทรี โหนด B อยูใ่ นตาแหน่งด้านล่างของโหนด A ดังนัน้
เรียกโหนด B ว่า โหนดลูกของโหนด A
โหนดพี่น้อง
คือ โหนดที่อยู่ใ นระดับ เดียวกัน เมื่อพิจารณาจากโครงสร้า งทรี
โหนด B และ C
(Sibling Node)
อยูใ่ นระดับเดียวกัน ดังนัน้ เรียกโหนด B และ C ว่า โหนดพี่น้อง
โหนดราก(Root Node) คือ โหนดที่มคี ุณสมบัติพเิ ศษ เป็ น โหนดที่ไม่มโี หนดแม่ และทุก
โหนดในทรีจ ะมี โ หนดนี้ เ ป็ นโหนดแม่ ดั ง นั ้น เมื่ อ พิ จ ารณา
โครงสร้างทรี เรียกโหนด A ว่า โหนดราก
โหนดใบ(Leaf Node)
คือ โหนดที่อ ยู่ใ นต าแหน่ ง ล่ า งสุด ของทรี ดัง นั น้ เมื่อ พิจ ารณา
โครงสร้างทรี จะเรียกโหนด C, D, E และ F ว่า โหนดใบ
5
รูจ้ กั กับทรี (Tree)
คุณสมบัติเฉพาะของทรี (Terminology of Tree)
บรรพบุรษุ (Ancestor)
สืบทอด(Descendant)
ทรีย่อย(Subtree)
เมือ่ พิจารณาจากโครงสร้างทรีเรียกความสัมพันธ์ระหว่างโหนด A, B
และ D ว่า โหนด A, B เป็ นบรรพบุรษุ ของโหนด D
ความสัมพันธ์ระหว่างแม่กบั ลูกมีคุณสมบัติของการสืบทอด ดั งนัน้
เมือ่ พิจารณาจากโครงสร้างทรีโหนด D ได้สบื ทอดจากโหนด A และ
โหนด B
ทรียอ่ ยคือโหนดทีอ่ ยูใ่ นตาแหน่งสืบทอดของโหนดทีเ่ ป็ นราก เมือ่
พิจารณาจากโครงสร้าง ทรี โหนด A มีทรียอ่ ย คือ B, C, D, E, และ
F ดังแสดงทรียอ่ ย
6
รูจ้ กั กับไบนารีทรี (Binary Tree)
• โหนดแม่ (R) หนึ่งโหนดจะมีลกู ได้ไม่เกิน 2 โหนด และเรียกโหนดลูกเหล่านัน้ ว่า ทรีย่อย
(Subtrees)
• โหนดลูกทีอ่ ยูใ่ นตาแหน่งทางซ้ายของโหนดแม่จะเรียกว่า ทรีย่อยซ้าย (Left subtrees :
TL) เป็ นกลุ่มข้อมูลทีม่ คี า่ น้อยกว่าโหนดแม่
• โหนดลูกทีอ่ ยูใ่ นตาแหน่งทางขวาของโหนดแม่ เรียกว่าทรีย่อยขวา (Right subtrees :
TR) เป็ นกลุ่มข้อมูลทีม่ คี า่ มากกว่าโหนดแม่
7
รูจ้ กั กับไบนารีทรี (Binary Tree)
คุณสมบัติของไบนารีทรี
• ความสูงของทรี (Height of Trees)
o ความสูงของทรี หมายถึงจานวนโหนดทีม่ คี วามยาวจากโหนดรากถึงโหนดทีเ่ ป็ นใบ
o แทนความสูงของทรีดว้ ยสัญญาลักษณ์ h
h=3
h=5
h=7
8
รูจ้ กั กับไบนารีทรี (Binary Tree)
คุณสมบัติของไบนารีทรี
• คุณสมบัติไบนารีทรีเต็ม (Full Binary Tree)
o ถ้าทรีวา่ งจะเป็ นไบนารีทรีเต็มคือความสูงของทรีมคี า่ เท่ากับศูนย์ (h = 0)
o ถ้าทรีไม่วา่ งคือ h>0 และทีต่ าแหน่งความสูง h–1 มีโหนดครบทุกโหนดจึงจะเป็ น
ไบนารีทรีเต็ม
• คุณสมบัติแบบสมบูรณ์ (Complete Binary Tree)
o ทีต่ าแหน่งความสูง h-1 จะต้องมีโหนดเต็มทุกตาแหน่ง
o การเพิม่ โหนดเข้าไปในทรีทต่ี าแหน่งความสูง h ต้องเพิม่ โหนดในทรีจากซ้ายไปขวา
9
รูจ้ กั กับไบนารีทรี (Binary Tree)
คุณสมบัติของไบนารีทรี
• ความสูงสมดุล (Height Balanced)
• ความสูงสมดุล (Height Balanced) อาจจะเรียกว่า ทรีแบบสมดุล
• พิจารณาทรีแบบสมดุลคือ ความสูงของโหนดย่อยทางขวาเมื่อเปรียบเทียบกับความสูง
ของโหนดย่อยทางซ้ายจะมีความแตกต่างกันของความสูงไม่เกิน 1
ทรีความสูงสมดุล
ทรีความไม่สงู สมดุล
ทรีความไม่สงู สมดุล
10
การสร้างและการจัดการไบนารีทรี
• การจัดการโหนดในไบนารีทรีจะประกอบไปด้วยขัน้ ตอน การเพิม่ การลบโหนด และ
การเข้าถึงข้อมูลในไบนารีทรีหรือเรียกว่าการท่องเข้าไปในไบนารีทรี
• การท่องเข้าไปในไบนารีท รีมลี กั ษณะเหมือนกับการท่องเข้าไปในลิงค์ลิสต์ โดยจะเริม่
ท่องเข้าไปทรีจากโหนดราก และท่องเข้าไปในไบนารีทรีทลี ะโหนดแบบลาดับจนถึงโหนด
สุดท้ายในไบนารีทรี
• ขันตอนวิ
้
ธใี นการสร้างไบนารีทรี (ADT Binary Tree)
1. Create an empty binary tree.(สร้างไบนารีทรีวา่ งเปล่า)
2. Create a one-node binary tree, given an item.(สร้า งไบนารีท รีห นึ่ ง โหนด และเพิ่ม เข้า ไปใน
ไบนารีทรี)
3. Remove all node from a binary tree, leaving it empty.(ลบโหนดทัง้ หมดจากไบนารีท รี ท าให้
ไบนารีทรีวา่ งเปล่า)
4. whether a binary tree is empty.(สนใจไบนารีทรีทว่ี า่ งเปล่า)
5. Determine what data is the binary tree’s root.(สนใจข้อมูลโหนดไหนเป็ นโหนดรากไบนารีทรี)
6. Set the data in the binary tree’s root.(กาหนดข้อมูลในไบนารีทรีให้เป็ นโหนดรากของไบนารีทรี)
11
การสร้างและการจัดการไบนารีทรี
• Pseudo code โครงสร้างไบนารีทรี
+createBinaryTree(in rootItem:TreeItemType,in leftTree:BTree,in rightTree:BTrees)
//สร้างไบนารีทรี ตาแหน่งโหนดรากคือ rootItem และ leftTree และ righttree คือทรียอ่ ยทางซ้ายและทางขวาตามลาดับ
+setRootItem(in newItem:TreeItemType)
//แทนข้อมูลในโหนดรากของไบนารีทรีดว้ ย newItem ในกรณีทรีไม่วา่ ง แต่ถา้ ทรีวา่ งให้สร้างโหนดรากด้วย newItem
+attachLeft(in newItem:TreeItemType) throws InterruptedException
//เพิม่ ข้อมูลลูกทางซ้ายของโหนดรากด้วย newItem ให้แจ้งการผิดพลาดเมื่อทรีเป็ นทรีวา่ งหรือมีลกู ทางซ้ายอยูแ่ ล้ว
+attachRight(in newItem:TreeItemType) throws InterruptedException
//เพิม่ ข้อมูลลูกทางขวาของโหนดรากด้วย newItem ให้แจ้งการผิดพลาดเมื่อทรีเป็ นทรีวา่ งหรือมีลกู ทางขวาอยูแ่ ล้ว
+attachLeftSubTree(in leftTree:BinaryTree) throws InteruptedException
//เพิม่ leftTree ในตาแหน่งทรียอ่ ยทางซ้ายของโหนดรากของไบนารีทรี ให้แจ้งการผิดพลาดเมื่อทรีเป็ นทรีว่างหรือทรียอ่ ย
ซ้ายมีอยูแ่ ล้ว
+attachRightTree(in rightTree:BinaryTree) throws InteruptedException
//เพิม่ leftTree ในตาแหน่งทรียอ่ ยทางขวาของโหนดรากของไบนารีทรี ให้แจ้งการผิดพลาดเมื่อทรีเป็ นทรีว่างหรือทรียอ่ ย
ขวามีอยูแ่ ล้ว
+detachLeftSubtree():Binarytree throws InteruptedException
//แยกและคืนค่าทรียอ่ ยทางซ้ายของโหนดราก ให้แจ้งการผิดพลาดถ้าเป็ นทรีวา่ ง
+detachRightSubtree():Binarytree throws InteruptedException
//แยกและคืนค่าทรียอ่ ยทางขวาของโหนดราก ให้แจ้งการผิดพลาดถ้าเป็ นทรีวา่ ง
12
การสร้างและการจัดการไบนารีทรี
ตัวอย่างที่ 7.1 สร้างไบนารีทรีจาก Pseudo codeไบนารีทรี
ทรีต้นแบบ
การสร้างไบนารีทรีจากทรีตน้ แบบ
13
การสร้างและการจัดการไบนารีทรี
การสร้างไบนารีทรีด้วยโครงสร้างอาร์เรย์
• ใช้อาร์เรย์ขนาด 2 มิตใิ นการเก็บข้อมูลโครงสร้างไบนารีทรี ในมิตทิ ่ี 1 มีขนาดเท่ากับ 3
เพือ่ เก็บข้อมูลโหนด, ตาแหน่งลูกทางซ้ายของโหนด และตาแหน่งลูกทางขวาของโหนด
ตัวอย่างที่ 7.2 สร้างไบนารีทรีดว้ ยโครงสร้างอาร์เรย์
Java
C
public class TreeNode{
private int item;
private int lChild;
private int rChild;
//คอนสตักเตอร์และเมธอดในการจัดการไบนารีทรี
}//end TreeNode
โดยที่
item
lChild
rChild
struct TreeNode{
int item;
int lChild;
int rChild;
};
//ฟงั ก์ชน
ั ในการจัดการไบนารีทรี
ทาหน้าทีเ่ ก็บข้อมูลโหนด
ทาหน้าทีเ่ ก็บตาแหน่งลูกทางซ้ายของโหนด
ทาหน้าทีเ่ ก็บตาแหน่งลูกทางขวงของโหนด
14
การสร้างและการจัดการไบนารีทรี
การสร้างไบนารีทรีด้วยโครงสร้างอาร์เรย์
ตัวอย่างที่ 7.3 การใช้งานไบนารีทรีโครงสร้างอาร์เรย์
Java
C
public class BinaryTreeArrayBased{
protected final int MAX_NODE=100;
TreeNode[] tree = new TreeNode[MAX_NODE];
protected int root;
protected int free;
//constructors and methods ในการตจัดการข้อมูลในไบนารทรี
}// end BinaryTreeArrayBased
โดยที่
MAX_NODE
tree
root
free
#include <TreeNode.h>
#define MAX_NODE 100
struct tree
TreeNode[MAX_NODE];
int root;
int free;
//function
ในการจัดการข้อมูลในไบนารี ทรี
เป็ นขนาดอาร์เรย์ทเ่ี ก็บข้อมูลได้มากทีส่ ดุ
เป็ นอาร์เรย์ทม่ี โี ครงสร้างแบบ TreeNode โดยแต่ละแถว
ข้อมูลสามารเก็บข้อมูลโหนด (item), ตาแหน่งลูกทางซ้าย
(lChild) และตาแหน่งลูกทางขวา (rChild)
ทาหน้าทีเ่ ก็บตาแหน่งของโหนดราก
ทาหน้าทีเ่ ก็บตาแหน่งว่างของอาร์เรย์ทย่ี งั ไม่เก็บข้อมูล
15
การสร้างและการจัดการไบนารีทรี
การสร้างไบนารีทรีด้วยโครงสร้างอาร์เรย์
ตัวอย่างที่ 7.4 ตัวอย่างโครงสร้างอาร์เรย์เก็บข้อมูลไบนารีทรี
16
การสร้างและการจัดการไบนารีทรี
การสร้างไบนารีทรีด้วยโครงสร้างลิงค์ลิสต์
Java
public class TreeNode{
private int item;
private TreeNode lChild;
private TreeNode rChild;
}
C
struct TreeNode{
int item;
struct TreeNode *lChild;
struct TreeNode *rChild;
};
17
การจัดการข้อมูลในไบนารีทรี
• ขันตอนพื
้
น้ ฐานในการจัดการข้อมูลในไบนารีทรี (Operation of the ADT Binary Tree)
1. Insert a new item into a binary tree. (เพิม่ ข้อมูลใหม่ในไบนารีทรี)
2. Delete the item with a given search key from a binary tree. (ลบข้อมูลที่ได้จากการค้นหา
ในไบนารีทรี)
3. Retrieve the item with a given search key from a binary tree.(นาข้อมูลทีไ่ ด้จากการค้นหา
ในไบนารีทรี)
4. Traverse the item in a binary tree in preorder,inorder,or postorder.(ท่องเข้าไปในไบนารีทรี
ด้วยหลักการ preorder, inorder หรือ postorder)
18
การจัดการข้อมูลในไบนารีทรี
• Pseudo code ขันตอนพื
้
น้ ฐานในการจัดการข้อมูลไบนารีทรี
+insert(in newItem:TreeItemType)
//เพิม่ newItem เข้าไปในไบนารีทรี ในตาแหน่งทีเ่ หมาะสมทีไ่ ด้จากการเปรียบเทียบโหนดทีม่ อี ยูใ่ นทรี
//กับ newItem
+delete(in searchKey:KeyType) throws InterruptedException
//ลบข้อมูลในไบนารีทรีทไ่ี ด้จากค้นหาข้อมูลทีเ่ ท่ากับข้อมูล searchKey แต่ถา้ ไม่เจอข้อมูลในทรีให้แจ้ง
//ความผิดพลาดในการลบข้อมูล
+retrieve(in searchKey:KeyType):TreeItemType
//คืนค่าข้อมูลในไบนารีทรีทม่ี ขี อ้ มูลเท่ากับข้อมูล searchKey ถ้าไม่เจอข้อมูลในไบนารีทรีให้สง่ ค่า null
//กลับคืน
19
การจัดการข้อมูลในไบนารีทรี
การค้นหาข้อมูลในไบนารีทรี
• การเพิม่ หรือการลบข้อมูลในไบนารีทรี จะต้องค้นหาตาแหน่งทีเ่ หมาะสมทีจ่ ะเพิม่ หรือลบ
ข้อมูลในไบนารีทรีก่อนเสมอ
ตัวอย่างที่ 7.5 Pseudo code การค้นหาข้อมูลในไบนารีทรี
1
2
3
4
5
6
7
8
9
10
+search(in bst:BinaryTree, in searchKey:KeyType)
if(bst is empty){
//ค้นหาข้อมูลไม่เจอ
}else if(searchKey == bst’s item){
//ค้นหาข้อมูลเจอ
}else if(searchkey < bst’s item){
search(Left subtree of bst, searchkey)
}else{
search(Right subTree of bst, searchkey)
}//end if
20
การจัดการข้อมูลในไบนารีทรี
การเพิ่มโหนดข้อมูลในไบนารีทรี
• การเพิม่ โหนดข้อมูลในไบนารีทรี จะเป็ นตาแหน่งใบในไบนารีทรีเท่านัน้
ตัวอย่างที่ 7.6 การเพิม่ โหนดข้อมูลในไบนารีทรี
เมือ่ ต้องการเพิม่ ข้อมูลโหนด “Fook” เข้าไปในไบนารีทรี
ไบนารีทรีตน้ แบบ
ไบนารีทรีหลังเพิม่ “Fook”
21
การจัดการข้อมูลในไบนารีทรี
การเพิ่มโหนดข้อมูลในไบนารีทรี
ตัวอย่างที่ 7.7 Pseudo code เพิม่ ข้อมูลในไบนารีทรี
1
2
3
4
5
6
7
8
9
10
+insertItem(in treeNode:TreeNode,in newItem:TreeItemType)
if(treeNode is null){
Create a new node and let treeNode reference it
Create a new node with newItem as the data portion
Set the references in the new node to null
}else if(newItem.getKey() < treeNode.getItem().getKey())
treeNode.setLeft(insertItem(treeNode.getLeft(), newItem)
}else{
treeNode.setRight(insertItem(treeNode.getRight(), newItem)
}
22
การจัดการข้อมูลในไบนารีทรี
การท่องเข้าไปในไบนารีทรี
• การท่องเข้าไปในไบนารีทรีจะใช้หลักการของการเรียกซ้า (Recursive) เพือ่ เข้าถึงทุก
โหนดในไบนารีทรี
• ถ้าไบนารีทรีเป็ นทรีวา่ งเปล่าจะไม่มกี ารตอบสนองอะไร แต่ถา้ ไบนารีทรีไม่วา่ งเปล่าจะเริม่
ท่องเข้าไปในไบนารีทรีจากตาแหน่งของโหนดราก คือตาแหน่งของ R หลังจากนัน้ จะท่อง
เข้าในทรียอ่ ยซ้ายและทรียอ้ ยขวาคือ TL และ TR จนถึงโหนดสุดท้ายในไบนารีทรี
23
การจัดการข้อมูลในไบนารีทรี
การท่องเข้าไปในไบนารีทรี
o การท่องเข้าไปในไบนารีทรีแบบ Preorder
+preorder(in binTree:BinaryTree)
if(binTree is not empty){
Display the data in the root of binTree
preorder(Left subtree of binTree’s root)
preorder(Right subtee of binTree’s root)
}
• ตาแหน่งการท่องเข้าไปในทรีแบบ Preorder จะท่องจากโหนดตาแหน่งตรงกลาง
แล้วลูกทรีย่อยทางซ้าย และกลับมายัง ลูกทรีย่อยทางขวา โดยทาจนกระทัง้ ถึง
โหนดสุดท้ายในทรี
ผลการท่องเข้าไปในไบนารีทรีดงั นี้คอื 70, 30, 5, 30,
40, 60, และ 80
24
การจัดการข้อมูลในไบนารีทรี
การท่องเข้าไปในไบนารีทรี
o การท่องเข้าไปในไบนารีทรีแบบ Inorder
+inorder(in binTree:BinaryTree)
if(binTree is not empty){
inorder(Left subtree of binTree’s root)
Display the data in the root of binTree
inorder(Right subtee of binTree’s root)
}
• ท่องเข้าไปในไบนารีทรีแบบ Inorder เริม่ จากตรวจสอบว่าทรีวา่ งหรือไม่ถา้ ทรีไม่วา่ งจะ
ท่องเข้าไปยังโหนดทางซ้ายสุดของทรีก่อน แล้วนาข้อมูลในตาแหน่งทางซ้ายสุดนี้ไป
แสดงผล
• ต่อไปจะท่องกลับไปยังโหนดตรงกลางคือโหนดแม่พร้อมทัง้ นาข้อมูลไปแสดงผล แล้วจึง
ท่องเข้าไปยังโหนดย่อยทางขวาของโหนดแม่
ผลการท่องเข้าไปในไบนารีดงั นี้คอื 5, 30, 40, 50,
60, 70 และ 80
25
การจัดการข้อมูลในไบนารีทรี
การท่องเข้าไปในไบนารีทรี
o การท่องเข้าไปในไบนารีทรีแบบ Postorder
+postorder(in binTree:BinaryTree)
if(binTree is not empty){
postorder(Left subtree of binTree’s root)
postorder(Right subtee of binTree’s root)
Display the data in the root of binTree
}
• เริม่ จากตรวจสอบว่าทรีว่างหรือไม่ถา้ ทรีไม่ว่างจะท่องเข้าไปยังโหนดทางซ้ายสุดของทรี แล้วนา
ข้อมูลไปแสดงผล ต่อไปจะไปโหนดทรีย่อยทางขวาของโหนดแม่และนาข้อมูลออกไปแสดงผล
แล้วจึงไปยังโหนดแม่พร้อมทัง้ แสดงผลโหนดแม่
ผลการท่องเข้าไปในไบนารีดงั นี้คอื 5, 40, 60, 50, 30,
80 และ 70
26
การจัดการข้อมูลในไบนารีทรี
การลบโหนดข้อมูลในไบนารีทรี
o กรณี โหนดที่ต้องการลบอยู่ในตาแหน่ งของโหนดใบ
• การลบโหนดในกรณีน้เี ป็ นกรณีทง่ี า่ ยทีส่ ุดในการลบโหนด
• กาหนดให้โหนดแม่ทอ่ี า้ งอิงไปยังโหนดใบทีเ่ ป็ นโหนดลูกและเป็ นโหนดทีต่ อ้ งการลบ
มีคา่ เท่ากับ null (ยกเลิกการอ้างอิงไปยังโหนดใบ)
27
การจัดการข้อมูลในไบนารีทรี
การลบโหนดข้อมูลในไบนารีทรี
o กรณี โหนดที่ต้องการลบมีโหนดลูกอยู่หนึ่ งโหนด
1.
กรณี โหนดลูกอยู่ด้านซ้ายของโหนดที่ต้องการลบ ตัวอย่างเช่น เมือ่ ต้องการลบ
โหนด N และมีโหนด L เป็ นโหนดลูกทางซ้ายของโหนด N เพียงโหนดเดียว ในกรณีน้ี
จะใช้หลักการเลื่อน ด้วยการเลือกโหนด L ขึน้ ไปแทนทีโ่ หนด N
2. กรณี โหนดลูกอยู่ด้านขวาของโหนดที่ต้องการลบ ตัวอย่างเช่น เมือ่ ต้องการลบ
โหนด N และมีโหนด O เป็ นโหนดลูกทางขาวของโหนด N ในกรณีน้ใี ช้หลักการ
เลื่อน โดยเลื่อนโหนด O ขึน้ แทนทีโ่ หนด N
28
การจัดการข้อมูลในไบนารีทรี
การลบโหนดข้อมูลในไบนารีทรี
o กรณี โหนดที่ต้องการลบมีโหนดลูกอยู่ 2 โหนด
• การลบโหนดในกรณี น้ี ต้อ งหาโหนดลู ก มาแทนที่โ หนดที่ต้อ งการลบด้ว ยหลัก การ
Inorder successor โดยการเลือกโหนดใบในตาแหน่ งทางซ้ายสุดของกลุ่มทรีย่อย
ทางขวาของโหนดทีต่ อ้ งการลบมาสลับข้อมูลกับข้อมูลทีต่ อ้ งการลบ
• ตัวอย่างเมือ่ ต้องการลบโหนด “Jim”
29
การจัดการข้อมูลในไบนารีทรี
การลบโหนดข้อมูลในไบนารีทรี
o กรณี โหนดที่ต้องการลบมีโหนดลูกอยู่ 2 โหนด
• หลักการ Preorder successor เป็ นการหาโหนดใบในตาแหน่งทางขวาสุดของกลุ่มทรี
ย่อยทางซ้ายของโหนดทีต่ อ้ งการลบมาสลับข้อมูลกับโหนดทีต่ อ้ งการลบ
• ตัวอย่างการหาตาแหน่งด้วยหลักการ Preorder successor เมือ่ ต้องการลบโหนด “Jim”
30
การจัดการข้อมูลในไบนารีทรี
การลบโหนดข้อมูลในไบนารีทรี
ตัวอย่างที่ 7.8 Pseudo code ลบข้อมูลในไบนารีทรี
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
+deleteNode(in treeNode:TreeNode):TreeNode
if(treeNode is a leaf) {
Remove treeNode from the tree.
}
else if(treeNode has only one child c){
if(c was a left child of its parent p){
Make c the left child of p
}else{
Make c the right child of p
}else{ //treeNode has two children
Find the item contained in treeNode’s inorder successor.
Copy the item into treeNode.
Technique for a left or a node with one child.
}
return reference to root node of resulting tree
31
การจัดการข้อมูลในไบนารีทรี
การลบโหนดข้อมูลในไบนารีทรี
ตัวอย่างที่ 7.9 แสดงการเพิม่ และลบโหนดในไบนารีทรี
32
รูจ้ กั กับ AVL Tree
• AVL Tree มาจากชือ่ ของผูค้ ดิ ค้นคือ Adel’son, Vel’skii และ Landis
• AVL Tree เป็ นอัลกอริทมึ สาหรับจัดการข้อมูลภายในไบนารีทรีให้มคี วามสมดุล
• ไบนารี ท รีสมดุล (Height Balanced) หมายถึง ความสูง ของทรีย่อยด้านซ้า ยและ
ด้านขวามีความสูงทีแ่ ตกต่างกันไม่เกิน 1
• หลักการทาไบนารีทรีให้สมดุลด้วย AVL Tree จะใช้หลักการของ การหมุน (Rotate)
33
รูจ้ กั กับ AVL Tree
• การปรับทรีให้สมดุลด้วย AVL Tree จะใช้ค่าความแตกต่าง (balance factor) ระหว่างความ
สูงทรียอ่ ยด้ายขวา (TR) กับความสูงทรียอ่ ยด้ายซ้าย (TL) ดังนี้
balance factor = h(TR) - h(TL)
34
การสร้าง AVL Tree
Java
public class TreeNode{
private int item;
private TreeNode lChild;
private TreeNode rChild;
private int balFactor;
}//end TreeNode
//ข้อมูลในทรี
//อ้างอิงลูกทางซ้าย
//อ้างอิงลูกทางขวา
//ความแตกต่างความสูง
C
struct TreeNode{
int item;
//ข้อมูลในทรี
struct TreeNode *lChild; //อ้างอิงลูกทางซ้าย
struct TreeNode *rChild; //อ้างอิงลูกทางขวา
int balFactor;
//ความแตกต่างความสูง
};
35
การเพิม่ ข้อมูลใน AVL Tree
• เมือ่ เพิม่ ข้อมูลเข้าไปในทรีแล้วทาให้โครงสร้างของทรีไม่สมดุล จะต้องปรับโครงสร้างทรีให้
สมดุลด้วยการหมุนโหนดข้อมูลภายในทรี
การปรับไบนารีทรีให้สมดุลด้วยการหมุน 1 ครัง้ ใน AVL Tree
• จะหมุนจากกลุ่มทรีย่อยทีม่ คี วามสูงมากกว่าไปหาโหนดทรีย่อยทีม่ คี วามสูงน้อยกว่า
เช่น ถ้าลูกทางขวามีความสูง (h) เท่ากับ 3 และลูกทางซ้ายมีความสูงเท่ากับ 1 การ
หมุนจะหมุนจากด้านขวาไปหาด้านซ้ายเพือ่ ปรับให้ไบนารีทรีสมดุล
36
การเพิม่ ข้อมูลใน AVL Tree
การปรับไบนารีทรีให้สมดุล
1. ให้หมุนข้อมูลในรอบทีห่ นึ่ง โดยกาหนดให้โหนด 20 เป็ นจุดแรกในการหมุน ซึ่งเลือกโหนด
20 เนื่องจากเป็ นตาแหน่งของโหนดลูกทีท่ าให้ทรีไม่สมดุล ดังแสดงผลการหมุนข้อมูลรอบที่
หนึ่งในรูป (b)
2. แต่เมือ่ พิจารณาทรีหลังการหมุนรอบแรกแล้ว พบว่า ทรียงั ไม่สมดุล ต้องปรับการหมุนใน
รอบที่ 2 ด้วยการกาหนดให้โหนด 40 เป็ นจุดถัดไป ซึง่ เป็ นตาแหน่งทีท่ รีไม่สมดุล ด้วยการ
เปลีย่ น 30 เป็ นโหนดแม่แทนโหนด 40 พร้อมกับย้าย 35 เป็ นลูกทางขวาของโหนด 30
ดังแสดงผลการหมุนไบนารีทรีในรอบทีส่ องในรูป (d)
37
การเพิม่ ข้อมูลใน AVL Tree
การปรับไบนารีทรีให้สมดุล
• การพิจารณาว่าการปรับทรีให้สมดุลด้วยหลักการหมุนควรจะหมุน 1 ครัง้ หรือหมุน 2 ครัง้ นัน้
พิจารณาจากโหนดทีเ่ พิม่ เข้าไปในไบนารืทรีแล้วทาให้ไบนารีทรีไม่สมดุล
o การหมุน 1 ครัง้ จะทาเมือ่ เพิม่ ข้อมูลเข้าไปในทรียอ่ ยด้านเดียวกับด้านทีเ่ พิม่ แล้วทาให้ท
รีไม่สมดุล เช่นเพิม่ 60 เข้าไปแล้วทาให้ทรีไม่สมดุล จะต้องหมุน 1 ครัง้ เนื่องจาก 60 ถูก
เพิม่ เข้าไปในตาแหน่งทางขวาและโหนด 55 เป็ นลูกทางขวา ดังนัน้ จะหมุน 1 ครัง้ เพือ่
ปรับทรีให้สมดุล
38
การเพิม่ ข้อมูลใน AVL Tree
การปรับไบนารีทรีให้สมดุล
o การหมุน 2 ครัง้ เมื่อเพิม่ ข้อมูลเข้าไปในทรีย่อยด้านตรงข้ามกับด้านทีเ่ พิม่ เช่นเพิม่
53 เข้า ไปทรีแ ล้ว ท าให้ท รีไ ม่ส มดุ ล ต าแหน่ ง ในการเพิ่ม 53 เข้า ไปในต าแหน่ ง ลูก
ทางซ้ายของโหนด 55 แต่โหนด 55 เป็ นโหนดลูกทางขวา ดังนัน้ จะต้องหมุน 2 ครัง้
เพือ่ ปรับทรีให้สมดุล
หมุนครัง้ ที่ 1
หมุนครัง้ ที่ 2
39
การเพิม่ ข้อมูลใน AVL Tree
ตัวอย่างที่ 7.10 โค้ดรหัสเทียมการเพิม่ ใน AVL Tree
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
+insertNodeAVL(in root:TreeNode,in newItem:TreeItemType):TreeNode
if(root is empty){
create new root with newItem
else root = insertAVL(root, newItem);
retrun root;
+insertAVL(in Node:TreeNode,in newItem:TreeItemType):TreeNode
if(Node is empty){
create new Node with newItem in binaryTree
if(newItem < Node.item){
Node.left = insertAVL(Node.left, newItem);
if(height(Node.left)-height(Node.right)>1){
if(insertion occurred on left side)
Node = SingleRotateLChild(Node);
else Node = DoubleRotateLChild(Node);
}
}else{
Node.right = insertAVL(Node.right, newItem);
if(height(Node.right)-height(Node.left)>1){
if(insertion occurred on right side)
AVLTree = SingleRotateRChild(Node);
else AVLTree = DoubleRotateRChild(Node);
}
}
return Node
40
การลบข้อมูลใน AVL Tree
• หลักการลบโหนดใน AVL Tree สามารถใช้หลักการลบโหนดของไบนารีทรีมาโหนดใน
AVL Tree ได้ โดยเริม่ จากค้นหาตาแหน่ ง โหนดทีต่ อ้ งการลบ และลบโหนดในตาแหน่ ง
ต่างๆ ดังนี้
1. โหนดที่ ต้องการลบอยู่ในตาแหน่ งใบ สามารถลบโหนดในตาแหน่ งใบด้วยการ
เปลีย่ นการเชือ่ มโยงไปยังโหนดลูกให้มคี า่ เท่ากับ null
2. โหนดที่ต้องการลบมีลกู หนึ่ งโหนด ให้แทนทีโ่ หนดทีต่ อ้ งการลบด้วยโหนดลูก
3. โหนดที่ต้องการลบมีลูกสองโหนด ให้สลับข้อมูลโหนดทีต่ อ้ งการลบด้วยการหา
ตาแหน่งโหนดด้วยวิธ ี inorder successor เพือ่ หาข้อมูลในตาแหน่งใบมาสลับกลับ
ข้อมูลทีต่ อ้ งการลบ แล้วจึงลบโหนดทีต่ อ้ งการลบในตาแหน่งใบ
• เมือ่ ลบโหนดใน AVL Tree แล้วทาให้ทรีไม่สมดุล สามารถใช้วธิ ปี รับโหนดลูกในทรีดว้ ย
หลักการหมุน 1 ครัง้ หรือหมุน 2 ครัง้ เพือ่ ปรับทรีให้สมดุล
41
การลบข้อมูลใน AVL Tree
การปรับไบนารีทรีให้สมดุลด้วยการหมุน 1 ครัง้ หลังจากลบโหนด
ใน AVL Tree
• ปรับทรีให้สมดุลด้วยการหมุน 1 ครัง้ จะพิจารณาจากตาแหน่ ง โหนดลูกของโหนดที่ไม่
สมดุล ว่ามีความต่างของความสูงโหนดทางซ้ายและความสูงทางขวามีค่าเป็ น 1 หรือไม่
ถ้ามีคา่ เป็ น 1 ให้ปรับทรีดว้ ยการหมุน 1 ครัง้
• การหมุน 1 ครัง้ ยังมีอกี กรณีหนึ่งคือ เมือ่ ลบโหนดแล้วโหนดลูกมีความสูงต่างเท่ากับ 0
ในกรณีน้ใี ช้วธิ กี ารหมุน 1 ครัง้ เช่นเดียวกัน
42
การลบข้อมูลใน AVL Tree
การปรับไบนารีทรีให้สมดุลด้วยการหมุน 2 ครัง้ หลังจากลบโหนด
ใน AVL Tree
• พิจารณาปรับทรีให้สมดุลด้วยการหมุน 2 ครัง้ จะพิจารณาตาแหน่งโหนดลูกของโหนดที่
ไม่สมดุล ว่ามีความสูงต่างเท่ากับ -1 หรือไม่ ถ้าเป็ นค่า -1 จะหมุนในกลุ่มทรียอ่ ยทีม่ ี
ความสูงต่าง -1 ก่อนหนึ่งครัง้ แล้วปรับโครงสร้างด้วยการหมุนครัง้ ที่ 2 ไปยังทิศทางของ
โหนดทีม่ คี วามสูงต่างเท่ากับ 2 หรือ -2
43
การลบข้อมูลใน AVL Tree
ตัวอย่างที่ 7.12 โค้ดรหัสเทียมการลบข้อมูลใน AVL Tree
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
+deleteNodeAVL(in subRoot:TreeNode,in key:TreeItemType):Boolean
if (subRoot is a leaf)
if (key is equal subRoot’s key)
delete key from subRoot and return true
else not found key detete and return false
else //compare subRoot’s key with key delete
if (subRoot’s key < key) //check right subTree
deleteNodeAVL(subRoot.right, key)
else if (subRoot’s key > key) //check left subTree
deleteNodeAVL(subRoot.left, key)
else //subRoot’s key = key for delete node
if (zero children)
remove key from the tree
else if (one children)
contained children to delete node
else //two children
find the item contained by inordersuccessor and delete node in leaf
if (subRoot’s balance factor equals 2 or -2)
if (subRoot’s childen balance factor equal 1 or 0)
one rotating subRoot
else //subRoot’s childen balance factor equal -1
two rotating subRoot
else tree balance return true
44
รูจ้ กั กับ AVL Tree
ตัวอย่างที่ 7.13 แสดงการเพิม่ และลบโหนดใน AVL Tree
45
รูจ้ กั กับทรีสมดุลแบบ 2-3 Trees
• 2-3 Trees หมายถึงโหนดแม่จะมีจานวนโหนดลูกได้ 2 หรือ 3 โหนด
• การเรียกโหนดทีม่ โี หนดลูกใน 2-3 Trees จะเรียกตามจานวนข้อมูลทีอ่ ยูใ่ นโหนด
o โหนดทีม่ โี หนดลูก 2 โหนด จะเรียกว่า 2-nodes
o โหนดทีม่ โี หนดลูก 3 โหนด จะเรียกว่า 3-nodes
• 2-3 Trees ไม่ใช่ไบนารีทรีเนื่องจากมีโหนดลูกได้ 3 โหนด
46
รูจ้ กั กับทรีสมดุลแบบ 2-3 Trees
ถ้ากาหนดให้ T เป็ น 2-3 Trees ทีม่ คี วามสูง h จะพิจารณาว่า T จะเป็ น 2-3 Trees เมือ่
1. T เป็ นทรีวา่ ง (2-3 Trees มีความสูง h=0)
2. T มีรปู แบบโครงสร้างดังนี้
โดยที่
 R คือโหนดทีป่ ระกอบด้วยข้อมูลภายในโหนดหนึ่งข้อมูล และมีทรียอ่ ยคือ TL และ TR
 ข้อมูลภายในโหนด R จะมีคา่ มากกว่าข้อมูลทางซ้ายคือ TL
 ข้อมูลภายใน R จะมีคา่ น้อยกว่าข้อมูลทางขวาคือ TR
ดังนัน้ สรุปได้วา่ TL < R < TR
47
รูจ้ กั กับทรีสมดุลแบบ 2-3 Trees
3. T มีรปู แบบโครงสร้างดังนี้
โดยที่
 R คือโหนดทีป่ ระกอบด้วยข้อมูลภายในโหนดสองข้อมูล และมีทรียอ่ ยคือTL, TM และ TR
 ข้อมูลภายในโหนด R จะมีคา่ มากกว่าข้อมูลทางซ้ายคือ TL
 ข้อมูลตรงกลางคือ TM จะเป็ นข้อมูลทีม่ ากกว่า TL แต่น้อยกว่า TR
 ข้อมูลทางขวาคือ TR จะมีขอ้ มูลมากกกว่า R
ดังนัน้ สรุปได้วา่ TL < TM < TR
48
รูจ้ กั กับทรีสมดุลแบบ 2-3 Trees
กฎของ 2-3 Trees
1. โหนดข้อมูลจะมีขอ้ มูลภายในโหนดได้ 1 หรือ 2 ค่า
2. ถ้า โหนดแม่ม ีโ หนดลูก 2
โหนด ข้อ มูล ในโหนดแม่จ ะมีข้อ มูล ได้เ พีย งหนึ่ ง ข้อ มูล
ตัวอย่างเช่น โหนดแม่มคี ่าเท่ากับ S ข้อมูลทางซ้ายจะเป็ นข้อมูลทีน่ ้อยกว่า S และข้อมูล
ทางขวาเป็ นข้อมูลทีม่ ากกว่า S
49
รูจ้ กั กับทรีสมดุลแบบ 2-3 Trees
กฎของ 2-3 Trees
3. ถ้าโหนดแม่มโี หนดลูก 3 โหนด ข้อมูลในโหนดแม่จะต้องมีขอ้ มูลภายในโหนด 2 ค่า คือ S
และ L โดยที่
 ข้อมูลโหนดลูกทางซ้ายจะมีขอ้ มูลน้อยกว่า S
 ข้อมูลโหนดตรงกลางจะมีขอ้ มูลมากกว่า S และน้อยกว่า L
 ข้อมูลโหนดลูกทางขวาจะมีขอ้ มูลมากกว่า L
50
โครงสร้างข้อมูล 2-3 Trees
• โครงสร้างข้อมูล 2-3 Tree จะประกอบด้วยส่วนข้อมูลทีเ่ ก็บข้อมูลทีน่ ้อยทีส่ ุดในโหนด,
ข้อมูลทีม่ ากทีส่ ุดในโหนด และส่วนเชือ่ มโยงไปยังทรียอ่ ย
• ส่วนเชือ่ มโยงไปยังทรียอ่ ยจะประกอบด้วยส่วนเชือ่ มโยงทรียอ่ ยทางซ้าย, ส่วนเชือ่ มโยง
ทรียอ่ ยตรงกลาง และส่วนเชือ่ มโยงทรียอ่ ยทางขวา
ตัวอย่างที่ 7.14 อัลกอริทมึ โครงสร้าง 2-3 Trees
1
2
3
4
5
6
7
8
Java
public class 2-3TreeNode{
private int smallItem;
private int largeItem;
private 2-3TreeNode lChild;
private 2-3TreeNode midChild;
private 2-3TreeNode rChild;
//คอนสตรักเตอร์และเมธอดทีใ่ ช้ในการจัดการ
}
C
2-3 Trees
struct 2-3TreeNode{
int smallItem;
int largeItem;
struct 2-3TreeNode *LChild;
struct 2-3TreeNode *midChild;
struct 2-3TreeNode *rChild;
//ฟงั ก์ชน
ั ทีใ่ ช้ในการจัดการ 2-3 Trees
};
51
การท่องเข้าไปใน 2-3 Trees
• การท่องเข้าไปใน 2-3 Tree จะใช้การท่องเข้าไปในทรีแบบ Inorder
ตัวอย่างที่ 7.15 โค้ดรหัสเทียมการท่องเข้าไปใน 2-3 Trees แบบ Inorder
1
2
3
4
5
6
7
8
9
10
11
12
13
14
+inorder(in ttTree:2-3TreeNode)
if(ttTree’s root R is a leaf)}
visit the data item
}else if(R has two data items)
inorder(left subtree of ttTree’s root)
Visit the first data item
inorder(middle subtree of ttTree’s root)
Visit the second data item
inorder(right subtree of ttTree’s root)
}else {
inorder(left subtree of ttTree’s root)
Visit the data item
inorder(right subtree of ttTree’s root)
}
52
การค้นหาข้อมูลใน 2-3 Trees
• การค้นหาข้อมูลใน 2-3 Tree จะใช้หลักการเดียวกับการค้นหาข้อมูลในไบนารีทรี
ตัวอย่างที่ 7.16 โค้ดรหัสเทียมการค้นหาข้อมูลใน 2-3 Trees
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
+retriveItem(in ttTree:2-3TreeNode,in searchKey:KeyType):TreeItemType
if(searchKey is in ttTree’s root node R)
treeItem = the data portion of R
}
else if(R is a leaf){
treeItem = null //not found data in 2-3 Tree
}//search the appropriate subtree
else if(r has two data items){
if(searchKey < smaller search key of R){
treeItem = retriveItem(R’s left subtree, searchKey)
}
else if(searckKey < larger search key of R){
treeItem = retriveItem(R’s middle subtree, serchKey)
}
else{
treeItem = retriveItem(R’s right subtree, searchKey)
}
}
else{ //R has one data item
if(searchKey < R’s search key){
treeItem = retriveItem(R’s left subtree, searchKey)
}
else{
treeItem = retriveItem(R’s right subtree, searchKey)
}
}
53
การเพิม่ ข้อมูลใน 2-3 Trees
• การเพิม่ ข้อมูลใน 2-3 Trees ต้องเพิม่ ข้อมูลในตาแหน่งใบเท่านัน้
• ข้อมูลภายในโหนดต้องจัดเรียงข้อมูลจากน้อยไปหามาก
ตัวอย่างที่ 7.17 แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน 2-3 Trees
ทรีตน้ แบบ
ทรีเพิม่ ข้อมูล 40
1. เพิ่มข้อมูล 40: ขัน้ ตอนในการเพิม่ ข้อมูล 40 ใน 2-3 Trees มีลาดับขัน้ ตอนดังนี้
1. นาข้อมูล 40 เปรียบเทียบกับโหนดรากคือ 55 ผลการเปรียบเทียบ 40 มีคา่ น้อยกว่า 55 ดังนัน้ จะต้องเป็ น
ลูกทางซ้ายของ 55
2. ตาแหน่ งโหนดถัดไปไม่ใช่ตาแหน่ งใบดังนัน้ นา 40 เปรียบเทียบกับโหนดถัดไปคือ 33 เมื่อทาการ
เปรียบเทียบ 40 กับ 33 ข้อมูล 40 จะอยูท่ างขวาของ 33 เนื่องจาก 40 มากกว่า 33
3. เพิม่ ข้อมูล 40 เข้ากับโหนดเดียวกับ 40 เนื่องจากข้อมูลในโหนด <44> อยูใ่ นตาแหน่งใบและเมือ่ เพิม่ 40
เข้าไปแล้วยังมีขอ้ มูลไม่เกิน 2 ข้อมูล ไม่ผดิ กฎของ 2-3 Trees ดังแสดงการเพิม่ 40 ดังนี้
54
การเพิม่ ข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.17 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน 2-3 Trees
2. เพิ่มข้อมูล 35: ขัน้ ตอนในการเพิม่ 35 ได้นาทรีทไ่ี ด้เพิม่ ข้อมูล 40 ไปแล้วมาเป็ นทรีตน้ แบบในการเพิม่
ข้อมูล 35 มีลาดับขัน้ ตอนดังนี้
1. หาตาแหน่งในการเพิม่ ข้อมูล 35 เหมือนกับการเพิม่ ข้อมูล 40 ตาแหน่งทีจ่ ะทาการเพิม่ ข้อมูล 35 คือ
โหนด <40 44> ดังแสดงการเพิม่ ข้อมูล 35 ในทรีรปู (a)
2. เมือ่ ทาการเพิม่ ข้อมูล 35 เข้าไปแล้วข้อมูลภายในโหนดมีขอ้ มูลมากกว่าสองคือ <35 40 44> ซึง่ ผิดกฎ
ข้อที่ 3 ของ 2-3 Trees
3. ปรับโครงสร้างทรีให้ไปตามกฎของ 2-3 Trees ด้วยการนาข้อมูลตาแหน่ งตรงกลางของโหนด
<35 40 44> คือนา 40 ขึน้ ไปรวมกับข้อมูลโหนดแม่ ดังแสดงในรูป (b) พร้อมทัง้ ทาการแยกโหนด 35
และ 44 ให้เป็ นโหนดลูกของข้อมูล 40 ดังแสดงในรูป (b) และได้แสดงผลการเพิม่ ข้อมูล 35 ในรูป (c)
(a)
(b)
(c)
55
การเพิม่ ข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.17 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน 2-3 Trees
3. เพิ่มข้อมูล 37: การเพิม่ ข้อมูล 37 ใช้ทรีเพิม่ ข้อมูล 35 มาเป็ นทรีตน้ แบบในการเพิม่ ข้อมูล
1. ค้นหาตาแหน่งในการเพิม่ ข้อมูล 37 ซึง่ จะอยูร่ วมกับโหนด <35>
2. เพิม่ ข้อมูล 37 เข้าไปรวมกับโหนด <35> ดังแสดงในรูป และเมือ่ ทาการเพิม่ 37 เข้าไปแล้วไม่ผดิ กฎ
ของ 2-3 Trees ก็ไม่ทาอะไรกับโครงสร้าง 2-3 Trees
56
การเพิม่ ข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.17 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน 2-3 Trees
4. เพิ่มข้อมูล 36: การเพิม่ ข้อมูล 36 ใช้ทรีเพิม่ ข้อมูล 36 มาเป็ นทรีตน้ แบบในการเพิม่ ข้อมูลภายในทรี
1. ค้นหาตาแหน่งในการเพิม่ 36 คือโหนด <35 37> ดังแสดงการเพิม่ ข้อมูล 36 ในรูป (a)
2. เมือ่ เพิม่ 36 ข้อมูลภายในโหนดคือ <35 36 37> มีขอ้ มูลภายในโหนดมีขอ้ มูลมากกว่า 2 ไม่เป็ นไปตามกฎข้อที่ 3
ของ 2-3 Trees ต้องทาการแยกข้อมูลด้วยการนาข้อมูลในตาแหน่งตรงกลางของโหนดคือ 36 ขึน้ ไปเป็ นโหนดแม่
พร้อมทัง้ แยกข้อมูล 35 และ 37 ออกเป็ นโหนดลูกของ 36 ดังแสดงในทรีรปู (b)
3. เมือ่ นาข้อมูล 36 ไปเพิม่ ในโหนดแม่แล้วทาให้ขอ้ มูลภายในโหนดเป็ น <33 36 40> ผิดกฎที่ 3 ดังนัน้ ต้องทาการ
แยกข้อมูลในตาแหน่งตรงกลางของโหนดคือ 36 ขึน้ ไปรวมกับโหนดแม่คอื โหนด <55> พร้อมทัง้ แยกโหนด 33
และ 40 เป็ นโหนดลูกของข้อมูล 36 ดังแสดงในทรีรปู (c) และได้แสดงผลการเพิม่ ข้อมูล 36 ในรูป (d)
57
การเพิม่ ข้อมูลใน 2-3 Trees
สรุปขัน้ ตอนการเพิ่มข้อมูลในตาแหน่ งโหนดใบของ 2-3 Trees
จะเริม่ จากหาตาแหน่ งโหนดใบ คือ โหนด n ทีเ่ ป็ นโหนดสาหรับเพิม่ ข้อมูลใหม่ในทรี แต่ถ้า
เพิม่ ข้อมูลในโหนด n แล้วทาให้มขี อ้ มูลเท่ากับ 3 ค่า (ข้อมูล S, M และ L) ซึง่ ไม่เป็ นไปตาม
กฎข้อที่ 1 ของ 2-3 Trees ให้แยกข้อมูลในตาแหน่ งตรงกลางคือ M ขึน้ ไปเป็ นโหนดแม่
พร้อมทัง้ แยกข้อมูลในโหนด n ออกเป็ นสองโหนดคือ n1 เป็ นข้อมูลทีม่ คี ่าน้อยที่สุดคือ S และ
n2 เป็ นข้อมูลทีม่ ากทีส่ ุดคือ L ทาให้โหนดย่อยทัง้ 2 อยูใ่ นตาแหน่งโหนดลูกของ M
58
การเพิม่ ข้อมูลใน 2-3 Trees
สรุปขัน้ ตอนการเพิ่มข้อมูลในตาแหน่ งโหนดแม่ของ 2-3 Trees
โหนดแม่ทเ่ี พิม่ ข้อมูลเแล้วมีขอ้ มูลในโหนดเท่ากับ 3 ค่า และโหนดแม่ทถ่ี ูกเพิม่ ข้อมูลมีขอ้ มูลโหนดลูกอยู่ 4 ค่า ดัง
แสดงการแยกข้อมูลในโหนดแม่ดงั รูป จะมีลาดับการทางานดังนี้
1. นาข้อมูลตรงกลางของโหนด n คือ M ขึน้ ไปรวมกับโหนดทีอ่ ยู่ในระดับบนคือโหนด P พร้อมทัง้ แยกข้อมูล
โหนดลูกออกเป็ นสองโหนดคือ n1 และ n2
2. พบว่า a เป็ นข้อมูลทีน่ ้อยกว่า S ดังนัน้ ข้อมูลจะอยูใ่ นตาแหน่ง โหนดลูกทางซ้ายของ S และ b เป็ นข้อมูลที่
มากกว่า S และน้อยกว่า M ดังนัน้ เมือ่ แบ่งเป็ น n1 และ n2 แล้ว b จะอยูใ่ นตาแหน่งโหนดลูกทางขวาของ S
3. ส่วน c เป็ นข้อมูลทีม่ ากกว่า M แต่น้อยกว่า L ดังนัน้ c จะอยูใ่ นตาแหน่งลูกทางซ้ายของ L และ d เป็ นข้อมูลที่
มากกว่า L ดังนัน้ ข้อมูล d จะอยูใ่ นตาแหน่งลูกทางขวาของ L
59
การเพิม่ ข้อมูลใน 2-3 Trees
สรุปขัน้ ตอนการเพิ่มข้อมูลในตาแหน่ งโหนดรากของ 2-3 Trees
ถ้าโหนดแม่ถกู เพิม่ ข้อมูลเข้าไปแล้วมีขอ้ มูลภายในโหนดรากเท่ากับ 3 ค่า จะแยกข้อมูล M ขึน้
เป็ นโหนดรากใหม่
60
การเพิม่ ข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.18 โค้ดรหัสเทียมเพิม่ ข้อมูลใน 2-3 Trees
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
21
+insertItem(in ttTree:TwoThreeTree,in newItem:TreeItemType)
Search locate for add newItem to leafNode
if(leafNode now has three items){
split(leafNode)
}
+split(inout n:2-3TreeNode){
//แยกโหนด n ในกรณีข้อมูลในโหนด n มีข้อมูล 3 ข้ อมูล
if(n is the root){
Create a new node p
}else{
Let p be the parent of n
}
Replace node n with two nodes, n1 and n2, so that p is their parent.
Give n1 the item in n with the smallest value.
Give n2 the item in n with the largest value.
if(n is not a leaf){
n1 become the parent of n’s two leftmost children
n2 become the parent of n’s two rightmost children
}
Move the item in n that has the middle value up tp p
if(p now has three items){
split(p)
}
61
การลบข้อมูลใน 2-3 Trees
• การลบข้อมูลในโหนด 2-3 Trees จะต้องลบในตาแหน่งใบ
• แยกโหนดทีม่ ขี อ้ มูลเต็มไปแทนตาแหน่งข้อมูลทีต่ อ้ งการลบ
ตัวอย่างที่ 7.19 แสดงการลบข้อมูลใน 2-3 Trees โดยจะใช้โครงสร้าง 2-3 Trees
1. ลบข้อมูล 77: มีลาดับการทางานดังนี้
1. ค้นหาข้อมูล 77 ใน 2-3 Trees โหนด 77 อยูใ่ นโหนด <77 99> ไม่ได้อยูใ่ นตาแหน่งของโหนดใบจึงต้อง
ใช้หลักการ Inorder successor หาข้อมูลในตาแหน่งโหนดใบเพือ่ นาสลับข้อมูลกับ 77 คือข้อมูล 88 และ
ได้แสดงการสลับตาแหน่งข้อมูลระหว่าง 77 และ 88 ในรูป (b)
2. ลบข้อมูล 77 ทีอ่ ยูใ่ นตาแหน่งโหนดใบของทรีดงั แสดงในรูป (c)
3. ลบโหนดออกจากทรีดงั แสดงในรูป (d)
4. เมือ่ พิจารณาโหนดแม่ของโหนดทีถ่ ูกลบข้อมูล ข้อมูลในโหนดแม่มขี อ้ มูล 2 ข้อมูลคือ 88 และ 99 และ
โหนดลูกมีขอ้ มูล 2 ข้อมูลคือ 66 และ 111 จานวนข้อมูลในโหนดแม่และโหนดลูกไม่เป็ นไปตามกฎข้อที่
1 ของ 2-3 Trees คือข้อมูลในโหนดลูกมีสองข้อมูลในโหนดแม่จะต้องมีขอ้ มูลเพียงข้อมูลเดียว ในกรณีน้ี
ให้ใช้หลักการเลื่อนข้อมูลในโหนดแม่ทม่ี คี ่าน้อยทีส่ ุดในคือ 88 ลงไปรวมกับข้อมูลในโหนดลูก ดังในรูป
(e) การลบข้อมูลในตาแหน่งใบและย้ายข้อมูลจากโหนดแม่ไปรวมกับโหนดลูก เรียกรูปแบบนี้ว่า การ
62
รวม (Merging) และแสดงผลการลบข้อมูล 77 ในรูป (f)
การลบข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.19 (ต่อ) แสดงการลบข้อมูลใน 2-3 Trees โดยจะใช้โครงสร้าง 2-3 Trees
63
การลบข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.19 (ต่อ) แสดงการลบข้อมูลใน 2-3 Trees โดยจะใช้โครงสร้าง 2-3 Trees
2. ลบข้อมูล 111: ใช้โครงสร้าง 2-3 Trees มาลบข้อมูล 111 มีลาดับขัน้ ตอนการทางานดังนี้
1. ค้นหาตาแหน่งข้อมูล 111 ใน 2-3 Trees ซึง่ ข้อมูล 111 อยูใ่ นตาแหน่งของโหนดใบ ลบข้อมูลในโหนดนี้
ได้ทนั ทีดงั แสดงการลบข้อมูล 111 ในรูป (a)
2. เมือ่ ทาการลบข้อมูล 111 ไม่เป็ นไปตามกฎข้อที่ 1 ของ 2-3 Trees คือข้อมูลในโหนดแม่ 1 ข้อมูลต้องมี
ลูกสองโหนด แต่เมือ่ ลบข้อมูลแล้วโหนดแม่มลี ูกเพียงหนึ่งโหนด ดังนัน้ ต้องทาการปรับโครงสร้างทรี ใน
กรณีน้ีใช้หลักการรวมข้อมูลด้วยการเลื่อน 99 มารวมกับโหนด <66 88> ทาไม่ได้เพราะจะมีขอ้ มูล
เท่ากับสามข้อมูล ไม่เป็ นไปตามกฎ 2-3 Trees ในกรณีจะใช้หลักการเลื่อนข้อมูล 88 ในโหนดทีม่ ขี อ้ มูล
สองข้อมูลคือ <66 88> ไปไว้ในโหนดข้อมูลทีว่ า่ ง ดังแสดงในรูป (b) ในกรณี นี้ทาไม่ได้เนื่องจากข้อมูล
88 จะอยูใ่ นตาแหน่งทางขวาของโหนด 99 ไม่ได้ เนื่องจากโหนดทางขวาต้องมีขอ้ มูลมากกว่าโหนดแม่
3. การแก้ปญั หานี้จะใช้วธิ กี ารเลื่อนข้อมูลในโหนดแม่คอื 99 ไปแทนข้อมูลในโหนดลูกทีถ่ ูกลบข้อมูล และ
ทาการเลือ่ นข้อมูลในโหนด <66 88> ด้วยการเลือ่ นข้อมูลทีม่ ากทีส่ ุดในโหนดคือ 88 ขึน้ ไปเป็ นโหนดแม่
แทน 99 ดังแสดงในรูปที่ (c) และได้แสดงผลการลบข้อมูล 111 ในรูป (d)
64
การลบข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.19 (ต่อ) แสดงการลบข้อมูลใน 2-3 Trees โดยจะใช้โครงสร้าง 2-3 Trees
65
การลบข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.19 (ต่อ) แสดงการลบข้อมูลใน 2-3 Trees โดยจะใช้โครงสร้าง 2-3 Trees
4.
ลบข้อมูล 88: ใช้โครงสร้างข้อมูล 2-3 Trees ทีล่ บข้อมูล 111 เป็ นทรีตน้ แบบในการลบข้อมูล 88 มีขนั ้ ตอน
การทางานดังนี้
1. ค้นหาตาแหน่งข้อมูล 88 ทีต่ อ้ งการลบ ซึง่ ข้อมูล 88 ไม่ได้อยูใ่ นตาแหน่งโหนดใบ ดังนัน้ ต้องทาการ
สลับข้อมูลด้วยหลักการ Inorder successor ข้อมูลทีจ่ ะนามาสลับกับ 88 คือข้อมูล 99 แล้วทาการสลับ
ข้อมูลระหว่าง 88 และ 99 ดังแสดงในรูป (a)
2. ลบข้อมูล 88 ในตาแหน่งโหนดใบ ดังแสดงในรูป (b)
3. แก้ปญั หากรณีดว้ ยการใช้หลักการรวมข้อมูล เนื่องจากข้อมูลในระดับพีน่ ้องของโหนด <88> คือ
โหนด <66> มีขอ้ มูลภายในโหนดมีเพียงหนึ่งข้อมูลในกรณีใช้หลักการเลื่อนข้อมูลไม่ได้ ต้องใช้วธิ กี าร
รวมข้อมูลด้วยการรวมข้อมูล 99 เข้ากับโหนด <66> พร้อมทัง้ ลบโหนดทีว่ า่ งเปล่า ดังแสดงในรูป (c)
4. การลบข้อมูลยังไม่เสร็จเนื่องจากมีโหนดแม่ทถ่ี ูกลบข้อมูลยังมีลูกอยูค่ อื <66 99> ดังนัน้ จะทาซ้าใน
ขัน้ ตอนการลบข้อมูลอีกครัง้ เพื่อลบข้อมูล โหนดทีไ่ ม่มขี อ้ มูล ด้วยการเริม่ จากตรวจสอบโหนดทีจ่ ะทา
การเลือ่ นข้อมูลมาแทนตาแหน่งโหนดข้อมูลว่างได้คอื โหนด <33> แต่ขอ้ มูลในโหนด 33 มีเพียงข้อมูล
เดียวไม่สามารถใช้หลักการเลื่อนได้ จึงใช้หลักการรวมข้อมูล ด้วยการรวมโหนด 55 ซึง่ เป็ นโหนดราก
และย้ายลูกคือโหนด <66 99> ไปกับโหนดลูกของ 55 พร้อมทัง้ ลบโหนดทีว่ า่ งเปล่าดังแสดงในรูป (d)
5. ข้อมูลในโหนดแม่ได้ถูกรวมไปอยู่กบั โหนดทางซ้าย ทาให้โหนดแม่เป็ นโหนดว่างเปล่าและมีลูกเพียง
ด้านเดียว ซึ่งในกรณีน้ีเป็ นกรณีพเิ ศษเพราะว่า โหนดที่ว่างเปล่าเป็ น โหนดราก และมีลูกด้านเดียว
สามารถทาการลบข้อมูลโหนดนี้ได้และยอมให้ <30 55> เป็ นโหนดรากแทนดังแสงในรูป (e)
66
การลบข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7.19 (ต่อ) แสดงการลบข้อมูลใน 2-3 Trees โดยจะใช้โครงสร้าง 2-3 Trees
67
การลบข้อมูลใน 2-3 Trees
สรุปขัน้ ตอนวิธีในการลบข้อมูลใน 2-3 Trees
 ถ้าโหนด n เก็บข้อมูลทีต่ อ้ งการลบ และโหนด n เป็ นโหนดใบมีขอ้ มูลเพียงข้อมูลเดียว และไม่มขี อ้ มูลใน
ระดับพีน่ ้องสามารถลบโหนดนี้ได้เลย
 ถ้าโหนดทีจ่ ะลบมีโหนดพีน่ ้องและในโหนดพีน่ ้องมีขอ้ มูลอยู่ 2 ค่า จะใช้หลักการกระจายข้อมูลโหนดระดับพี่
น้องไปยังโหนดที่ถูกลบข้อมูลดังแสดงในรู ป (a) โดยเริ่ มจากเลื่อนข้อมูลของโหนดแม่ คือ P ไปยังโหนด
ข้อมูลว่างเปล่าและเลื่อนข้อมูลในระดับพี่นอ้ งที่มีขอ้ มูลมากที่สุดในโหนดคือ L ไปเป็ นข้อมูลโหนดแม่แทน
 ถ้าในกรณีโหนดในระดับพีน่ ้องมีขอ้ มูลเพียงข้อมูลเดียวดังแสงดในรูป (b) ในกรณี น้ ี จะใช้วิธีการรวมข้อมูล
ด้วยการนาข้อมูลในโหนดแม่คือ L มารวมเข้ากับข้อมูลในโหนดลูกคือ S พร้อมทั้งลบโหนดข้อมูลที่วา่ งเปล่า
 ถ้าในกรณีโหนด n ทีถ่ ูกลบเป็ นโหนดทีม่ ลี กู และมีขอ้ มูลโหนดในระดับพีน่ ้อง 2 ข้อมูล ดังแสดงในรูป (c) ใน
กรณี น้ ีจะใช้หลักการกระจายข้อมูล
 ถ้าในกรณีโหนด n ทีถ่ ูกลบเป็ นโหนดทีม่ ลี ูกและมีขอ้ มูลโหนดในระดับพีน่ ้องเพียงข้อมูลเดียว ดังแสดงใน
รูป (d) ในกรณี น้ ีจะใช้หลักการรวมข้อมูล
 ถ้าในกรณีโหนดทีถ่ ูกนาไปรวม คือ ข้อมูลในโหนดรากของทรี และโหนดรากมีทรียอ่ ยเพียงด้านเดียว ใน
กรณีน้ีจะลบโหนดรากออกไปจากทรี ส่งผลทาให้ความสูงของทรีมคี วามสูงลดลง 1 ระดับ ดังแสดงในรู ป
(e)
68
การลบข้อมูลใน 2-3 Trees
สรุปขัน้ ตอนวิธีในการลบข้อมูลใน 2-3 Trees
69
การลบข้อมูลใน 2-3 Trees
ตัวอย่างที่ 7-20 โค้ดรหัสเทียมลบข้อมูลใน 2-3 Trees
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
+deleteItem(in ttTree:2-3TreeNode, in searchKey:TreeItemType)
Search locate for keyequals searchKey to locate theItem
if(theItem is present){
if(theItem is not in a leaf){
Swap item theItem with its inorder successor, which will be in a leaf
theLeaf
}
Delete item theItem from leaf theleaf
if(theLeaf now has no items){
fix(theLeaf)
}
return true
}
else{
return false
}
+fix(in n:TreeNode)
if(n is the root) {
Remove the root
}
else{
Let p be the parent of n
if(some sibling of n has two items) {
Distribute items appropriately among n, the sibling, and p
}
else{ //merge the node
Choose an adjacent sibling s of n
Bring the appropriate item down from p into s
Remove node n
if(p is now empty) {
fix(p)
}
}
}
70
รูจ้ กั กับทรีสมดุลแบบ 2-3-4 Trees
• ทรีทอ่ี นุญาตให้โหนดแม่มลี กู ได้ไม่เกิน 4 โหนด
• ในแต่ละโหนดมีขอ้ มูลได้ไม่เกิน 3 ข้อมูล
71
รูจ้ กั กับทรีสมดุลแบบ 2-3-4 Trees
• ในการตรวจสอบว่าทรีเป็ น 2-3-4 Trees มีขนั ้ ตอนเหมือนกับ 2-3 Trees โดยกาหนดให้ T เป็ น 2-3-4 Trees
ทีม่ คี วามสูง h พิจารณาว่า T เป็ น 2-3-4 Trees ถ้า
1. T เป็ นทรีวา่ งเปล่า(2-3-4 Trees มีความสูงเท่ากับ 0)
2. T มีโครงสร้างดังนี้
โดยที่
 R คือโหนดทีป่ ระกอบด้วยข้อมูลภายในโหนด 1 ข้อมูล และมีทรียอ่ ยคือ TL และ TR
 ความสัมพันธ์ภายในทรี R จะมีค่ามากกว่าข้อมูลทางซ้ายคือ TL และ R จะมีค่าน้อยกว่า
ข้อมูลทางขวาคือ TR
3. T มีโครงสร้างดังนี้
โดยที่




R คือโหนดทีป่ ระกอบด้วยข้อมูลภายในโหนด 2 ข้อมูล และมีทรียอ่ ยคือ TL, TM และ TR
ความสัมพันธ์ภายในทรี R จะมีคา่ มากกว่าข้อมูลทางซ้ายคือ TL
ข้อมูลตรงกลางคือ TM จะมีขอ้ มูลทีม่ ากกว่า TL แต่น้อยกว่า TR
ข้อมูลทางขวาคือ TR จะมีขอ้ มูลทีม่ ากกว่า R
72
รูจ้ กั กับทรีสมดุลแบบ 2-3-4 Trees
4. T มีโครงสร้างดังนี้
โดยที่
 R คือโหนดทีป่ ระกอบด้วยข้อมูลภายในโหนด 3 ข้อมูล และมีทรียอ่ ยคือ TL, TML, TMR และ TR
 ความสัมพันธ์ภายในทรี R จะมีคา่ มากกว่า TL
 ข้อ มู ล ใน middle-left
subtree(TML) จะมีข้อ มูล ที่ม ากกว่ า TL แต่ น้ อ ยกว่ า middle-right
subtree(TMR)
 ข้อมูล TMR จะมีขอ้ มูลทีม่ ากกว่าข้อมูล TML แต่น้อยกว่า TR
 ข้อมูล TR จะมีขอ้ มูลทีม่ ากกว่า R
73
รูจ้ กั กับทรีสมดุลแบบ 2-3-4 Trees
กฎของ 2-3-4 Trees
1. ถ้ามีโหนดลูก 2 โหนดจะมีขอ้ มูลในโหนดแม่ 1 ข้อมูล ดังแสดงโครงสร้างในรูป (a) โดยข้อมูลทางซ้ายจะมีค่า
น้อยกว่า S และข้อมูลทางขวาจะมีคา่ มากกว่า S
2. ถ้ามีโหนดลูก 3 โหนดจะมีขอ้ มูลในโหนดแม่ 2 ข้อมูล ดังแสดงโครงสร้างในรูป (b) โดยที่
 ข้อมูลด้านซ้ายจะมีคา่ น้อยกว่า S
 ข้อมูลตรงกลางจะมีคา่ มากกว่า S และน้อยกว่า L
 ข้อมูลทางขวาจะมีคา่ มากกว่า L
3. ถ้ามีโหนดลูก 4 โหนดจะมีขอ้ มูลในโหนดแม่ 3 ข้อมูล ดังแสดงโครงสร้างในรูป (c) โดยที่
 ข้อมูล S จะมีคา่ มากกว่าข้อมูลโหนดลูกทางซ้าย และมีคา่ น้อยกว่าโหนดลูกตรงกลางซ้าย
 ข้อมูล M จะมีคา่ มากกว่าโหนดลูกตรงกลางซ้าย และมีคา่ น้อยกว่าข้อมูลลูกตรงกลางขวา
 ข้อมูล L จะมีคา่ มากกว่าโหนดลูกตรงกลางขวาแต่น้อยกว่าโหนดลูกทางซ้าย
4. ข้อมูลภายในโหนดจะมีขอ้ มูลได้ 1 หรือ 2 หรือ 3 ข้อมูล
(a) โครงสร้างมีลกู 2 โหนด (b) โครงสร้างมีลกู 3 โหนด
(c) โครงสร้างมีลกู 4 โหนด
74
โครงสร้างข้อมูล 2-3-4 Trees
ตัวอย่างที่ 7-21 อัลกอริทมึ โครงสร้าง 2-3-4 Trees
Java
1
2
3
4
5
6
7
8
9
10
public class 2-3-4TreeNode{
private int smallItem;
private int middleItem;
private int largeItem;
private 2-3-4TreeNode lChild;
private 2-3-4TreeNode lmidChild;
private 2-3-4TreeNode rmidChild;
private 2-3-4TreeNode rChild;
//คอนสตรักเตอร์และเมธอดทีใ่ ช้ในการจัดการ 2-3-4
}
C
Trees
struct 2-3-4TreeNode{
int smallItem;
int middleItem;
int largeItem;
struct 2-3-4TreeNode *LChild;
struct 2-3-4TreeNode *lmidChild;
struct 2-3-4TreeNode *rmidChild;
struct 2-3-4TreeNode *rChild;
//ฟงั ก์ชน
ั ทีใ่ ช้ในการจัดการ 2-3-4 Trees
};
75
การเพิม่ ข้อมูลใน 2-3-4 Trees
1. เพิ่มข้อมูล 66 : เป็ นส่วนเริม่ สร้าง 2-3-4 Trees โดยกาหนดให้ขอ้ มูล 66 เป็ นโหนดรากดังแสดงในรูป a
2. เพิ่มข้อมูล 30 : เข้าไปในทรี ดังแสดงในรูป (b)
3. เพิ่มข้อมูล 10 : เข้าไปในทรีดงั แสดงในรูป (c)
4.
เพิ่มข้อมูล 22: หาตาแหน่งโหนดทีจ่ ะต้องเพิม่ ข้อมูล 22 จากทรีเพิม่ ข้อมูล 10 อยูใ่ นตาแหน่งของ
โหนดรากคือ <11 33 66> และเมือ่ จะทาการเพิม่ ข้อมูลเข้าในโหนดนี้จะทาให้มขี อ้ มูลภายในโหนดมี
ข้อมูลเท่ากับ 4 ดังนัน้ ต้องจัดการข้อมูลภายในโหนดก่อนด้วยวิธกี ารแยกข้อมูล ด้วยการนาค่าใน
ตาแหน่ งตรงกลางคือ 33 ขึน้ ไปยังรวมกับโหนดแม่ดงั แสดงในรูป (b) หลังจากนัน้ จึงเพิม่ ข้อมูล 22
เข้าไปทรี ดังแสดงการเพิม่ ข้อมูล 22 ในรูป (c)
76
การเพิม่ ข้อมูลใน 2-3-4 Trees
5. เพิ่มข้อมูล 55 และ 44: นาโครงสร้างทรีเพิม่ 22 มาเป็ นทรีตน้ แบบ ในการเพิม่ ข้อมูล 55 และ 44 เข้าไปในทรี
ตาแหน่งโหนดทีท่ าการเพิม่ ข้อมูล 55 และ 44 คือโหนด <66> และเมือ่ ทาการเพิม่ 55 และ 44 เข้าไปแล้วมี
ข้อมูลไม่เกินสี่ ดังนัน้ ไม่ตอ้ งทาการแยกข้อมูลในโหนดและได้แสดงการเพิม่ ข้อมูล 55 และ 44 ดังรูป
6.
เพิ่มข้อมูล 77: นาโครงสร้างทรีเพิม่ 55 และ 44 มาเพิม่ ข้อมูล 77 ตาแหน่ งโหนดที่ทาการเพิม่ คือ
<44 55 66> และเมือ่ จะเพิม่ ข้อมูลเข้าไปในโหนดนี้จะมีขอ้ มูลเท่ากับ 4 ดังนัน้ ต้องทาการแยกข้อมูล 55 ขึน้
ไปเป็ นโหนดแม่รวมกับโหนด 33 ดังแสดงในรูป (a) แล้วจึงเพิม่ ข้อมูล 77 เข้าไปในโหนด 66 ดังแสดงการ
เพิม่ ข้อมูล 77 ในรูป (b)
77
การเพิม่ ข้อมูลใน 2-3-4 Trees
7.
เพิ่มข้อมูล 88 และ 15: ในการเพิม่ ข้อมูล 88 และ 15 ไม่มกี ารแยกข้อมูลโหนดและได้แสดงการเพิม่ ข้อมูล
88 และ 15 ในรูป
8.
เพิ่มข้อมูล 99: ค้นหาตาแหน่งในการเพิม่ ข้อมูล 99 จากโครงสร้างทรีเพิม่ 88 และ 15 โหนดทีจ่ ะทาการ
เพิม่ ข้อมูลจะอยูใ่ นโหนด <66 77 88> เมือ่ จะเพิม่ ข้อมูล 99 เข้าไปจะทาให้มขี อ้ มูลในโหนดมีจานวนเท่ากับ
4 ข้อมูล ดังนัน้ จึงต้องแยก 77 ขึน้ ไปรวมกับโหนดแม่คอื <33 55> ดังแสดงในรูป (a) แล้วจึงทาการเพิม่
ข้อมูล 99 เข้าไปโหนดเดียวกับ 88 ดังแสดงการเพิม่ ข้อมูล 99 ในรูป (b)
78
การเพิม่ ข้อมูลใน 2-3-4 Trees
9.
เพิ่มข้อมูล 25: ค้นหาตาแหน่งในการเพิม่ ข้อมูล 25 จากโครงสร้างข้อมูลทรีเพิม่ 99 ข้อมูล 25 จะเพิม่ ใน
โหนด <11 15 22> เมือ่ จะทาการเพิม่ ข้อมูล 25 ทาให้มขี อ้ มูลในโหนดเท่ากับ 4 จึงต้องทาการแยก 15 ขึน้
ไปเป็ นโหนดแม่ แต่ในโหนดแม่คอื <33 55 77> เมือ่ นาข้อมูล 15 ไปรวมจะทาให้มขี อ้ มูลในโหนดนี้มจี านวน
ข้อมูลเท่ากับ 4 ดังนัน้ จึงต้องทาการแยกข้อมูล 55 ขึน้ ไปเป็ นโหนดรากใหม่ดงั แสดงในรูป (a) และแยกข้อมูล
ในโหนด <11 15 22> ข้อมูล 15 ขึน้ ไปรวมกับโหนด <33> ดังแสดงในรูป (b) แล้วจึงทาการเพิม่ ข้อมูล 23
ซึง่ อยูร่ วมกับโหนด <22> ดังแสดงการเพิม่ ข้อมูล 25 ในรูป (c)
79
การเพิม่ ข้อมูลใน 2-3-4 Trees
สรุปการเพิ่มข้อมูลใน 2-3-4 Trees
 ถ้าโหนดทีจ่ ะแยกเป็ นโหนดรากและมีขอ้ มูลในโหนดรากคือ <S M L> การแยกข้อมูลจะแยกข้อมูลตรงกลางคือ
ให้ M ขึน้ ไปเป็ นโหนดรากใหม่พร้อมทัง้ แยกข้อมูล S และ L ให้เป็ นลูกของโหนด M ดังนี้
 ถ้าโหนดทีจ่ ะแยกเป็ นโหนดลูกและมีขอ้ มูลโหนดแม่ 1 ข้อมูล ให้แยกข้อมูล M ไปรวมกับโหนดแม่ คือ P พร้อม
ทัง้ แยกข้อมูล S และ L เป็ นลูกของโหนด M ดังนี้
 ถ้าโหนดแม่มขี อ้ มูลในโหนดเท่ากับ 2 ข้อมูล และโหนดลูกมีขอ้ มูลเท่ากับ 3 ข้อมูล คือ <S M L> ให้นาข้อมูล M
ไปรวมกับโหนดแม่คอื <P Q> ดังแสดงดังนี้
80
การเพิม่ ข้อมูลใน 2-3-4 Trees
สรุปการเพิ่มข้อมูลใน 2-3-4 Trees
81
การลบข้อมูลใน 2-3-4 Trees
1. เริม่ จากหาตาแหน่งของโหนด n ทีเ่ ก็บข้อมูลทีต่ อ้ งการลบ
2. ถ้าโหนด n ไม่ได้อยูใ่ นตาแหน่งใบให้ใช้หลักการ Inorder successor หาตาแหน่งโหนดใบเพือ่
สลับตาแหน่ งข้อมูล ระหว่างข้อมูลที่ต้องการลบกับข้อมูลในตาแหน่ งใบเพื่อ ให้ลบข้อมูลใน
ตาแหน่งใบ
3. เมื่อลบข้อมูลแล้วต้องตรวจสอบความสมดุล ของทรี ถ้าทรีไม่สมดุล ให้ใช้ห ลักการกระจาย
ข้อมูล และหลักการรวมข้อมูลเพือ่ ทาให้ทรีสมดุล
82
รูจ้ กั กับ red-black Tree
• red-black Tree เป็ นทรีทม่ี โี ครงสร้างเหมือนกับไบนารีทรีแต่เป็ นไบนารีทม่ี คี ุณสมบัตขิ อง
ความสมดุล
• red-black Tree ถูกพัฒนามาจากคุณสมบัติ 2-3-4 Trees โดยการใช้หลักการปรับ 3 โหนด
และ 4 โหนด ของ 2-3-4 Trees ให้เป็ นโครงสร้างของไบนารีทรี คือ การเปลีย่ นการอ้างอิง
โหนดเป็ นสีแดงและสีดา โดยที่
o โหนดอ้างอิงสีดา (
) เป็ นโหนดทีม่ กี ารอ้างอิงเหมือนกับใน 2-3-4 Trees
o โหนดทีอ่ า้ งอิงด้วยสีแดง (
) เป็ นการอ้างอิงโหนดทีถ่ ูกแยกออกจากโหนดของ
2-3-4 Trees
83
รูจ้ กั กับ red-black Tree
คุณสมบัตขิ อง red-black Tree มีคุณสมบัตดิ งั นี้
 คุณสมบัติของโหนดราก: โหนดรากเป็ นโหนดสีดา
 คุณสมบัติภายนอก: ทุกๆ โหนดใบเป็ นสีดา
 คุณสมบัติภายใน: โหนดลูกของโหนดสีแดงเป็ นโหนดสีดาทัง้ คู่
 คุณสมบัติความลึก: โหนดใบทัง้ หมดจะมีความสูงเท่ากับความสูงของโหนดสีดา
การปรับเปลีย่ นโหนด 2-3-4 Trees ให้เป็ นโครงสร้าง red-black Tree ในกรณีทม่ี โี หนดใบ 4
โหนด และ 3 โหนด
84
รูจ้ กั กับ red-black Tree
ตัวอย่างที่ 7-22 การเปลีย่ นทรีโครงสร้าง 2-3-4 Trees เป็ น red-black Tree
ตัวอย่างที่ 7-23 อัลกอริทมึ โครงสร้างข้อมูล red-black Tree
Java
1 public class red-blackTreeNode{
2
public enum Color {RED, BLACK};
3
private int item;
4
private red-blackTreeNode lChild;
5
private red-blackTreeNode rChild;
6
private Color leftColor;
7
private Color rightColor;
//คอนสนคักเตอร์และเมธอดทีใ่ ช้ในการจัดการข้อมูลใน red-black Tree
8
}//end red-blackTreeNode
C
struct red-blackTreeNode{
int Color[] = {1,2};
int item;
struct red-blackTreeNode lChild;
struct red-blackTreeNode rChild;
int leftColor;
int rightColor;
//ฟงั ก์ชนั ทีใ่ ช้ในการจัดการข้อมูลใน red-black Tree
}//end red-blackTreeNode
85
การค้นหาและการท่องเข้าไปใน red-black Tree
• red-black Tree มีโครงสร้างเหมือนกับไบนารีทรี ดังนัน้ สามารถใช้อลั กอริทมึ ในการค้นหา
และการท่องเข้าไปในไบนารีทรีมาค้นหาและท่องเข้าไปใน red-black Tree
• การค้นหาและการท่องเข้าไปใน red-black Tree จะไม่สนใจสีในการอ้างอิง
86
การเพิม่ โหนดใน red-black Tree
• การเพิม่ โหนดใน red-black Tree สามารถใช้อลั กอริทมึ การเพิม่ โหนดในไบนารีทรีได้ และ
โหนดทีเ่ พิม่ เข้าไปในทรีจะเป็ นโหนดสีแดง ยกเว้นโหนดทีเ่ พิม่ เป็ นโหนดรากจะเป็ นโหนดสีดา
• เมือ่ เพิม่ โหนดใน red-back Tree โครงสร้าง red-back Tree ทีถ่ ูกเพิม่ โหนดจะต้องเป็ นไป
ตามคุณสมบัตขิ องโหนดราก, คุณสมบัตภิ ายนอก, คุณสมบัตภิ ายใน และคุณสมบัตคิ วามลึก
ตัวอย่างที่ 7-24 เพิม่ โหนดใน red-black Tree
• เมื่อพิจารณาจากรูป (a) โหนดทีต่ อ้ งการเพิม่ จะอยู่ในตาแหน่ ง โหนด z ซึง่ มีโหนด v
เป็ นโหนดพ่อแม่ แต่โหนด v เป็ นโหนดสีแดง เมื่อเพิม่ โหนด z เข้าไปจะทาให้เป็ น
โหนดสีแดงคูด่ งั แสดงในรูป (b)
• ไม่เป็ นไปตามคุณสมบัตภิ ายในคือ โหนดลูกของโหนดสีแดงต้องเป็ นสีดา ดังนัน้ ต้อง
ปรับโครงสร้างของทรี
(a)
(b)
87
การเพิม่ โหนดใน red-black Tree
การปรับโครงสร้างโหนดที่เป็ นสีแดงทัง้ คู่
• โครงสร้างโหนดทีเ่ ป็ นสีแดงทัง้ คู่จะประกอบด้วยโหนด z คือ โหนดลูก, โหนดพ่อแม่ คือ โหนด v และโหนด w
คือ โหนดพีน่ ้องของโหนด
• มีขอ้ พิจารณาเกีย่ วกับการปรับโครงสร้างทีเ่ กีย่ วกับโหนด w ทีเ่ ป็ นโหนดพีน่ ้องของโหนดโหนด v อยูส่ องกรณีคอื
กรณี ที่ 1: w เป็ นสีดา
• ในกรณีท่โี หนดเป็ นสีแดงทัง้ คู่ จะประกอบด้วย 4 โหนดดังแสดงในรูป (a) ซึ่งจะปรับโครงสร้างของ
โหนดทัง้ 4 โหนดให้มโี ครงสร้างใหม่ดงั แสดงรูป (b)
• การปรับโครงสร้างจะใช้วธิ กี ารหมุน เช่นเดียวกับการปรับโครงสร้างใน AVL Tree คือ ถ้าโหนดทีถ่ ูกเพิม่
อยู่ดา้ นเดียวกับกลุ่มของโหนดทีเ่ พิม่ จะหมุน 1 ครัง้ แต่ถ้าโหนดทีถ่ ูกเพิม่ อยู่ดา้ นตรงข้ามกับกลุ่มของ
โหนดทีเ่ พิม่ จะหมุน 2 ครัง้
โดยมีขนั ้ ตอนการปรับโครงสร้างดังนี้
1. จัดการเฉพาะโหนดทีเ่ ป็ นสีแดงคู่
2. ปรับโครงสร้างโหนดเฉพาะ 4 โหนดทีม่ คี วามสัมพันธ์กนั
3. ใช้คุณสมบัติภายใน เป็ นคุณสมบัติในการปรับ โครงสร้าง ส่วนคุณสมบัติอื่นๆ เป็ นคุณสมบัติ
ควบคุมให้ตรงกับรูปแบบของ red-black Tree
88
การเพิม่ โหนดใน red-black Tree
การปรับโครงสร้างโหนดที่เป็ นสีแดงทัง้ คู่
กรณี ที่ 1: w เป็ นสีดา
(a)
(b)
89
การเพิม่ โหนดใน red-black Tree
การปรับโครงสร้างโหนดที่เป็ นสีแดงทัง้ คู่
กรณี ที่ 1: w เป็ นสีดา
90
การเพิม่ โหนดใน red-black Tree
การปรับโครงสร้างโหนดที่เป็ นสีแดงทัง้ คู่
กรณี ที่ 2: w เป็ นสีแดง
• ในกรณีโหนด w เป็ นโหนดสีแดง แสดงว่าทัง้ สีโ่ หนดอยูใ่ นโหนดเดียวกันของ 2-3-4 Trees ดังแสดงในรูป (a)
• ในกรณีน้จี ะใช้หลักการในการปรับสีของโหนดเพื่อทาให้ทรีสมดุล ด้วยการเปลีย่ นสีโหนดพ่อแม่ คือ โหนด v และ
โหนดระดับพีน่ ้อง คือ โหนด w ให้เป็ นโหนดสีดา และโหนดพ่อแม่ของโหนด v คือโหนด u เปลีย่ นเป็ นโหนดสี
แดง ยกเว้นถ้าโหนด u เป็ นโหนดรากให้เป็ นโหนดสีดาเหมือนเดิม ดังแสดงการปรับสีของโหนดในรูป (b)
(a)
(b)
91
การเพิม่ โหนดใน red-black Tree
การปรับโครงสร้างโหนดที่เป็ นสีแดงทัง้ คู่
• การเพิม่ ข้อมูลใน red-black Tree ในกรณีทโ่ี หนดสีแดงคู่ ในกรณีท่ี 1 โหนดระดับพีน่ ้อง
เป็ นสีด่ า ใช้วธิ กี ารปรับโครงสร้าง (Restructure) ด้วยการหมุน
• ในกรณีท่ี 2 โหนดระดับพีน่ ้องเป็ นสีแดง ใช้วธิ กี ารปรับสี (Recolor)
ตัวอย่างที่ 7.14 โค้ดรหัสเทียมเพิม่ ข้อมูลใน red-black Tree
1
2
3
4
5
6
7
8
+insertNode(k:red-blackTree)
Search for key k to locate the insertion node z
Add the new item k at node z and color z is red
while doubleRed(z)
if isBlack(sibling(parent(z)))
z = restructure(z)
else //sibling(parent(z)) is red
z = recolor(z)
92
การเพิม่ โหนดใน red-black Tree
ตัวอย่างที่ 7-25 ตัวอย่างการเพิม่ ข้อมูลใน red-black Tree ลาดับการเข้ามาของข้อมูลดังนี้
A, L, G, O, R, I, T, H และ M
93
การลบโหนดใน red-black Tree
1.
สามารถใช้อลั กอริทมึ ในการลบโหนดของไบนารีมาใช้ในการลบโหนดของ red-back Tree ได้ โดยการหา
ข้อมูลมาสลับข้อมูลในตาแหน่ งที่ต้องการลบด้วยหลักการ Inorder successor แล้วลบโหนดนัน้ เช่น
ต้องการลบโหนด 7 ให้สลับตาแหน่งระหว่างโหนด 7 กับโหนด 8 คือการสลับโหนด u กับโหนด v แล้วจึง
ลบคีย์ 7 ทีต่ าแหน่ง v
2.
เมือ่ ต้องการลบโหนด v ให้พจิ ารณาสีของโหนด v ถ้าโหนด v เป็ นสีแดง สามารถลบโหนด v ได้ทนั ทีดงั
แสดงในรูป (a) แต่ถา้ โหนด v เป็ นโหนดสีดา และโหนด u เป็ นสีดา เมือ่ ลบโหนด v แล้วทาให้โหนด u
เป็ นสีดาคู่ (double black) ดังแสดงในรูป (b)
94
การลบโหนดใน red-black Tree
3.
เมือ่ เกิดสีดาคูข่ น้ึ ให้ทาต่อไปนี้
 กรณี ที่ 1: โหนดพีน่ ้องของโหนดสีดาคูเ่ ป็ นโหนดสีดาและมีโหนดลูกเป็ นโหนดสีแดง
ถ้าโหนดในระดับพีน่ ้องของโหนด u คือโหนด s เป็ นโหนดสีดาและมีโหนดลูกเป็ นสีแดง 1 โหนด คือ โหนด z ในกรณี
นี้จะใช้หลักการปรับโครงสร้างด้วยการหมุน 1 ครัง้ ดังแสดงในรูป
(a) แสดงการปรับโครงสร้าง
ดัวยการหมุน 1 ครัง้
(b) แสดงการปรับโครงสร้างใน 2-3-4 Trees
เทียบกับ red-black Tree
95
การลบโหนดใน red-black Tree
3.
เมือ่ เกิดสีดาคูข่ น้ึ ให้ทาต่อไปนี้
• กรณี ที่ 2: โหนดพีน่ ้องของโหนดสีดาคูเ่ ป็ นโหนดสีดาและมีโหนดลูกเป็ นโหนดสีดา
ถ้าโหนดพีน่ ้องโหนด s เป็ นโหนดสีดาและโหนดลูกของโหนดพีน่ ้องเป็ นโหนดสีดา คือ โหนด z ในกรณีน้ีจะใช้
หลักการ การเปลี่ยนสี (recoloring) ดังแสดงหลักการเปลีย่ นสีในรูป (a) ถ้าโหนดพ่อแม่กลายเป็ นดาคู่ ให้ปรับ
โครงสร้างของทรีใหม่ ดังแสดงในรูป (b)
96
การลบโหนดใน red-black Tree
3.
เมือ่ เกิดสีดาคูข่ น้ึ ให้ทาต่อไปนี้
• กรณี ที่ 3: โหนดพีน่ ้องเป็ นสีแดง
ถ้าโหนดระดับพีน่ ้องเป็ นโหนดสีแดงจะใช้หลักการ การปรับโครงสร้าง (adjustment) ด้วยการหมุน ดังแสดงในรูป
เมือ่ ปรับโครงสร้างแล้ว อาจจะต้องปรับทรีตามกรณีท่ี 1 และ 2 เพือ่ ให้ทรีเป็ นไปตามคุณสมบัติ red-black Tree
ตัวอย่างที่ 7-26 โค้ดรหัสเทียมลบข้อมูลใน red-black Tree
1
2
3
4
5
6
7
8
9
10
+deleteNode(k:red-blackTree)
Search for key k to locate the delete node y
Delete node y
while doubleback(u)
if (sibling node u is back and has a red child)
restructuring node with one rotation
else if (sibling node u is back and has a black child)
recolorting sibling node u
else //sibling node u is red
rotation node u and check doubleback again
97
การลบโหนดใน red-black Tree
ตัวอย่างที่ 7-26 ตัวอย่างการลบข้อมูลใน red-black Tree
การลบข้อมูลใน red-black Tree มีลาดับการลบโหนดดังนี้ 9, 8 และ 7
98
รูจ้ กั กับ B-Tree
• B-Tree เป็ นทรีทม่ี คี ุณสมบัตแิ บบหลายทิศทาง เป็ นทรีทอ่ี อกแบบมาเป็ นพิเศษเพื่อใช้ในการเก็บข้อมูลใน
ดิสก์ของเครือ่ งคอมพิวเตอร์
• คุณสมบัติ B-Tree คือ ทรีแบบหลายทิศทางตามจานวนของ m (Multiway tree of order m)
หมายความว่า ในแต่ละโหนดจะมีเส้นทีเ่ ชือ่ มโยงไปยังโหนดลูกได้เท่ากับ m ดังนัน้ แสดงว่าใน 1 โหนดจะมี
โหนดลูกได้ไม่มากกว่า m ข้อมูล และมีขอ้ กาหนดของ B-Tree ดังนี้
1. จานวนของคีย์ (Key) ในแต่ละโหนดทีไ่ ม่ใช่โหนดใบจะมีจานวนของคียเ์ ท่ากับ m -1
2. โหนดใบทัง้ หมดจะอยูใ่ นระดับเดียวกัน
3. โหนดทัง้ หมดทีไ่ ม่ใช่โหนดใบยกเว้นโหนดรากจะมีโหนดลูกได้น้อยทีส่ ดุ m/2 โหนด
4. โหนดแม่ในแต่ละโหนดใบจะมีโหนดลูกได้ 1 ถึง m โหนด
5. โหนดใบจะมีคยี ไ์ ด้ไม่มากกว่า m – 1
6. ตัวเลขของ m ต้องเป็ นเลขจานวนคี่
99
การเพิม่ โหนดใน B-Tree
ตัวอย่างที่ 7.27 แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน B-Tree
ในตัวอย่างนี้ กาหนดให้ m มีคา่ เท่ากับ 5 และมีลาดับการเข้ามาของข้อมูลดังนี้
1, 12, 8, 2, 25, 6, 14, 28, 17, 7, 52, 16, 48, 68, 3, 26, 29 และ 45
1.
2.
3.
4.
5.
เพิ่มข้อมูล 1 : เป็ นส่วนเริม่ ต้นโหนดราก B-Tree ดังแสดงในรูป (a)
เพิ่มข้อมูล 12 : เข้าไปในโหนดราก B-Tree ดังแสดงในรูป (b)
เพิ่มข้อมูล 8 : เข้าไปในโหนดราก B-Tree ดังแสดงในรูป (c)
เพิ่มข้อมูล 2 : เข้าไปในโหนดราก B-Tree ดังแสดงในรูป (d)
เพิ่มข้อมูล 25: เมือ่ เพิม่ 25 เข้าไปในโหนดรากแล้วข้อมูลทีอ่ ยูใ่ นโหนดรากมีคา่ เท่ากับ m คือ 5
ดังแสดงในรูป (a) ซึง่ ไม่เป็ นไปตามข้อกาหนดข้อที่ 5 ของ B-Tree ดังนัน้ จึงต้องแยกด้วยการ
นาค่ากลางของโหนดราก คือ 8 ขึน้ ไปเป็ นโหนดรากแทนดังแสดงในรูป (b)
(a)
(b)
100
การเพิม่ โหนดใน B-Tree
ตัวอย่างที่ 7.27 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน B-Tree
6. เพิ่มข้อมูล 6: เข้าไปในโหนดข้อมูล <1, 2> ดังแสดงในรูป (a)
7. เพิ่มข้อมูล 14: เข้าไปในโหนดข้อมูล <12, 25> ดังแสดงในรูป (b)
8. เพิ่มข้อมูล 28: เข้าไปในโหนดข้อมูล <12, 14, 25> ดังแสดงในรูป (c)
9.
เพิ่มข้อมูล 17: เมือ่ เพิม่ ข้อมูล 17 เข้าไปในโหนด <12, 14, 25, 28> ทาให้ขอ้ มูลในโหนดมีจานวน
เท่ากับ 5 ดังแสดงในรูป (a) ซึง่ ไม่เป็ นไปตามข้อกาหนดของ B-Tree ดังนัน้ นาค่ากลางคือ 17 ขึน้ ไป
รวมกับโหนดรากดังแสดงในรูป (b)
(a)
(b)
101
การเพิม่ โหนดใน B-Tree
ตัวอย่างที่ 7.27 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน B-Tree
10.
11.
12.
13.
เพิ่มข้อมูล 7: เข้าไปในโหนดข้อมูล <1, 2, 6> ดังแสดงในรูป (a)
เพิ่มข้อมูล 52: เข้าไปในโหนดข้อมูล <25, 28> ดังแสดงในรูป (b)
เพิ่มข้อมูล 16: เข้าไปในโหนดข้อมูล <12, 14> ดังแสดงในรูป (c)
เพิ่มข้อมูล 48: เข้าไปในโหนดข้อมูล <25, 28, 52> ดังแสดงในรูป (d)
14. เพิ่มข้อมูล 68: ข้อมูล 68 จะอยูร่ วมกับโหนด <25, 28, 48, 52> ดังแสดงในรูป (a) ทาให้ไม่เป็ นตาม
ข้อกาหนดของ B-Tree ดังนัน้ จึงนาคียใ์ นตาแหน่งตรงกลางคือ 48 ขึน้ ไปรวมกับโหนดรากดังแสดงผล
การเพิม่ 68 ในรูป (b)
102
การเพิม่ โหนดใน B-Tree
ตัวอย่างที่ 7.27 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน B-Tree
15. เพิ่มข้อมูล 3: ข้อมูล 3 ถูกเพิม่ เข้าไปในโหนด <1, 2, 6, 7> ดังแสดงในรูป (a) ทาให้มขี อ้ มูลภายใน
โหนดไม่เป็ นตามกาหนดของ B-Tree ดังนัน้ นาข้อมูลตรงกลางคือ 3 ขึน้ ไปรวมกับโหนดราก ดังแสดง
ในรูป (b)
(a)
(b)
16. เพิ่มข้อมูล 26: เข้าไปในโหนดข้อมูล <25, 28> ดังแสดงในรูป (a)
17. เพิ่มข้อมูล 29: เข้าไปในโหนดข้อมูล <25, 26, 28> ดังแสดงในรูป (b)
103
การเพิม่ โหนดใน B-Tree
ตัวอย่างที่ 7.27 (ต่อ) แสดงขันตอนการเพิ
้
ม่ ข้อมูลใน B-Tree
18. เพิ่มข้อมูล 45: ข้อมูล 45 จะถูกเพิม่ ร่วมกับโหนด <25, 26, 28, 29> ดังแสดงในรูป (a) ซึง่ ไม่เป็ นไป
ตามข้อกาหนดของ B-Tree จึงนาข้อมูล 28 ไปร่วมกับโหนดราก <3, 8, 17, 48> ทาให้จานวนข้อมูล
ในโหนดรากไม่เป็ นไปตามข้อกาหนดของ B-Tree จึงนาข้อมูล 17 ขึน้ ไปเป็ น โหนดรากใหม่ ดัง
แสดงผลการเพิม่ 45 ในรูปที่ (b)
104
การเพิม่ โหนดใน B-Tree
สามารถสรุปการเพิม่ คียใ์ น B-Tree ดังนี้
1. เพิม่ คียใ์ หม่ในตาแหน่งใบ
2. ถ้าการเพิม่ คียเ์ ข้าไปในตาแหนงใบแล้วมีจานวนคียเ์ ท่ากับค่า m จะต้องแยกโหนดใบ
ออกเป็ นสองกลุ่ม และนาคียใ์ นตาแหน่งกลางขึน้ ไปเป็ นโหนดพ่อแม่
3. ถ้าคีย์ในตาแหน่ งโหนดรากถูกแยกเป็ น 2 กลุ่ม จะทาให้คยี ใ์ นตาแหน่ งตรงกลางถูก
กาหนดให้เป็ นโหนดรากใหม่
105
การลบโหนดใน B-Tree
• การลบคียใ์ น B-Tree จะต้องลบข้อมูลในตาแหน่งโหนดใบ
• ถ้าตาแหน่ งคียท์ ต่ี อ้ งการลบอยู่ในตาแหน่ ง ใบ และยังมีคยี อ์ ่นื ทีไ่ ม่ใช้คยี ท์ ต่ี อ้ งการลบอยู่ใน
โหนดเดียวกัน ในกรณีน้สี ามารถลบคียอ์ อกจาก B-Tree ได้ทนั ที
• ถ้าตาแหน่งคียท์ ต่ี อ้ งการลบไม่ได้อยู่ในตาแหน่งใบ ให้ใช้หลักการ Inorder successor มา
สลับตาแหน่งของคียท์ ต่ี อ้ งการลบกับคียท์ อ่ี ยูใ่ นตาแหน่งใบ จึงลบคีย์ออกจาก B-Tree
• เมื่อลบคียแ์ ล้วส่งผลทาให้คยี ท์ อ่ี ยู่ในโหนดมีจานวนน้องกว่าจานวนของคียท์ ก่ี าหนดไว้ ให้
พิจารณาดูโหนดในระดับพีน่ ้องดังต่อไปนี้
• ถ้าโหนดในระดับพีน่ ้องมีจานวนของคีย์มากกกว่าหนึ่งคีย์ให้เลื่อนคีย์ ในระดับพ่อแม่ลงมา
แทนคียท์ ถ่ี ูกลบไปและเลื่อนคีย์ในตาแหน่ ง โหนดพีน่ ้องขึน้ ไปแทนคีย์ในโหนดพ่อแม่ทถ่ี ูก
เลื่อนลงไป ดังแสดงการเลื่อนตาแหน่งใน B-Tree
106
การลบโหนดใน B-Tree
• ถ้าโหนดในระดับพีน่ ้องมีจานวนของคียเ์ ท่ากับหนึ่ง ในกรณีน้จี ะใช้หลักการรวมคีย์ โดย
นาคียใ์ นระดับพ่อแม่ลงไปรวมกับคียใ์ นระดับพีน่ ้อง ดังแสดงการรวมคีย์ในรูป
107
การลบโหนดใน B-Tree
ตัวอย่างที่ 7.28 ตัวอย่างการลบข้อมูลใน B-Tree
กาหนดให้มลี าดับการลบข้อมูลคือ 52, 72, 69, 56 ใน B-Tree โดยกาหนดให้ m = 5 แสดงได้ดงั นี้
1. ลบข้อมูล 52: โดยนา B-Tree ต้นแบบมาลบดังแสดงในรูป a เมือ่ ตรวจสอบข้อมูล 52 ทีต่ อ้ งการลบไม่ได้
อยู่ในตาแหน่ งใบต้องทาการสลับตาแหน่ งข้อมูล 52 กับข้อมูลในตาแหน่ งใบด้วยหลักการ Inorder
successor คือข้อมูล 56 ดังแสดงในรูป (c) และทาการลบข้อมูล 52 ดังแสดงในรูป (d)
108
การลบโหนดใน B-Tree
ตัวอย่างที่ 7.28 ตัวอย่างการลบข้อมูลใน B-Tree
2.
ลบข้อมูล 72: นา B-Tree ทีเ่ พีม่ ข้อมูล 52 มาเป็ นต้นแบบในการลบข้อมูล 72 เป็ นข้อมูลทีอ่ ยูใ่ น
ตาแหน่งใบสามารถทาลบข้อมูล 72 ได้เลยดังแสดงในรูปที (b)
3.
ลบข้อมูล 69: นา B-Tree เพิม่ ข้อมูล 72 มาเป็ นทรีตน้ แบบในการลบข้อมูล ข้อมูล 69 อยูใ่ นตาแหน่งใบ
สามารถทาการลบข้อมูล 69 ได้ทนั ทีแต่เมือ่ ทาการลบข้อมูล 69 แล้วข้อมูลแม่มลี ูกอยู่เพียงโหนดเดียวซึง่
ไม่เป็ นตามกฎของ B-Tree ดังนัน้ จึงทาการเลือ่ นข้อมูลในลาดับพีส่ องคือ <31, 43> มี 2 ข้อมูลดังนัน้ จึงทา
การเลือ่ นข้อมูล 56 ลงมาแทนข้อมูล 69 และทาการเลือก 43 ขึน้ ไปเป็ นโหนดรากแทน ดังแสดงในรูป (d)
109
การลบโหนดใน B-Tree
ตัวอย่างที่ 7.28 ตัวอย่างการลบข้อมูลใน B-Tree
4. ลบข้อมูล 56: นา B-Tree เพิ่มข้อมูล 69 มาเป็ นต้นแบบ ข้อมูล 56 อยูใ่ นตาแหน่งใบสามารถลบข้อมูลได้ทนั ที แต่เมื่อลบ
ไปแล้วแม่มีขอ้ มูลเพียงข้อมูลเดียวและเมื่อดูโหนดระดับพี่นอ้ ง <31> มีเพียงข้อมูลเดียวดังนั้นต้องใช้หลักการเลื่อนข้อมูล
43 ไปร่ วมกับ 31 ดังแสดงในรู ปที่ (d)
110
การวิเคราะห์ B-Tree
จานวนของคียท์ งั ้ หมดใน B-Tree ทีล่ าดับ m และความสูง h
ล บ น
Root
ชัน้ ที่ 1
ชัน้ ที่ 2
...
ชัน้ ที่ h
นน ี
m-1
m(m-1)
m2(m-1)
mh(m-1)
ดังนัน้ จานวนคียท์ งั ้ หมดใน B-Tree คือ
2
3
h
(1 + m + m + m + . . . + m )(m + 1) =
 m h 1  1 
h 1
1

 * ( m  1)  m
 m 1 
และเมือ่ m = 5 และ h = 2 จะมีคยี ไ์ ด้ทงั ้ หมด 53 – 1 = 124
111
สรุปเนื้อหาบทที่ 7
• ทรีเป็ น โครงสร้า งข้อมูล ที่เ ก็บ ข้อ มูล แบบไม่ต่ อเนื่ อง ซึ่งภายในโครงสร้า งแบบทรีน้ี จะเชื่อ มโยงข้อมูลด้ว ย
ความสัมพันธ์แบบลาดับชัน้
• ทรีมคี ุณสมบัตริ ะหว่างข้อมูลทีเ่ ชื่อมโยงกันแบบลาดับชัน้ เช่น คุณสมบัตแิ ม่ลูก คุณ สมบัตพิ น่ี ้อง และทรีต้องมี
หนึ่งโหนดทีไ่ ม่มแี ม่และเป็ นแม่ของทุกโหนดคือ โหนดราก (root node)
• ทรีมหี ลายชนิดโดยแยกตามคุณสมบัตโิ ครงสร้างการเก็บข้อมูล เช่น ไบนารีทรีจะมีโหนดลูก 2 ข้อมูล จึงเรียกว่า
ไบนารีทรี, 2-3 Trees เป็ นทรีทส่ี ามารถมีลกู ได้ 2 หรือ 3 โหนด จึงเรียกว่า 2-3 Trees
• คุณสมบัตทิ รีสมดุลเป็ นคุณสมบัตทิ ใ่ี ช้ในการจัดการทรีเพือ่ ให้การเข้าถึงข้อมูลภายในทรีมปี ระสิทธิภาพ
• คุณสมบัตทิ รีสมดุลเป็ นการเปรียบเทรีบความสูงของทรียอ่ ยทางซ้ายและทางขวาว่ามีความสูงต่างกันมากกว่า 1
หรือไม่ ถ้าไม่เกิน แสดงว่าเป็ น ทรีสมดุล แต่ถา้ มีคา่ เกิน 1 แสดงว่าทรีไม่สมดุล
• การเพิม่ โหนดในทรีจะต้องเพิม่ โหนดในตาแหน่ งใบเท่านัน้ และต้องหาตาแหน่ งให้เหมาะสมกับข้ อมูลก่อนทีจ่ ะ
เพิม่ โหนดในทรีได้
• การลบโหนดในทรีตอ้ งลบโหนดในตาแหน่งใบเท่านัน้ ซึง่ การลบโหนดมีขอ้ มูลในทรีม ี 3 แบบคือ
o โหนดทีต่ อ้ งการลบไม่มลี กู สามารถลบโหนดนี้ได้ทนั ที
o โหนดทีต่ อ้ งการลบมีลกู หนึ่งโหนด จะให้นาโหนดลูกขึน้ มาแทนโหนดทีต่ อ้ งการลบ
o โหนดทีต่ อ้ งการลบมีโหนดลูก 2 โหนด ให้ใช้หลักการ Inorder succesor หาโหนดในตาแหน่งใบ และใน
ตาแหน่งลูกกลุม่ ลูกทางขวาในตาแหน่งซ้ายสุดนาไปสลับกับข้อมูลทีต่ อ้ งการลบแล้วจึงลบโหนดนัน้ ทิง้ ไป
112