STACK & QUEUE NGĂN XẾP & HÀNG ĐỢI doc

STACK & QUEUE
NGĂN XẾP & HÀNG ĐỢI
Nội dung
•
Trình bày khái niệm Stack và Queue
•
Minh họa các ứng dụng
•
Các phương pháp xây dựng Stack và Queue dựa trên những cấu trúc dữ
liệu đã biết
•Stack
–
Ví dụ
–
Định nghĩa
–
Các thao tác cơ bản
–
Xây dựng Stack
•Queue
–
Ví dụ
–
Định nghĩa
–
Các thao tác cơ bản
–
Xây dựng Queue
Ngăn xếp (Stack)
Chồng khay
cà phê

Chồng tiền
xu
Chồng sách Chồng áo sơ
mi
Các ví dụ về Ngăn xếp
Ngăn xếp - Định nghĩa
•
Stack là 1 cấu trúc:
•
gồm nhiều phần tử có thứ tự
•
hoạt động theo cơ chế “Vào sau – Ra trước” (LIFO – Last In, First
Out)
Đỉnh
ngăn
xếp
Ngăn xếp - Định nghĩa
•
Các thao tác cơ bản trên Stack:
•
InitStack: khởi tạo Stack rỗng
•
IsEmpty: kiểm tra Stack rỗng ?
•
IsFull: kiểm tra Stack đầy ?
•
Push: thêm 1 phần tử vào đỉnh Stack, có thể làm Stack đầy
•
Pop: lấy ra 1 phần tử từ đỉnh Stack, có thể làm Stack rỗng
•

StackTop: kiểm tra phần tử đầu Stack
Push Pop
Ngăn xếp
•
Minh họa thao tác Push
Data
Top
Ngăn xếp
•
Minh họa thao tác Pop
Data
Top
Ngăn xếp
•
Minh họa thao tác StackTop
 Ngăn xếp không thay đổi
Data
Top
?
?
Ngăn xếp
•
Có hai cách để xây dựng ngăn xếp
•
Sử dụng mảng 1 chiều
•
Sử dụng danh sách liên kết đơn
Mảng 1 chiều Danh sách liên kết đơn
- Viết chương trình dễ dàng,
nhanh chóng

- Bị hạn chế do số lượng
phần tử cố định
- Tốn chi phí tái cấp phát và
sao chép vùng nhớ nếu sử
dụng mảng động
Phức tạp khi triển khai
chương trình
Không bị cố định về số phần
tử, phụ thuộc vào bộ nhớ
Ngăn xếp – Sử dụng mảng
9
3
6
9 3 6
0 1 2 3 4 5 6 7 8 9
Xây dựng ngăn xếp bằng mảng 1 chiều
Ngăn xếp có 3 phần tử
StkTop
Đỉnh ngăn xếp
Stack
Stack
Top
Top
Ngăn xếp – Sử dụng mảng
•
// Giả sử Stack chứa các phần tử kiểu
nguyên
•
// (int) - Khai báo cấu trúc Stack
struct STACK {

int* StkArray; // mảng chứa các phần tử
int StkMax; // số phần tử tối đa
int StkTop; // vị trí đỉnh Stack
};
Ngăn xếp – Sử dụng mảng
•
Thao tác “Khởi tạo Stack rỗng”
int InitStack(STACK& s, int MaxItems)
{
s.StkArray = new int[MaxItems];
if (s.StkArray == NULL)
return 0; // Không cấp phát được bộ nhớ
s.StkMax = MaxItems;
s.StkTop = -1; // chưa có phần tử nào trong Stack
return 1; // khởi tạo thành công
}
Ngăn xếp – Sử dụng mảng
•
Thao tác “Kiểm tra Stack rỗng”
int IsEmpty(const STACK &s)
{
if (s.StkTop==-1)
return 1; // Stack rỗng
return 0; // Stack không rỗng
}
Ngăn xếp – Sử dụng mảng
•
Thao tác “Kiểm tra Stack đầy”
int IsFull(const STACK &s)
{

if (s.StkTop==s.StkMax-1)
return 1; // Stack đầy
return 0; // Stack chưa đầy
}
Ngăn xếp – Sử dụng mảng
•
Thao tác “Push”: thêm một phần tử vào đỉnh
Stack
int Push (STACK& s, int newitem)
{
if (IsFull(s))
return 0; // stack đầy, không thể thêm
s.StkTop++;
s.StkArray[s.StkTop] = newitem;
return 1; // thêm thành công
}
Ngăn xếp – Sử dụng mảng
•
Thao tác “Pop”: lấy ra 1 phần tử từ đỉnh Stack
int Pop(STACK& s, int& outitem)
{
if (IsEmpty(s))
return 0; // Stack rỗng, không lấy ra được
outitem = s.StkArray[s.StkTop];
s.StkTop ;
return 1; // lấy ra thành công
}
Ngăn xếp – Sử dụng mảng
•
Thao tác “StackTop”: kiểm tra 1 phần tử ở đỉnh Stack, không làm thay

đổi Stack
int StackTop(const STACK s, int& outitem)
{
if (IsEmpty(s))
return 0; // Stack rỗng, không lấy ra được
outitem = s.StkArray[s.StkTop];
return 1; // lấy ra thành công
}
Ngăn xếp – Ví dụ ứng dụng
•
Kiểm tra sự tương ứng của các cặp ngoặc đơn trong một biểu thức
•
( ( A + B ) / C ( A + B ) / C)
•
Đảo ngược một chuỗi ký tự
•
Cá Ăn Kiến  nếiK nĂ áC
? ?
Ngăn xếp – Sử dụng DSLK
9
7
4

N
StkCnt StkTop
7
Data Link
9
Data Link


4
Data Link
Ngăn xếp – Sử dụng DSLK
•
Cấu tạo đầu stack
•
Cấu tạo một phần tử trong stack
N
StkCnt StkTop
Data Link
stack
StkCnt <integer>
StkTop <node pointer>
end stack
node
Data <datatype>
Link <node pointer>
end node
Ngăn xếp – Sử dụng DSLK
// Khai báo cấu trúc một phần tử trong stack
struct NODE {
int Data;
NODE *pNext;
} ;
// Khai báo cấu trúc stack
struct STACK {
int StkCount;
NODE *StkTop;
};
Ngăn xếp – Sử dụng DSLK

•
VD: Thực hiện một số thao tác trên stack
STACK s;
InitStack(s);
Push(s, 7);
Push(s, 4);
Pop(s, x); // x = ?
N
StkCnt StkTop
7
Data Link
4
Data Link
Ngăn xếp – Sử dụng DSLK
•
Thao tác “Khởi tạo stack rỗng”:
void InitStack(STACK& s)
{
s.StkTop = NULL;
s.StkCount = 0;
}
Ngăn xếp – Sử dụng DSLK
•
Thao tác “Kiểm tra stack rỗng”:
int IsEmpty(const STACK& s)
{
if (s.StkTop == NULL)
return 1; // stack rỗng
return 0; // stack không rỗng
}

Ngăn xếp – Sử dụng DSLK
•
Thao tác “Kiểm tra stack đầy”:
int IsFull (const STACK s)
{
// thử tạo mới một phần tử
STACK_NODE* temp = new STACK_NODE;
// nếu không tạo được

stack đầy
if (temp == NULL)
return 1; // stack đầy
delete temp;
return 0; // stack chưa đầy
}