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 đơ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 vào: một stack S bất kỳ
Đầ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=”