c++链表的实现及栈队列

链表的源代码实现:

typedef int T;

class List

{

private:

struct Node

{

T data;

Node* next;

Node(const T& t=T()):data(t)

{

next=NULL;

}

};

//头节点

Node* head;

public:

List():head(NULL){}

//清除所有的节点

void clear()

{

while (NULL!=head)

{

Node *q=head->next;

delete head;

head=q;

}

}

//析构函数调用clear()

~List()

{

clear();

}

//在链表最前面插入

void insert_front(const T& t)

{

Node* p=new Node(t);

p->next=head;

head=p;

}

//在链表的最后面插入

void insert_back(const T& t)

{

Node* p=new Node(t);

if (NULL==head)

{

head=p;

}

else

{

getPointer(size()-1)->next=p;

}

}

//遍历所有的节点

void travel()

{

Node* p=head;

while (NULL!=p)

{

cout<<p->data<<' ';

p=p->next;

}

cout<<endl;

}

//获得链表的元素个数

int size()

{

int cnt=0;

Node* p=head;

while (NULL!=p)

{

cnt++;

p=p->next;

}

return cnt;

}

//获得链表中头节点中的数据

T getHead()

{

if (NULL==head)

{

throw "No head";

}

return head->data;

}

//获得链表中末节点中的数据

T getTail()

{

if (NULL!=head)

{

throw "No tail";

}

Node *p=head;

while(NULL!=p->next)

{

p=p->next;

}

cout<<p->data;

}

//判断链表是否为空

bool empty()

{

return NULL==head;

}

//在链表中查找数据,返回值是要查找的数据在链表中的位置,从0开始计数

int find(const T& t)

{

int pos=0;

Node* p=head;

while (NULL!=p)

{

if (p->data==t)

{

return pos;

}

p=p->next;

pos++;

}

return -1;

}

//更新某个节点上的数据

bool update(const T& o,const T& n)

{

int pos=find(o);



if (-1==pos)

{

return false;

}

Node* p=getPointer(pos);

p->data=n;

return true;

}

//获得pos位置上的节点

Node* getPointer(const int pos)

{

Node* p=head;

for(int i=0;i<pos;i++)

{

p=p->next;

}

return p;

}

//删除节点数据是t的节点

bool earse(const T& t)

{

int pos=find(t);

if (-1==pos)

{

return false;

}

if (0==pos)

{

Node* q=head->next;

delete head;

head=q;

return true;

}

else

{

Node* pre=getPointer(pos-1);

Node* cur=pre->next;

pre->next=cur->next;

delete cur;

return true;

}

};

========================================

栈的源代码实现:

class Stack

{

private:

List l;

public:

//在栈中插入数据,即在链表的最前面插入节点

void push(const T &t)

{

l.insert_front(t);

}

//删除栈顶节点,即删除链表中的头节点

void pop()

{

l.earse(l.getHead());

}

//取出栈顶中的数据,即取出链表中头节点中的数据

T top()

{

return l.getHead();

}

//判断栈是否为空

bool empty()

{

return l.empty();

}

//取得栈中的元素个数

int size()

{

return l.size();

}

//清空整个栈

void clear()

{

l.clear();

}

};

============================================================

队列的源代码实现::

class Queue

{

private:

List l;

public:

//数据入队,即在链表的末尾插入数据节点

void push(const T &t)

{

l.insert_back(t);

}

//数据出队,即在链表的开始删除数据节点

void pop()

{

l.earse(l.getHead());

}

//取得队首元素,即获得链表的头节点

T front()

{

return l.getHead();

}

//取得队尾元素,即获得链表的未节点

T back()

{

return l.getTail();

}

//判断队列是否为空

bool empty()

{

return l.empty();

}

//获得队列的元素个数

int size()

{

return l.size();

}

//清空整个队列

void clear()

{

l.clear();

}

};