Xây dựng stack bằng danh sách liên kết đơn pps

Phần 1: Xây dựng stack bằng danh sách liên kết đơnDùng kỷ thuật template để xây dựng một stack có thể lưu trữ bất kỳ... Kiểm tra Stack rỗng?. Mục đích: Kiểm tra một stack S có rỗng không

Phần 1: Xây dựng stack bằng danh sách liên kết đơn

Dùng kỷ thuật template để xây dựng một stack có thể lưu trữ bất kỳ ở đây T là kiểu bất kỳ template <class T> class Stack{

private:

struct Node{

T info;

Node *next;

};

Node *top;

void makeEmpty( ); //Làm rỗng từ 1 stack đã có

public:

Stack( ); // C O N S T R U C T O R

Stack( const Stack & ); // C O P Y C O N S T R U C T O R

~Stack( ); // DES T R U C T O R

bool isEmpty( ) ; //Kiểm tra Stack rỗng?

T & topOfStack( ); //Trả về phần tử ở đỉnh stack

void pop( ); //Lấy ra khỏi stack phần tử ở đỉnh stack

void push( T ); //Thêm 1 phần tử kiểu T vào stack

Stack & operator=( Stack & ); // O V E R L O A D E D "=" O P E R A T O R

};

1 C O N S T R U C T O R

Mục đích: tạo một ngăn xếp rỗng không có phần tử nào

Sử dung: Stack <kiểu> S;

Đầu vào: Không có

Đầu ra: một ngăn xếp S rỗng dùng để chứa kiểu T

Code:

template <class T> Stack<T>::Stack(){

top = NULL;

2 C O P Y C O N S T R U C T O R

Mục đích: tạo một ngăn xếp giống như một ngăn xếp S1 đã có sẵn

Sử dung: Stack <kiểu> S ( S1);

Đầu vào: Ngăn xếp S1 đã tồn tại

Đầu ra: một ngăn xếp S giống như ngăn xếp S1 nhưng dữ liệu ở 2 vị trí bộ nhớ khác nhau Code:

template <class T> Stack<T>::Stack(const Stack &s){

top = NULL;

while(!s.isEmpty()){

this->push(s.topOfStack());

s.pop();

}

}

3 DES T R U C T O R

Mục đích: Hũy một ngăn xếp khi phạm vi sử dụng của nó hết

Sử dung: chương trình tự gọi

template <class T> Stack<T>::~Stack(){

makeEmpty();

}

4 Kiểm tra Stack rỗng?

Mục đích: Kiểm tra một stack S có rỗng không

Sử dụng: S.isEmpty();

Đầu vào: một stack S bất kỳ

Đầu ra: trả về true nếu S không có phần tử nào, ngược lại là false

Code:

template <class T> bool Stack<T>::isEmpty() {

return top == NULL;

5 Trả về giá trị phần tử ở đỉnh stack

Mục đích: Trả về giá trị trên cùng của satck S

Sử dụng: S.topOfStack();

Đầu vào: một stack S bất kỳ

Đầu ra: trả về về giá trị ở đỉnh stack S nếu S không rỗng Code:

template <class T> const T & Stack<T>::topOfStack() {

if(isEmpty())

{cout<<endl<<"empty stack !";

exit(0);}

return top->info;

}

6 Làm rỗng từ 1 stack đã có

Mục đích: Làm rỗng một stack S để tối ưu bộ nhớ khi cần thiết

Sử dụng: S.makeEmpty();

Đầu vào: một stack S bất kỳ

Đầu ra: stack S rỗng

Code:

template <class T> void Stack<T>::makeEmpty(){

while(!isEmpty())

pop();

}

7 Lấy ra khỏi stack phần tử ở đỉnh stack

Mục đích: Loại 1 phần tử của stack S

Sử dụng: S.pop();

Đầu ra: stack S bớt đi phần tử ở đỉnh nếu stack không rỗng Code:

template <class T> void Stack<T>::pop(){

if(isEmpty())

{cout<<endl<<"Stack Empty !"<<endl; exit(0);}

else

{

Node *Otop = top;

top = top->next;

delete Otop;

}

}

8 Thêm 1 phần tử kiểu T vào stack

Mục đích: Thêm 1 phần tử T vào stack S

Sử dụng: S.push(T);

Đầu vào: một stack S bất kỳ và một giá trị có kiểu T

Đầu ra: stack S thêm 1 phần tử mà giá trị của nó là T Code:

template <class T> void Stack<T>::push(T x){

Node *t = new Node;

t->info = x;

t->next = top;

top = t;

9 Operator=

Mục đích: được dùng để gán stack S cho stack T

Sử dụng: T = S;

Đầu vào: một stack S bất kỳ

Đầu ra: stack T giống như stak S nhưng ở vị trí khác trong bộ nhớ

Code:

template <class T> const Stack<T> & Stack<T>::operator =(const Stack<T> &r){

if(*this != &r)

{ makeEmpty();

top = NULL;

*this = r;

} return *this;

}

Chú ý:

Để sử dụng stack ST lưu trữ kiểu bất kỳ T thì khai báo theo cú pháp Stack <T> ST;

đối với những lớp có thuộc tính con trỏ muốn sử dụng template trên thì cần định nghĩa chồng

tóan tử gán “operator=”