数据结构栈与队列（一）

     

目录

 栈的定义与特点

栈的顺序存储结构（顺序栈）

定义一个顺序栈

顺序栈的初始化

顺序栈的插入

顺序栈的删除

顺序栈的查找

栈的链式存储结构（链栈）

---

         栈和队列是两种重要的线性结构,是特殊的线性表。 

 栈的定义与特点

栈是一个后进先出的线性表，它只能在表尾进行删除和插入操作。对于栈来说，表尾端称为栈的栈顶，表头端称为栈的栈底。不含任何元素的空表称为空栈。

入栈：插入元素到栈顶。

出栈：从栈顶删除最后一个元素。

它在操作时的要求和限制有：

1>栈的元素必须“后进先出”.

2>栈的操作只能在这个线性表的表尾进行

如图所示：

栈的表示和操作的实现

栈的类型定义：

下面是栈的抽象数据类型定义：

ADT Stack
{
数据对象;
数据关系;
基本操作:
InitStack(&S)
操作结果:构造一个空栈s。
DestroyStack(&S)
初始条件:栈s已存在。
操作结果:栈S被销毁。
ClearStack(&S)
初始条件:栈S已存在。
操作结果:将s清为空栈。
StackEmpty (S)
初始条件:栈S已存在。
操作结果:若栈s为空栈，则返回true,否则返回false。StackLength(S)
初始条件:栈s已存在。
操作结果:返回S的元素个数，即栈的长度。
GetTop(S)
初始条件:栈S已存在且非空。
操作结果:返回S的栈顶元素，不修改栈顶指针。
Push(&S,e)
初始条件:栈S已存在。
操作结果:插入元素e为新的栈顶元素
Pop(&S, &e)
初始条件:栈S已存在且非空。
操作结果:删除s的栈顶元素，并用e返回其值。
StackTraverse (S)
初始条件:栈S已存在且非空。
操作结果:从栈底到栈顶依次对s的每个数据元素进行访问。
}ADT Stack

由于栈属于特殊线性表，而线性表有两种存储方式，因此栈也有栈的顺序存储结构和链式存储结构，即栈分为顺序栈和链栈。

栈的顺序存储结构（顺序栈）

定义一个顺序栈

typedef struct
{
    ElemType *base;//指向栈底的指针变量
    ElemType *top;//指向栈顶的指针变量
    int stackSize;//指示栈当前可使用的最大容量
}SqStack;

顺序栈的初始化

利用动态分配线性表的存储区域可以更有效的利用系统的资源。

#define STACK_INIT_SIZE 100
initStack(sqStack *s)
{
    s->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!s->base)
    exit(0);
    s->top=s->base;
    s->stackSize=STACK_INIT_SIZE;
}

顺序栈的插入

1>判断是否栈满，若满则不能进行插入则为错。

2>将插入元素压入栈顶

3>栈顶指针加一

Status ListInsert (SqList &L, int i， ElemType e)
{//在顺序表L中第i个位置插人新的元素e, i值的合法范围是1≤i≤L.length+1
if((i<1)1I (i>L.1ength+1)) return ERROR;  //i的值不合法
if (L. length==MAXSIZE) return ERROR;     //当前存储空间已满
for(j=L. length-1;j>=i-1;j--)             //插入位置及之后的元素后移
L.elem[j+1]=L.elem[j];                    //将新元素e放入第i个位置
L.elem[i-1]=e;                            //表长加1
++L. length;
return OK;

顺序栈的删除

1>判断栈是否为空，为空不能进行删除，则返回错误。

2>栈顶指针-1。

3>获取栈顶元素e

Status ListDelete (SqList &L,int i)
{//在顺序表L中删除第i个元素，i值的合法范围是1≤i≤L.length
if((i<1)1I (i>L.length) )
 return ERROR;               //i值不合法
for(j=i;j<=L. length-1;j++)
L.elem[j-1]=L.elem[j];       //被删除元素之后的元素前移
--L. length;                 //表长减1
return OK;

顺序栈的查找

1>从第一个元素起，依次将其值与e相比较，若找到值与e相等的元素，则查找成功。返回元素序号i+1；

2>若整个顺序表都没有找到，则查找失败。

int LocateElem(SqList L, ElemType e)
{//在顺序表L中查找值为e的数据元素，返回其序号for(i=0;i< L. length; i++)
if (L.elem[i]==e) return i+1;     //查找成功，返回序号i+1
return 0;                         // 查找失败， 返回0

栈的链式存储结构（链栈）

栈的链式存储结构每个节点包含一个数据域（存储数据元素信息的域）和一个指针域（存储直接后继存储位置的域）。

链栈的初始化

1>生成新节点作为头节点，用头指针L指向头节点。

2>头节点的指针域置空。

Status InitList (LinkList &L)
{//构造一个空的单链表L
L=new LNode;      //生成新节点作为头节点，用头指针L指向头节点
L->next=NULL;     // 头节点的指针域置空
return OK;

链栈的插入

1>查找节点ar并由指针p指向该节点。

2>生成一个新节点*s。

3>将新节点*s的数据域置为e。

4>将新节点*s的指针域指向节点aio⑤将节点*p的指针域指向新节点*s。

Status ListInsert (LinkList &L, int i, ElemType e)
{//在带头节点的单链表L中第i个位置插人值为e的新节点
p=L;j=0;
while(p && (j<i 一1) )
{p=p->next; ++j; }            //查找第i-1个节点，p指向该节点
if(!p11j>i-1) return ERROR;   //i > n+1或者i < 1
s=new LNode;                  //生成新节点*s
s->data=e;                    //将节点*s的数据域置为e
s->next=p->next;              //将节点*s的指针域指向节点a1
p->next=s;                    //将节点*p的指针域指向节点*s
return OK;
}

链栈的删除

1>查找节点a, ,并由指针p指向该节点。

2>临时保存待删除节点a的地址在q中，以备释放。

3>将节点*p的指针域指向a;的直接后继节点。

4>释放节点a;的空间。

Status ListDelete (LinkList &L,int i)
{//在带头节点的单链表L中，删除第i个元素p=L;j=0;
while( (p->next) && (j<i-1))               //查找第i-1个节点，P指向该节点
{p=p->next; ++j; }
if(! (p->next) |1 (j>i-1) ) return ERROR;  //当i>n或i<1时，删除位置不合理
q=p->next;                                 //临时保存被删节点的地址以备释放
p->next=q->next;                           //改变删除节点前驱节点的指针域
delete q;                                  //释放删除节点的空间
return OK;

链栈的查找

1>用指针p指向首元节点。

2>从首元节点开始依次顺着链域next向下查找，只要指向当前节点的指针p不为空，并所指节点的数据域不等于给定值e,则循环执行以下操作: p指向下一个节点。

3>返回p。若查找成功，p此时指向节点的地址值，若查找失败，则p的值为NULL。

LNode * LocateElem (LinkList L, ElemType e)
{//在带头节点的单链表L中查找值为e的元素
p=L->next;                 //初始化，p指向首元节点
while(p && p->data!=e)     //顺链域向后查找，直到p为空或p所指节点的数据域等于e
p=p->next;                 //p指向下一个节点
return P;                  //查找成功返回值为e的节点地址p,查找失败P为NULL