hoa cuong có thì sử dụng – thích thì lao vào

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (206.92 KB, 70 trang )

(1)<div class='page_container' data-page=1></div>
(2)<div class='page_container' data-page=2>

Cây

• Định nghĩa:

• Rỡng là 1 cây

• T1 , T2 , ……Tm là cây thi

là cây (m-phân)

• T1 , T2 , ……Tm gọi là cây con của cây T
T

Tm
T2

</div>
(3)<div class='page_container' data-page=3>

• Ví dụ

– Cây thư mục trong hệ điều hành
– Cây gia phả của 1 dòng họ

– Cây biểu thức: a-b+c*d/e

- /

</div>
(4)<div class='page_container' data-page=4>

Mợt sớ khái niệm

• R là cha của U, O, P
• U, O, P là con của R

• Q, R là đỉnh trước của A.
• A là đỉnh sau của Q, R

• T, Y, U, O, A là các nút lá (khơng có con)
• Q là nút gốc

E R

T U O P

mức 1

mức 2

mức 3

</div>
(5)<div class='page_container' data-page=5>

Phép duyệt

• Phép duyệt: Đưa ra tất cả các nút theo
mợt thứ tự nào đó, mỡi nút 1 lần

– Ví dụ: Tim kiếm một file hay một folder trong
cây thư mục

• Phổ biến:

– Duyệt theo bề sâu (Depth First Search - DFS)
– Duyệt theo bề rộng (Breadth First Search -

</div>
(6)<div class='page_container' data-page=6>

Cây nhị phân (Binary tree)

• Là cây bao gờm các nút, mỡi nút có tới đa 2 cây
con:

– Cây con bên trái (Left)
– Cây con bên phải (Right)
• Mơ tả cấu trúc:

typedef struct nodet {
elem data;

struct nodet *left, *right;
} node;

</div>
(7)<div class='page_container' data-page=7>

Duyệt theo bề sâu (DFS)

• Duyệt tiền tự (Preorder Search – NLR)

– Thăm nút gốc (Node)

– Duyệt cây con bên trái (Left)

– Duyệt cây con bên phải (Right)

• Duyệt trung tự (Inorder Search – LNR)
(tương tự)

</div>
(8)<div class='page_container' data-page=8>

Duyệt theo bề sâu (DFS)

• NLR: QWTYRUPA
• LNR: TWYQURAP
• LRN: TYWUAPRQ

R
w

T U P

</div>
(9)<div class='page_container' data-page=9>

Ví dụ: Đếm số nút trên cây

int sonut(tree t)
{

if (t==NULL) return 0;

</div>
(10)<div class='page_container' data-page=10>

Độ cao cây?

int h(tree t)
{

if (t==NULL) return 0;

return 1 + max(h(t->left), h(t->right));
}

</div>
(11)<div class='page_container' data-page=11>

Nhập cây số nguyên>0

void nhap(tree &t)
{

int x;
cin>>x;
if (x>0)
{

t = new node;
t->data = x;

nhap(t->left);
nhap(t->right);
}

else

t = NULL;

• Với cây trên dữ liệu nhập:

7 2 4 0 0 5 0 0 6 
 3 0 0 9 8 0 
 0 0

6
2

4 3 9

</div>
(12)<div class='page_container' data-page=12>

In cây (số nguyên)

void incay(tree t, int m=1)
{

if (t!=NULL)
{

incay(t->left, m+1);

cout<<endl<<setw(4*m)<<t->data;
incay(t->right, m+1);

</div>
(13)<div class='page_container' data-page=13>

Xóa toàn bộ cây

void xoacay(tree &t)
{

if (t!=NULL)
{

xoacay(t->left);
xoacay(t->right);
delete t;

</div>
(14)<div class='page_container' data-page=14>

Đếm số nút lá trên cây

int sonutla(tree t)
{

if (t==NULL) return 0;

if (t->left==NULL && t->right==NULL)

return 1;

</div>
(15)<div class='page_container' data-page=15>

Đếm số nút có 1 con trên cây

int sonut1(tree t)
{

if (t==NULL) return 0;

if ((t->left!=NULL) &&( t->right==NULL))
return 1+sonut1(t->left);

if ((t->left==NULL) &&( t->right!=NULL))
return 1+sonut1(t->right);

</div>
(16)<div class='page_container' data-page=16>

Đếm số nút có 1 con trên cây

int sonut1(tree t)
{

if (t==NULL) return 0;

if ((t->left!=NULL && t->right==NULL)||
 (t->left==NULL && t->right!=NULL)) 
return 1+sonut1(t->left) +sonut1(t->right);
return sonut1(t->left)+sonut1(t->right);

</div>
(17)<div class='page_container' data-page=17>

Đếm số nút có 1 con trên cây

int sonut1(tree t)
{

if (t==NULL) return 0;

if ((t->left==NULL) ^( t->right==NULL))

return 1+sonut1(t->left)+sonut1(t->right);
return sonut1(t->left)+sonut1(t->right);

</div>
(18)<div class='page_container' data-page=18>

Đếm số nút trong trên cây (không

phải là lá)

int sonuttrg(tree t)
{

if (t==NULL) return 0;

if (t->left==NULL && t->right==NULL)
return 0;

</div>
(19)<div class='page_container' data-page=19>

Tính trung binh cộng

void NLR(tree t, int &sn, int &tg)
{

if (t!=NULL)

{

tg+=t->data;
sn++;

NLR(t->left, sn, tg);
NLR(t->right, sn, tg);
}

}

float tbc(tree t)
{

int sn, tg;
sn = tg = 0;

NLR(t, sn, tg);

</div>
(20)<div class='page_container' data-page=20>

Bài tập

• Đếm sớ nút trên mức thứ k
• Đếm sớ nút trên mức >= k
• Đếm số nút trên mức <= k

</div>
(21)<div class='page_container' data-page=21>

Đếm số nút trên mức lẻ của cây

int muccl(tree t, int m=1)

{

if (t==NULL) return 0;

return m%2 +muccl(t->left, m+1) +

muccl(t->right, m+1);
}

Gọi hàm:

cout<<“Số nút trên mức lẻ =“<<muccl(t);

</div>
(22)<div class='page_container' data-page=22>

Đếm số nút trên mức thứ k

int nutk(tree t, int k)
{

if (t==NULL) return 0;
if (k>1)

return nutk(t->left,k-1)+nutk(t->right, k-1);
return 1;

</div>
(23)<div class='page_container' data-page=23>

void nlr(tree t, int k, int &sn, int &tg)
{
if (t!=NULL)
{

if (k>1)
{

nlr(t->left, k-1, sn, tg);
nlr(t->right, k-1, sn, tg);
}
else
{
sn++;
tg +=t->data);
}
}
}

float tbc(tree t, int k)
{

int sn, tg;
sn = tg = 0;

nlr(t, k, sn, tg);

</div>
(24)<div class='page_container' data-page=24>

void nlr(tree t, int k, int &sn, int &tg)
{
if (t!=NULL)
{
sn++;
tg +=t->data);

if (k>1)
{

nlr(t->left, k-1, sn, tg);
nlr(t->right, k-1, sn, tg);
}

}
}

float tbc(tree t, int k)
{

int sn, tg;
sn = tg = 0;

nlr(t, k, sn, tg);

if (sn == 0) return 
0.;

</div>
(25)<div class='page_container' data-page=25>

void nlr(tree t, int k, int &sn, int
&tg)
{
if (t!=NULL)
{
if (k<=1)
{
sn++;
tg +=t->data);

}

nlr(t->left, k-1, sn, tg);

nlr(t->right, k-1, sn,
tg);

}
}

float tbc(tree t, int k)
{

int sn, tg;
sn = tg = 0;

nlr(t, k, sn, tg);

if (sn == 0) return 
0.;

</div>
(26)<div class='page_container' data-page=26>

Dụt theo bề rợng (BFS)

• Hay còn gọi là dụt theo mức
• Sử dụng hàng đợi: Tuần tự từ
mức thấp đến cao, từ trái qua
phải

• Với cây trên ta có thứ tự các
nút được duyệt lần lượt:

Q W R T Y U P A
SV cài đặt như bài tập

R
w

T U P

</div>
(27)<div class='page_container' data-page=27>

1. Khởi tạo hàng đợi q rỗng
2. M=0; p=NULL;

3. Nếu t!=NULL
• Đưa p vào q

• Đưa t vào q

4. Khi q!=rỗng

• Lấy p ra khỏi q

• Nếu p==NULL
 Nếu q!=rỗng

• M = M+1;

• Đưa p vào q

• //Xử lý

• Ngược lại

 Xử lý p->data

</div>
(28)<div class='page_container' data-page=28>

Cây tim kiếm nhị phân

(Binary Search Tree – BST)

• Ý nghĩa: Phục vụ tim kiếm nhị phân trên cấu
trúc đợng

• Định nghĩa: Là cây nhị phân thỏa điều kiện mọi
nút đều có khóa

</div>
(29)<div class='page_container' data-page=29>

BST

11
3

1 9 15

</div>
(30)<div class='page_container' data-page=30>

Chèn phần tử vào BST

• Thêm 12

•

15
5

25 40

35
12<

12>

12<

</div>
(31)<div class='page_container' data-page=31>

Chèn phần tử vào BST

void inserttree(tree &t, elem x)
{

if (t==NULL)
{

t = new node;
t->data = x;

</div>
(32)<div class='page_container' data-page=32>

Nhập cây (số nguyên >0)

t = NULL;
do {

cin>>x;
if (x>0)

</div>
(33)<div class='page_container' data-page=33>

Xóa phần tử trên BST

• Xóa 15

15
5

25 40

35
15<

15>

15=

</div>
(34)<div class='page_container' data-page=34>

34
• Xóa 20

15
5

25 40

</div>
(35)<div class='page_container' data-page=35>

void deletetree(tree &t, elem x)
{

if (t!=NULL)
 if (x<t->data)
 deletetree(t->left, x);
 else
if (x>t->data)
 deletetree(t->right, x);
else
{

tree q = t;

if (t->right==NULL)
t = t->left;

else

if (t->left==NULL)
 t = t->right;
else

</div>
(36)<div class='page_container' data-page=36>

36
Tim phần tử thay thế (phần tử lớn nhất)

void del(tree &r, tree &q)
{

if (r->right!=NULL)
del(r->right, q);

else

{

q->data = r->data;
q = r;

</div>
(37)<div class='page_container' data-page=37>

Tim kiếm phần tử trên BST

</div>
(38)<div class='page_container' data-page=38>

Tim kiếm phần tử x

tree searchtree(tree t, elem x)
{

if (t==NULL)

return NULL;
if (x<t->data)

return searchtree(t->left, x);
if (x>t->data)

return searchtree (t->right, x);
return t;

</div>
(39)<div class='page_container' data-page=39>

Cắt cây có gớc x

tree cuttree(tree &t, elem x)
{

if (t==NULL)
return NULL;
if (x<t->data)

return cuttree (t->left, x);
 if (x>t->data)

return cuttree (t->right, x);
{

</div>
(40)<div class='page_container' data-page=40>

void ink(tree t, int &k)
{

if (t!=NULL)
{

if (k>0)

ink(t->right, k);
if (k>0)

{

cout<<setw(4)<<t->data;
k--;

}

if (k>0)

ink(t->left, k);
}

</div>
(41)<div class='page_container' data-page=41></div>
(42)<div class='page_container' data-page=42>

42
• Đưa vào cây:1, 2, 3, …, n

</div>
(43)<div class='page_container' data-page=43>

Định nghĩa

</div>
(44)<div class='page_container' data-page=44>

Định nghĩa

</div>
(45)<div class='page_container' data-page=45>

Biểu diễn cây

</div>
(46)<div class='page_container' data-page=46>

Tổ chức cấu trúc dữ liệu

• Tương tự như BST, tuy nhiên mỗi node cần bổ
sung một vùng bal (balance), ghi nhận trạng 
thái cân bằng tại node đó:

</div>
(47)<div class='page_container' data-page=47>

Mơ tả cấu trúc dữ liệu

typedef struct nodet {
elem data;

struct nodet *left, *right;
int bal;

} node;

</div>
(48)<div class='page_container' data-page=48>

Trạng thái cân bằng tại 1 node

• Tại p có 3 trường hợp:

p->bal = 1 p->bal = 0 p->bal = -1

</div>
(49)<div class='page_container' data-page=49>

a) Trường hợp p->bal = 1

• Thêm vào làm cho hR tăng

hoặc xóa làm cho hL giảm

Đặt p1 = p->right
phép quay:

p->right=p1->left
 p1->left =p

p1 p

</div>
(50)<div class='page_container' data-page=50>

a1) Trường hợp p1->bal = 1

• Thêm vào làm cho hR tăng

hoặc xóa làm cho hL giảm

phép quay đơn:
 p->right=p1->left
 p1->left =p

p->bal =0
p1->bal=0
p = p1

p1 p

</div>
(51)<div class='page_container' data-page=51>

a2) Trường hợp p1->bal = 0

• Chỉ xảy ra khi xóa làm cho hL giảm

phép quay đơn:

p->right=p1->left
 p1->left =p

p->bal =1
p1->bal=-1

p1 p

</div>
(52)<div class='page_container' data-page=52>

a3) Trường hợp p1->bal = -1

• Khơng sử dụng phép quay đơn được vi sẽ mất cân
bằng

phép quay đơn:

p->right=p1->left
 p1->left =p

p1
p

</div>
(53)<div class='page_container' data-page=53>

a3) Trường hợp p1->bal = -1

• Đặt p2 = p1->left

Sử dụng phép quay kép

p->right=p2->left
 p2->left=p

p1->left=p2->right
 p2->right=p1

p->bal=(p2->bal==1? -1: 0)
p1->bal=(p2->bal==-1? 1: 0)

</div>
(54)<div class='page_container' data-page=54>

b) Trường hợp p->bal = -1

• Trường hợp này đới xứng với trường hợp
a), chính vi vậy ta chỉ cần thay

– left thành right và ngược lại

</div>
(55)<div class='page_container' data-page=55>

Chèn phần tử vào AVL

• Tương tự như BST, tuy nhiên sau khi

chèn cây sẽ tăng độ cao, sử dụng biến h
để ghi nhận cây có tăng đợ cao hay

</div>
(56)<div class='page_container' data-page=56>

Ví dụ minh họa

• Thêm lần lượt 3, 5 và 7

3 1

5 7

3 1

5 0

7 0

3
0

Thêm 7

Mất cân bằng tại 3

Sử dụng quay đơn …và cân bằng

3 1

5 1

</div>
(57)<div class='page_container' data-page=57>

Ví dụ minh họa

Thêm 12, 10

5 1

7 1

3
0

12 0

10 0

Thêm 10

5 1

7 1

3
0

12 -1

10 0

</div>
(58)<div class='page_container' data-page=58>

Ví dụ minh họa

• Thêm 11

5 1

10 0/1

3
0

12 0/-1

7
0
11 0
-1
5
0

10
3
0
12
7

0 11 0

</div>
(59)<div class='page_container' data-page=59>

• Thêm 8, 9 ?

-1

0
10

3
0

0 11 0

</div>
(60)<div class='page_container' data-page=60>

void insertAVL(AVLtree &p, elem 
x, int &h)

{

if (p==NULL)
{

p = new node;
p->data = x;

p->left = p->right = NULL;
p->bal=0;
h=1; //true
}
else
if (x<p->data)
{

insertAVL(p->left, x, h);

if (h) Xem lại cân bằng trái tại p;

}
else

if (x>p->data)
{

insertAVL(p->right, x, h);
 if (h) Xem lại cân bằng

phải tại p;

}
else

</div>
(61)<div class='page_container' data-page=61>

Xem lại thế cân bằng trái

switch (p->bal)
{

case 1: p->bal = 0; h = 0; break;
case 0: p->bal = -1; break;

case -1:

{ AVLtree p1 = p->left;
if (p1->bal ==-1)

{

p->left = p1->right;
 p1->right = p;

p->bal = 0;

p = p1; //p->bal =0; h=0
}

else
{

AVLtree p2 = p1->right;
p->left = p2->right;

p2->right = p;

p1->right = p2->left;
p2->left = p1;

p->bal = (p2->bal==-1?1:0);
p1->bal = (p2->bal==1?-1:0);
p = p2; //p->bal =0; h=0

}

p->bal = 0;
h = 0;

</div>
(62)<div class='page_container' data-page=62>

Xem lại thế cân bằng phải

• Trường hợp này đới xứng với trường hợp
xem lại thế cân bằng trái, chính vi vậy ta
chỉ cần thay

– left thành right và ngược lại

– 1 thành -1 và ngược lại

</div>
(63)<div class='page_container' data-page=63>

Xóa phần tử

Xóa 35
0
0
5
0
10
12
7

0 11 0

1
20
25
-1
30
23 0
35
27 0
0
6

0 9 0

-1

</div>
(64)<div class='page_container' data-page=64>

0
10

0 11 0

1
25

27 0

0 9 0

-1

</div>
(65)<div class='page_container' data-page=65>

Xóa phần tử

Xóa 35
0
0
5
-1
10
12
7

0 11 0

1
20
25
-1
30
23 0
35
-1
6

0 9 0

-1

</div>
(66)<div class='page_container' data-page=66>

66
• Mất cân bằng tại 20

1
25

30
0

-1

-1
10

0 11 0

0 9 0

</div>
(67)<div class='page_container' data-page=67>

0
10

-1

5 1

7
0

0 9

0
25

30
0

</div>
(68)<div class='page_container' data-page=68>

Xóa phần tử trên AVL

void deleteAVL(AVLtree &p, elem x, int &h)
{

if (p==NULL)
 h = 0;
else

if (x<p->data)
 {

deleteAVL(p->left, x, h);

if (h) Xem lại thê cân bằng trái tại p

}
 else

if (x>p->data)

{

deleteAVL(p->right, x, h);
 if (h)

Xem lại thê cân bằng phải tại p

}

else
{

AVLtree q = p;

if (p->right==NULL)
 {

p = p->left;
h = 1;

}
 else

if (p->left==NULL)
{

p = p->right;
 h = 1;

}

else
{

del(p->left, q, h);
 if (h)

Xem lại thê cân bằng trái tại p

}
 delete q;
}

</div>
(69)<div class='page_container' data-page=69>

Tim phần tử thay thế

void del(AVLtree &r, AVLtree &q, int &h)
{

if (r->right!=NULL)
{

del(r->right, q, h);

if (h) Xem lại thê cân bằng phải tại r

}
else
{

q->data = r->data;
q = r;

r = r->left;
h = 1;

</div>
(70)<div class='page_container' data-page=70>

Kiểm tra 10%

(đến 11g30)

• Minh họa quá trinh hinh thành cây AVL khi
thêm lần lượt các giá trị sau vào cây (chỉ rõ
phép quay- nếu có):

</div>

hoa cuong có thì sử dụng – thích thì lao vào

Cây

Mợt sớ khái niệm

Phép duyệt

Cây nhị phân (Binary tree)

Duyệt theo bề sâu (DFS)

Duyệt theo bề sâu (DFS)

<i>Ví dụ: Đếm số nút trên cây</i>

<i>Độ cao cây?</i>

<i>Nhập cây số nguyên>0</i>

<i>In cây (số nguyên)</i>

<i>Xóa toàn bộ cây</i>

<i>Đếm số nút lá trên cây</i>

<i>Đếm số nút có 1 con trên cây</i>

<i>Đếm số nút có 1 con trên cây</i>

<i>Đếm số nút có 1 con trên cây</i>

<i>Đếm số nút trong trên cây (không </i>

<i>phải là lá)</i>

Tính trung binh cộng

Bài tập

Đếm số nút trên mức lẻ của cây

Đếm số nút trên mức thứ k

Dụt theo bề rợng (BFS)

Cây tim kiếm nhị phân

<b> (Binary Search Tree – BST)</b>

BST

Chèn phần tử vào BST

Chèn phần tử vào BST

Nhập cây (số nguyên >0)

Xóa phần tử trên BST

Tim kiếm phần tử trên BST

Tim kiếm phần tử x

Cắt cây có gớc x

Định nghĩa

Định nghĩa

Biểu diễn cây

Tổ chức cấu trúc dữ liệu

Mơ tả cấu trúc dữ liệu

Trạng thái cân bằng tại 1 node

a) Trường hợp p->bal = 1

a1) Trường hợp p1->bal = 1

a2) Trường hợp p1->bal = 0

a3) Trường hợp p1->bal = -1

a3) Trường hợp p1->bal = -1

b) Trường hợp p->bal = -1

Chèn phần tử vào AVL

Ví dụ minh họa

Ví dụ minh họa

Ví dụ minh họa

Xem lại thế cân bằng trái

Xem lại thế cân bằng phải

Xóa phần tử

Xóa phần tử

Xóa phần tử trên AVL

Tim phần tử thay thế

Kiểm tra 10%

(đến 11g30)

Tài liệu liên quan

Tài liệu bạn tìm kiếm đã sẵn sàng tải về