Ng«n ng÷ lËp tr×nh vµ cÊu tróc d÷

liÖu víi C/C++

Gi¶ng viªn : Ph¹m Do·n TÜnh
Bé m«n : §iÖn tö tin häc
Khoa : §iÖn tö – ViÔn Th«ng
Tr­êng : §¹i häc B¸ch khoa- Hµ néi
 Ch­¬ng 3’
Cµi ®Æt mét sè cÊu tróc d÷ liÖu víi
C
Gi¶ng viªn : Ph¹m Do·n TÜnh
Bé m«n : §iÖn tö tin häc
Khoa : §iÖn tö – ViÔn Th«ng
Tr­êng : §¹i häc B¸ch khoa- Hµ néi
 C¸c néi dung chÝnh
□ 3’.1 Danh s¸ch liªn kÕt (Linked list)
□ 3’.2 Ng¨n xÕp (Stack)
□ 3’.3 Hµng ®îi (Queue)
□ 3’.4 C©y (Tree)

Object-Oriented Programming (OOP) 3

3’.1 Danh s¸ch liªn kÕt
□ DS liªn kÕt lµ tËp hîp c¸c phÇn tö d÷ liÖu kh«ng liªn tôc ®­îc kÕt nèi
víi nhau th«ng qua 1 liªn kÕt (th«ng th­êng lµ con trá).
□ Cho phÐp ta qu¶n lý bé nhí linh ®éng.
□ C¸c phÇn tö ®­îc chÌn vµo danh s¸ch vµ xo¸ khái danh s¸ch mét c¸ch
dÔ dµng.
□ T¹i mçi nót cã 2 thµnh phÇn:
■ D÷ liÖu trong nót
■ Con trá ®Õn phÇn tö kÕ tiÕp

Danh s¸ch liªn kÕt (Linked List) víi c¸c nót chøa ký tù

A B C D
Trong bé nhí

A 800 B 712 C 992 D 0

100 80 71 99
0 0 2 2
Object-Oriented Programming (OOP) 4
3’.1 Danh s¸ch liªn kÕt
□ §Ó khai b¸o mét DS liªn kÕt trong C, dïng có ph¸p sau:
typedef int Kieu_PT;
struct Node
{
Kieu_PT data;
struct Node *next;
};
□ §Ó thªm mét phÇn tö:
■ CÊp ph¸t nhí cho node
■ §­a sè liÖu vµo node míi
■ Cho node liªn kÕt víi danh s¸ch:
□ Thªm vµo ®Çu
□ Thªm vµo cuèi
□ ChÌn vµo gi÷a DS.

Object-Oriented Programming (OOP) 5

3’.1 Danh s¸ch liªn kÕt
Hea Tail
d
...
NewNod
e
Thªm vµo ®Çu NULL
DS
Hea P
d
...

(1 NULL
(2 )
)
NewNod
ChÌn vµo gi÷a DS sau con trá P e

Object-Oriented Programming (OOP) 6

3’.1 Danh s¸ch liªn kÕt ®«i (Doubly Linked List)
□ B»ng c¸ch thªm vµo mçi node cña danh s¸ch ®¬n 1 con trá “prev”, ta sÏ cã
danh s¸ch liªn kÕt ®«i.
□ Víi DS liªn kÕt ®«i, ta cã thÓ duyÖt DS theo 2 chiÒu kh¸c nhau.
□ ThuËt to¸n ®Ó duyÖt mét DS liªn kÕt:
■ Gi¶ thiÕt DS lµ con trá tíi PhÇn tö ®Çu tiªn trong DS, th×:
while(DS !=NULL)
{
... C¸c thao t¸c trªn Node
DS=DS->next; /* ChuyÓn qua node tiÕp theo */
}

A B C D
NULL
NULL

Object-Oriented Programming (OOP) 7

BµI tËp
□ Cho c¸c th«ng tin vÒ sinh viªn nh­sau:
□ -int Ma_SV, char Ten_SV[35], char Lop[20]
□ VIÕt 1 ch­¬ng tr×nh C thùc hiÖn c¸c viÖc sau (dïng menu):
1. NhËp 1 danh s¸ch SV tõ bµn phÝm vµ l­u vµo 1 danh s¸ch liªn kÕt L.
2. HIÓn thÞ danh s¸ch trªn mµn h×nh d­íi d¹ng b¶ng.
3. Gâ vµo tªn 1 SV vµ t×m xem SV cã trong L hay kh«ng, hiÓn thÞ c¸c
th«ng tin cña SV nµy.
4. Gâ vµo tªn 1 SV vµ xo¸ SV nµy khái L.
5. S¾p xÕp danh s¸ch SV theo chiÒu t¨ng dÇn cña m· SV.
6. NHËp vµo 1 SV cã m· míi vµ chÌn SV nµy vµo ®óng vÞ trÝ sao cho
m· SV vÉn t¨ng dÇn.
7. L­u L ra 1 tÖp trªn ®Üa cã tªn “SV.dat”
8. §äc tõ tÖp “SV.dat” ®Ó x©y dùng L.

Object-Oriented Programming (OOP) 8

VÝ dô: Qu¶n lý Sinh viªn
/* Chuong Trinh Quan ly Sinh Vien
Su dung Sanh sach lien ket
Va co xu ly FILE
*/
#include <stdio.h> /* I/O chuan */
#include <malloc.h> /* Dung cho malloc() */
#include <ctype.h> /* Su dung cho toupper() */
#include <conio.h> /* Dung cho getche() */
#include <stdlib.h> /* Dung cho atoi() */
#include <string.h> /* Dung cho strcmp() */
typedef struct Sinh_Vien /* Cac ban ghi Sinh vien */
{
int Ma_SV;
char Ten_SV[35];
char Lop[20];
Sinh_Vien *next;
};
typedef Sinh_Vien* SV_Node;

Object-Oriented Programming (OOP) 9

void Them_SV(SV_Node &DS,Sinh_Vien SV)
{ /* Them SV vao cuoi DS */
SV_Node tmp,newSV=(Sinh_Vien*)malloc(sizeof(Sinh_Vien));
*newSV=SV;
newSV->next =NULL;
if (DS==NULL)
DS=newSV;/* Phan tu dau tien cua DS */
else
{ /* Them vao cuoi danh sach */
tmp=DS;
while(tmp->next !=NULL) /* Dung lai o nut cuoi cung */
tmp=tmp->next ;
/* Ket thuc while, tmp o PT cuoi */
tmp->next =newSV;
}

Object-Oriented Programming (OOP) 10

Sinh_Vien Nhap_SV()
{
Sinh_Vien sv;
char s[100];
printf("Nhap ma SV:"); gets(s);sv.Ma_SV =atoi(s);
printf("Nhap ten SV:"); gets(sv.Ten_SV);
printf("Nhap Lop:"); gets(sv.Lop);
return sv;
}
void Display_SV(Sinh_Vien const *DS)
{
printf("Danh sach sinh vien!\n");
while(DS !=NULL)
{
printf("%5d%40s%20s\n",DS->Ma_SV,DS->Ten_SV,DS-
>Lop);
DS=DS->next ;
}
}
Object-Oriented Programming (OOP) 11
SV_Node Tim_SV(Sinh_Vien const *DS,char *ten)
{
Sinh_Vien *kq=NULL;
while(DS !=NULL)
if(strcmp(DS->Ten_SV,ten)==0)
{
kq=DS;
break;
}
else
DS=DS->next ;
if(kq!=NULL)
printf("Tim thay!\a\n");
else
printf("Khong Tim thay!!!\a\n");
return kq;
}

Object-Oriented Programming (OOP) 12

bool Xoa_SV(SV_Node &DS,char *ten)
{ bool kq=false;
SV_Node tmp=DS,delNode;
if(DS!=NULL)
{ if(strcmp(tmp->Ten_SV,ten)==0) /* Kiem tra node dau tien */
{ delNode=DS;
DS=DS->next;
free(delNode);
kq=true; }
else /* Duyet cac Node con lai */
while(tmp->next !=NULL)
if (strcmp(tmp->next ->Ten_SV,ten)==0)
{ delNode=tmp->next ;
tmp->next =tmp->next->next;
free(delNode);
kq=true;
break; }
else
tmp=tmp->next; }
return(kq);
}

Object-Oriented Programming (OOP) 13

void Ghi_File(char *fn,SV_Node DS)
{
FILE *f=fopen(fn,"w+b");
Sinh_Vien sv;
if (f==NULL)
printf("Khong mo duoc File!\n");
else
{
while(DS!=NULL)
{
fwrite(DS,sizeof(Sinh_Vien),1,f);
DS=DS->next;
}
fclose(f);
}
}

Object-Oriented Programming (OOP) 14

void Doc_File(char *fn,SV_Node &DS)
{
FILE *f=fopen(fn,"rb");
Sinh_Vien sv;
if (f==NULL)
printf("Khong mo duoc File!\n");
else
{
while(fread(&sv,sizeof(Sinh_Vien),1,f)==1)
Them_SV(DS,sv);
fclose(f);

}
}

Object-Oriented Programming (OOP) 15

void main()
{
struct Sinh_Vien *LIST=NULL;
char yesno='n',ten[100];
do
{
printf("1. Them Sinh Vien\n");
printf("2. Xoa Sinh Vien\n");
printf("3. Tim Sinh Vien\n");
printf("4. In Danh Sach Sinh Vien\n");
printf("5. Ghi Danh Sach ra File\n");
printf("6. Doc Danh Sach tu File\n");
printf("7. Thoat chuong trinh\n");
printf("Hay chon (1,2,3,4,5,6,7):");yesno=toupper(getche());

Object-Oriented Programming (OOP) 16

switch(yesno)
{
case '1': Them_SV(LIST,Nhap_SV()); break;
case '2': printf("Go ten SV can xoa:");gets(ten);
if(Xoa_SV(LIST,ten))
printf("Da xoa!\n");
else
printf("Khong thay!\n");
break;
case '3': printf("Go ten SV can tim:");gets(ten);
Tim_SV(LIST,ten);
break;
case '4': Display_SV(LIST); break;
case '5': Ghi_File("danhsach.dat",LIST); break;
case '6': Doc_File("danhsach.dat",LIST); break;
default:
printf("Hay chon lai!\n");
} /* End of switch() */
} while(yesno !=‘7');
} /* End of main() */

Object-Oriented Programming (OOP) 17

3’.2 Ng¨n xÕp (Stack)
□ Ng¨n xÕp lµ mét tËp hîp c¸c phÇn tö cã tr×nh tù, c¸c phÇn tö ra/vµo
stack t¹i mét ®iÓm gäi lµ “§Ønh ng¨n xÕp” (stack-top).
□ C¸c phÇn tö vµo/ra theo nguyªn t¾c LIFO – Vµo sau ra tr­íc (Last-In-
First-Out).
□ Stack cã c¸c thao t¸c c¬ b¶n lµ push,pop vµ con trá “top”.
□ Ngoµi ra cã thÓ cã c¸c hµm kh¸c nh­:
■ initialize() khëi t¹o stack
pus pop,
■ isEmpty()
h top
Ng¨n xÕp cã rçng kh«ng?
□ §Ó x©y dùng mét ng¨n xÕp cã thÓ dïng:
■ M¶ng kÕt hîp víi mét biÕn nguyªn Stac
“top” l­u vÞ trÞ trªn cïng cña ng¨n xÕp. k
■ Danh s¸ch liªn kÕt víi thuËt to¸n:
chÌn vµo ®Çu/ xo¸ khái ®Çu danh s¸ch

Object-Oriented Programming (OOP) 18

3’.2 Ng¨n xÕp (Stack) – C¸c øng dông cña Stack
□ Stack cã rÊt nhiÒu øng dông trong thùc tÕ vµ lý thuyÕt vµ ®Æc biÖt
lµ trong khoa häc m¸y tÝnh.
□ Mét trong nh÷ng øng dông cña stack ta cã thÓ kÓ ®Õn lµ chuyÓn
®æi vµ tÝnh to¸n gi¸ trÞ cho mét biÓu thøc.
Trong to¸n häc ta cã thÓ biÓu diÔn mét biÓu thøc d­íi d¹ng
■ Trung tè (infix):

To¸n_H¹ng To¸n_Tö To¸n_H¹ng

■ HËu tè (postfix):
To¸n_H¹ng To¸n_H¹ng To¸n_Tö
VÝ dô:
infix postfix
A+B*C --> ABC * +
(A + B) * C --> AB + C *
Object-Oriented Programming (OOP) 19
3’.2 Ng¨n xÕp (Stack) – C¸c øng dông cña Stack
□ Trong c¸ch biÓu diÔn Postfix, ta kh«ng thÊy xuÊt hiÖn c¸c dÊu
ngoÆc ( ).
□ C¸c to¸n tö:
■ + céng – Trõ * Nh©n / Chia ®­îc kÕt hîp tõ tr¸i sang
■ To¸n tö hµm mò ^ th× ®­îc kÕt hîp tõ ph¶i sang.
□ C¸ch tÝnh biÓu thøc postfix:
■ NÕu ®äc ®­îc to¸n h¹ng, ®Èy nã lªn stack
■ Khi gÆp to¸n tö, ®äc ra 2 to¸n h¹ng trªn cïng cña stack vµ
thùc hiÖn tÝnh to¸n víi to¸n tö.
■ §Èy kÕt qu¶ trªn lªn stack vµ tiÕp tôc thùc hiÖn ®Õn khi ®äc
hÕt biÓu thøc.
□ Ngoµi ra stack cßn cã kh¸ nhiÒu øng dông kh¸c n÷a. VÝ dô d­íi
®©y øng dông stack trong viÖc chuyÓn ®æi c¬ sè:

Object-Oriented Programming (OOP) 20

BµI tËp
□ NhËp 1 biÓu thøc (d¹ng infix) tõ bµn phÝm vµ chuyÓn nã sang d¹ng
postfix. TÝnh gi¸ trÞ biÓu thøc nµy.
□ VD: A=2*3^3 + 5*6^2 – 7*8^5

Object-Oriented Programming (OOP) 21

VÝ dô: §æi c¬ sè dïng Stack
#include <stdio.h>
#include <malloc.h>
typedef struct Node
{
int data;
Node *next;
};
typedef struct Stack
{
Node *top;
};
void Khoi_Tao(Stack &s)
{
s.top =NULL;
}

Object-Oriented Programming (OOP) 22

void Push(Stack &s,int pt)
{
Node *tmp=(Node*)malloc(sizeof(Node));
tmp->data =pt;
if(s.top ==NULL) /* Phan tu dau tien */
{
s.top =tmp;
s.top->next =NULL;
}
else /* Phan tu tiep theo */
{
tmp->next =s.top;
s.top =tmp;
}

Object-Oriented Programming (OOP) 23

bool isEmpty(Stack s)
{
return (s.top==NULL);
}
void Pop(Stack &s,int &pt)
{
if (!isEmpty(s))
{
pt=s.top->data ;
s.top=s.top->next ;
}
}

Object-Oriented Programming (OOP) 24

void main() /* Quy doi co so 10 ra nhi phan */
{
Stack S;
Khoi_Tao(S);
int a,pt,du;
printf("Nhap vao so he 10:");scanf("%d",&a);
while((a/2)>0)
{
Push(S,a%2);
a=a/2;
}
Push(S,a);
printf("Bieu dien duoi dang nhi phan:\n");
while(!isEmpty(S))
{
Pop(S,pt);
printf("%1d",pt);
}
printf("\n");
}

Object-Oriented Programming (OOP) 25

3’.3 Hµng ®îi (Queue)
□ Hµng ®îi lµ mét tËp hîp ®éng gåm c¸c phÇn tö vµo/ra mét c¸ch cã
trËt tù. Th«ng th­êng viÖc vµo/ra tu©n theo nguyªn t¾c FIFO (First-In-
First-Out Vµo tr­íc ra tr­íc).
□ Trong hµng ®îi cã 2 ®iÓm lµ “front” - ®Çu hµng ®îi vµ “rear” – cuèi
hµng ®îi.
□ Khi 1 phÇn tö míi ra nhËp hµng ®îi t¹i “rear” ta gäi lµ “enqueue” vµ 1
phÇn tö rêi hµng ®îi t¹i “front” ta gäi lµ “dequeue”.
□ Khi cµi ®Æt hµng ®îi cã thÓ sö dông:
■ M¶ng kÕt hîp víi 2 biÕn nguyªn “front” vµ “rear” ®Ó ®iÒu khiÓn
vÞ trÝ ®Çu vµ cuèi danh s¸ch.
■ Danh s¸ch liªn kÕt víi thuËt to¸n thªm vµo cuèi, xo¸ t¹i ®Çu danh
s¸ch sÏ cho ta hµng ®îi nh­mong muèn.
□ Ngoµi hµng ®îi th«ng th­êng FIFO, thùc tÕ cßn cã hµng ®îi cã tÝnh
®Õn møc ®é ­u tiªn cña c¸c phÇn tö lóc ®ã ta cã “priority queue”.

Object-Oriented Programming (OOP) 26

3’.4 C©y (tree)

□ C©y lµ mét tróc d÷ liÖu ®Æc biÖt bao gåm 1 hoÆc nhiÒu phÇn tö d÷
liÖu liªn kÕt víi nhau th«ng qua con trá. C¸c phÇn tö d÷ liÖu nµy gäi lµ
c¸c nót (Node) cña c©y.
□ Mét nót ®¬n lÎ lµ mét c©y!
□ C©y tæng qu¸t bao gåm:
■ Mét nót gèc r vµ
■ Kh«ng tån t¹i hoÆc tån t¹i nhiÒu c©y con (sub-tree) T1,T2,...Tk.
Trong ®ã gèc cña nh÷ng c©y con nµy ®­îc nèi víi gèc r.
■ Gèc cña c¸c c©y T1,T2,...Tk ®­îc gäi lµ c¸c con (children) cña r .
■ r ®­îc gäi lµ cha (parent) cña c¸c gèc nµy.
■ C¸c nót ®­îc sinh ra tõ 1 cha gäi lµ anh em (siblings).

Object-Oriented Programming (OOP) 27

3’.4 C©y (tree)
□ Nót l¸ (leaf): Lµ nót mµ t¹i ®ã kh«ng tån t¹i c¸c c©y con.
□ §­êng dÉn (Path): §­êng gi÷a 2 nót 1 vµ k lµ thø tù n1,n2,...,nk sao cho ni lµ
cha cña ni+1 víi i=1-k.
□ DuyÖt c©y (Tree-Traveral):
Cã 3 ph­¬ng ph¸p duyÖt c©y c¬ b¶n
1) PreOrder:
□ ViÕng th¨m nót gèc r
□ ViÕng th¨m ®Ö quy cïng thuËt to¸n PreOrder c¸c c©y con
T1,T2,...,Tk.
2) PostOrder:
□ ViÕng th¨m ®Ö quy c¸c nh¸nh T1,T2,...,Tk theo thuËt to¸n
PostOrder.
□ ViÕng th¨m nót gèc r.
3) InOrder:
□ ViÕng th¨m ®Ö quy nh¸nh tr¸i cña r lµ T1 theo thuËt to¸n InOrder
□ ViÕng th¨m nót gèc r.
□ ViÕng th¨m ®Ö quy c¸c nh¸nh cßn l¹i theo thuËt to¸n InOrder.

Object-Oriented Programming (OOP) 28

3’.5 C©y nhÞ ph©n (binary tree)
□ D¹ng ®¬n gi¶n nhÊt cña c©y lµ c©y nhÞ ph©n. roo
□ §Þnh nghÜa t
C©y nhÞ ph©n gåm cã: lef righ
■ 1 nót (gäi lµ gèc – root) vµ t t
■ C¸c c©y con tr¸i (left) vµ c©y con ph¶i (right), b¶n th©n c¸c c©y
con nµy còng lµ c©y nhÞ ph©n.
□ C©y nhÞ ph©n cã trËt tù:
■ Gi¸ trÞ kho¸ cña tÊt c¶ c¸c nót ë nh¸nh tr¸i nhá h¬n gi¸ trÞ kho¸
cña nót gèc.
■ Gi¸ trÞ kho¸ cña tÊt c¶ c¸c nót ë nh¸nh ph¶i lín h¬n gi¸ trÞ kho¸
cña nót gèc.
■ B¶n th©n c¸c c©y con tr¸i vµ ph¶i còng lµ nh÷ng c©y nhÞ ph©n
cã trËt tù.

Object-Oriented Programming (OOP) 29

3’.5 C©y nhÞ ph©n (binary tree)
struct TreeNode;
typedef struct TreeNode* PtrToNode;
typedef struct TreeNode *Position;
typedef struct TreeNode *SearchTree;
typedef PtrToNode Tree;

struct TreeNode
{
ElementType Element;
Tree Left;
Tree Right;
};

Object-Oriented Programming (OOP) 30

PreOrder
void pretrav(PtrToNode tree)
{
if (tree != NULL) {
printf("%d\n", tree->Element); /* Tham root */
pretrav(tree->Left); /* Tham nhanh trai */
pretrav(tree->Right); /* Tham nhanh phai*/
} /* end if */
} /* end pretrav */

Object-Oriented Programming (OOP) 31

InOrder
void intrav(PtrToNode tree)
{
if (tree != NULL) {
intrav(tree->left); /* Tham nhanh trai */
printf("%d\n", tree->info); /* Tham goc */
intrav(tree->right); /* Tham nhanh phai */
} /* end if */
} /* end intrav */

Object-Oriented Programming (OOP) 32

PostOrder
void posttrav(PtrToNode tree)
{
if (tree != NULL) {
posttrav(tree->left); /* Tham nhanh trai */
posttrav(tree->right); /* Tham nhanh phai*/
printf("%d\n", tree->info); /* Tham goc */
} /* end if */
} /* end posttrav */

Object-Oriented Programming (OOP) 33

Bµi tËp
ViÕt 1 ch­¬ng tr×nh C thùc hiÖn c¸c viÖc sau:
1. NhËp vµo 1 d·y sè nguyªn kh«ng trïng nhau vµ l­u vµo trong 1 c©y
nhÞ ph©n cã trËt tù.
2. HiÓn thÞ c©y nhÞ ph©n dïng thuËt to¸n InOrder.
3. NhËp vµo 1 sè vµ h·y thùc hiÖn:
1. T×m xem sè ®ã cã tån t¹i hay kh«ng?
2. Xo¸ sè nµy khái c©y nhÞ ph©n? (Khã)

Object-Oriented Programming (OOP) 34