链式存储结构的基本操作

1、线性表的链表实现：插入、删除、翻转

2、链式堆栈的实现

3、链式队列的基本操作

实验目的：掌握单链表，链式堆栈，链式队列的定义及基本操作

实验内容：

（1）用带表头的链表存放输入的数据，每读入一个数，按升序顺序插入到链表中，链表中允许两个结点有相同值。链表的头结点存放链表后面的结点个数，初始化时就生成头结点（初值为0）。链表翻转是把数据逆序（变成降序），注意，头结点不动。翻转后要再翻转一次，恢复升序后才能插入新元素，否则会出错

（2）先定义堆栈的几个基本操作，再设计一主函数利用堆的操作完成以下功能：假设一个算术表达式中可以包含三种括号：()[]{}，且这三种括号可以按任意次序嵌套使用（如：...[...{...}...[...]...]...(...)）。编写判别给定表达式中所含括号是否正确配对出现的算法，已知表达式已存入数据元素为字符的单链表中。

（3）先定义队列的几个基本操作，再设计一主函数利用队列的操作完成以下功能：键盘输入的字符可以临时存入键盘的缓冲区中。为了充分利用缓冲区的空间，往往将缓冲区设计成链式循环队列的结构，并为循环队列结构的缓冲区设置一个队首指针和一个队尾指针。每输入一个字符到缓冲区中，就将尾指针后移，链入缓冲区的循环队列之中；每输出一个字符号，就将队头指针前移，将它从缓冲队列中删除。假设有两个进程同时存在于一个应用程序中，第一个进程连续在屏幕上显示字符“X”，第二个进程不断检查键盘上是否有输入，若有则读入用户键入的字符，将其保存到键盘缓冲区中。

（1）//LinList.h

template class LinList; //前视定义,否则友元无法定义

template //模板类型为T

class ListNode

{

friend class LinList; //定义类LinList为友元

friend void LinListSort(LinList &L);

private:

ListNode *next; //指向下一结点的指针

T data; //定义为公有成员方便使用

int size;

public:

//构造函数1,用于构造头结点

ListNode(ListNode *ptrNext = NULL)

{size=0;next = ptrNext;}

//构造函数2,用于构造其他结点

ListNode(const T& item, ListNode *ptrNext = NULL)

{data = item; next = ptrNext; }

~ListNode(void){} //析构函数

};

//单链表类的定义

template

{

friend void LinListSort(LinList &L);

private:

ListNode *head; //头指针

int size; //当前的数据元素个数

ListNode *Index(int i); //定位

public:

LinList(void); //构造函数

~LinList(void); //析构函数

int ListSize(void) const; //取当前数据元素个数

void Insert(const T& item, int i); //前插

T Delete(int i); //删除

T GetData(int i); //取元素

void OrderInsert(T x);

void Converse(void);

};

//单链表类的实现

template

LinList::LinList(void) //构造函数

{

head = new ListNode(); //头指针指向头结点

size = 0; //size的初值为0

}

template

LinList::~LinList(void) //析构函数

{

ListNode *p, *q;

p = head; //p指向第一个结点

while(p != NULL) //循环释放结点空间直至初始化状态 {

q = p;

p = p->next;

delete q;

}

size = 0; //结点个数置为初始化值0

head = NULL;

}

template

ListNode *LinList::Index(int i) //定位

//返回指向第i个数据元素结点的指针

//参数i的取值范围为：-1≤i≤size-1；i=-1时返回头指针

{

if(i < -1 || i > size-1)

{

cout << "参数i越界出错！" << endl;

exit(0);

}

if(i == -1) return head; //i为-1时返回头指针head

ListNode *p = head->next; //p指向第一个数据元素结点

int j = 0; //从0开始计数

while(p != NULL && j < i) //寻找第i个结点

{

p = p->next;

j++;

}

return p; //返回第i个结点的指针

}

template

int LinList::ListSize(void) const //取当前数据元素个数并返回{

return size;

}

template

void LinList::Insert(const T& item, int i) //插入

//在第i个结点后插入一个元素值为item的新结点

//参数i的取值范围为：0≤i≤size

{

if(i < 0 || i > size)

{

cout << "参数i越界出错！" << endl;

exit(0);

}

ListNode *p = Index(i - 1); //p为指向第i-1个结点的指针

//构造新结点p，p的data域值为item，next域值为p->next

ListNode *q = new ListNode(item, p->next);

p->next = q; //新结点插入第i个结点前

size++; //元素个数加1

}

template

T LinList::Delete(int i) //删除

//删除第i个数据元素并返回。参数i的取值范围为：0≤i≤size-1 {

{

cout << "链表已空无元素可删！" << endl;

exit(0);

}

if(i < 0 || i > size-1)

{

cout << "参数i越界出错！" << endl;

exit(0);

}

ListNode *s, *p = Index(i - 1); //p为指向第i-1个结点指针 s = p->next; //s指向第i个结点

p->next = p->next->next; //第i个结点脱链

T x = s->data;

delete s; //释放第i个结点空间

size--; //结点个数减1

return x; //返回第i个结点的data域值

}

template

T LinList::GetData(int i) //取数据元素

//取第i个数据元素并返回。参数i的取值范围为：0≤i≤size-1 {

if(i < 0 || i > size-1)

{

cout << "参数i越界出错！" << endl;

exit(0);

}

ListNode *p = Index(i); //p指向第i个结点

return p->data;

}

template

void LinList::OrderInsert(T x)

//数据元素x有序插入

{

ListNode *curr, *pre;

//循环初始化

curr = head->next; //curr指向第一个数据元素结点

pre = head; //pre指向头结点

//定位插入位置

while(curr != NULL && curr->data <= x)

{

curr = curr->next;

}

//申请一个结点并赋值

ListNode *q = new ListNode(x, pre->next);

pre->next = q; //把新结点插入pre所指结点后

size++;

}

template

void LinList::Converse(void)

{

ListNode *p, *q;

p = head->next;

head->next = NULL;

while(p != NULL)

{

q = p;

p = p->next;

q->next = head->next;

head->next = q;;

}

}

//LinList.cpp

#include

#include

#include "LinList.h"

void main(void)

{

LinList myList;

int s[] = {1,2,3,4,5,6,7,8,9,10}, n = 10;

int k[] = {1,4,3,6,9,7}, m = 6;

int temp;

for(int i = 0; i < n; i++) //为链表赋值

myList.OrderInsert(s[i]);

cout<<"升序插入数据:"<

for(i = 0; i < myList.ListSize(); i++) //测试Delete()和Insert()的最坏情况

{

temp = myList.GetData(i);

cout << temp << " ";

}

myList.Converse();

cout << endl;

cout<<"链表翻转:"<

for(i = 0; i < myList.ListSize(); i++) //测试Delete()和Insert()的最坏情况 {

temp = myList.GetData(i);

cout << temp << " ";

}

myList.Converse();

for(int j = 0; j < m; j++) //为链表赋值

myList.OrderInsert(k[j]);

myList.Converse();

cout << endl;

cout<<"链表翻转后插入新数据:"<

for(i = 0; i < myList.ListSize(); i++) //测试Delete()和Insert()的最坏情况 {

temp = myList.GetData(i);

cout << temp <<" ";

}

cout<

}

（2）//LinStack.h

template class LinStack; //前视定义,否则友元无法定义template //模板类型为T

class StackNode

{

friend class LinStack; //定义类LinStack为友元

private:

T data; //数据元素

StackNode *next; //指针

public:

//构造函数1,用于构造头结点

StackNode(StackNode *ptrNext = NULL)

{next = ptrNext;}

//构造函数2,用于构造其他结点

StackNode(const T& item, StackNode *ptrNext = NULL)

{data = item; next = ptrNext;}

~StackNode(){};

};

template

class LinStack

{

private:

StackNode *head; //头指针

int size; //数据元素个数

public:

LinStack(void); //构造函数

~LinStack(void); //析构函数

void Push(const T& item); //入栈

T Pop(void); //出栈

T GetTop(void)const; //取栈顶元素

int NotEmpty(void) const; //堆栈非空否

};

//堆栈类的实现

template

LinStack::LinStack() //构造函数

{

head = new StackNode; //头指针指向头结点 size = 0; //size的初值为0

}

template

LinStack::~LinStack(void) //析构函数

//释放所有动态申请的结点空间

{

StackNode *p, *q;

p = head; //p指向头结点

while(p != NULL) //循环释放结点空间

{

q = p;

p = p->next;

delete q;

}

}

template

int LinStack::NotEmpty(void) const //堆栈非空否{

if(size != 0) return 1;

else return 0;

}

template

void LinStack::Push(const T& item) //入栈

{

//新结点newNode的data域值为item，next域值为head->next

StackNode *newNode = new StackNode(item, head->next); head->next = newNode; //新结点插入栈顶

size++; //元素个数加1

}

template

T LinStack::Pop(void) //出栈

{

if(size == 0)

{

cout << "堆栈已空无元素可删！" << endl;

exit(0);

}

StackNode *p = head->next; //p指向栈顶元素结点

T data = p->data;

head->next = head->next->next; //原栈顶元素结点脱链

delete p; //释放原栈顶结点空间

size--; //结点个数减1

return data; //返回原栈顶结点的data域值

}

template

T LinStack::GetTop(void)const //取栈顶元素

{

return head->next->data;

}

//LinStack.cpp

#include

#include

#include

#include

void main()

//判断有n个字符的字符串exp左右括号是否配对正确

LinStack myStack; //定义顺序堆栈类对象myStack char exp[100];

int i;

cout<<"请输入一组表达式（以#结束）："<

for(i=0;i<100;i++)//输入表达式

{

cin>>exp[i];

if(exp[i]=='#')break;

}

for(i=0;exp[i]!='#';i++)

{

if((exp[i]=='(')||(exp[i]== '[')||(exp[i]== '{'))

myStack.Push(exp[i]); //入栈

else if(exp[i] == ')' &&myStack.NotEmpty()

&&myStack.GetTop()=='(')

myStack.Pop(); //出栈

else if(exp[i]==')'&&myStack.NotEmpty()

&&myStack.GetTop()!='(')

{

cout<<"左、右括号配对次序不正确!"<

return;

}

else if(exp[i] == ']' &&myStack.NotEmpty()

&&myStack.GetTop()=='[')

myStack.Pop(); //出栈

else if(exp[i]==']'&&myStack.NotEmpty()

&&myStack.GetTop()!='[')

{

cout<<"左、右括号配对次序不正确!"<

return;

}

else if(exp[i] == '}' &&myStack.NotEmpty()

&&myStack.GetTop()=='{')

myStack.Pop(); //出栈

else if(exp[i]=='}'&&myStack.NotEmpty()

&&myStack.GetTop()!='{')

{

cout<<"左、右括号配对次序不正确!"<

return;

}

else if(((exp[i]==')')||(exp[i]==']')||(exp[i]=='{'))

&&!myStack.NotEmpty())

{

cout<<"右括号多于左括号!"<

return;

}

}

if(myStack.NotEmpty())

cout<<"左括号多于右括号!"<

else

cout<<"左、右括号匹配正确!"<

}

（3）//LinQueue.h

template class LinQueue; //前视定义,否则友元无法定义template

class QueueNode

{

friend class LinQueue; //定义类LinQueue为友元private:

QueueNode *next; //指针

T data; //数据元素

public:

//构造函数

QueueNode(const T& item, QueueNode *ptrNext = NULL) :data(item), next(ptrNext){}

~QueueNode(){}; //析构函数

};

template

class LinQueue

{

private:

QueueNode *front; //队头指针

QueueNode *rear; //队尾指针

int count; //计数器

public:

LinQueue(void); //构造函数

~LinQueue(void); //析构函数

void Append(const T& item); //入队列

T Delete(void); //出队列

T GetFront(void)const; //取队头数据元素

int NotEmpty(void)const //非空否

{return count != 0;};

};

//队列类的实现

template

LinQueue::LinQueue() //构造函数

{

front = rear = NULL; //无头结点

count = 0; //count的初值为0

}

template

LinQueue::~LinQueue(void) //析构函数

{

QueueNode *p, *q;

p = front; //p指向第一个结点

while(p != NULL) //循环直至全部结点空间释放

{

q = p;

p = p->next;

delete q;

}

count = 0; //置为初始化值0

front = rear = NULL;

}

template

void LinQueue::Append(const T& item) //入队列

//把数据元素item插入队列作为新队尾结点

{

//构造新结点newNode，newNode的data域值为item，next域值为NULL QueueNode *newNode = new QueueNode(item, NULL);

if(rear != NULL) rear->next = newNode; //新结点链入

rear = newNode; //队尾指针指向新队尾结点

//若队头指针原先为空则置为指向新结点

if(front == NULL) front = newNode;

count++; //计数器加1

}

template

T LinQueue::Delete(void) //出队列

//把队头结点删除并由函数返回

{

if(count == 0)

{

cout << "队列已空！" << endl;

exit(0);

}

QueueNode *p = front->next; //p指向新的队头结点 T data = front->data; //保存原队头结点的data域值

delete front; //释放原队头结点空间

front = p; //front指向新的队头结点

count--; //计数器减1

return data; //返回原队头结点的data域值

}

template

T LinQueue::GetFront(void)const //取队头数据元素{

if(count == 0)

{

cout << "队列已空！" << endl;

exit(0);

}

return front->data;

}

//LinQueue.cpp

#include

#include "windows.h"

#include

#include

using namespace std;

#include "LinQueue.h"

DWORD WINAPI Input_Thread(LPVOID data)

{

LinQueue myQueue;

char str;

while(true)

{

str = _getch();

myQueue.Append(str);

cout<

}

return((DWORD)data);

}

void main()

{

HANDLE thread_handle;

DWORD thread_dword;

thread_handle = CreateThread(NULL,0,Input_Thread,NULL,0,&thread_dword); //创建线程 while(true) //不断打印X

{

cout<<"X";

Sleep(500);

}

CloseHandle(thread_handle);//关闭线程

}