栈和队列的基本性质

栈是先进后出的结构(弹夹)

队列是先进先出的(排队)

栈和队列在实现结构上可以有数组和链表两种方式

栈结构的基本操作：

1、弹栈

2、访问栈顶元素

3、压栈操作

4、返回当前栈中的元素个数

队列结构的基本操作：

1、队列元素进队列是从队尾插入的

2、队列元素出队列是从对头弹出的             (类似于日常排队)

/*栈的结构定义(顺序栈)*/

#define MAXSIZE 100

typedef int ElemType; /*视栈中要存放的具体元素类型而定*/

typedef int Status;

typedef struct

{

ElemType data[MAXSIZE]; //利用系统的栈来存放栈元素

int top;

}Stack;

typedef struct

{

ElemType *base; //利用堆来存放栈的元素

ElemType *top; //栈顶指针和栈底指针

int count; //栈的大小

}Stack1;

/*栈的初始化*/

Status InitStack(Stack *s)

{

if(s == NULL)

{

return -1;

}

s->top = -1; //初始化栈顶指针

return 0;

}

#define NUM 10

Status InitStack(Stack1 *s1)

{

if(s1 == NULL)

{

return -1;

}

s1->top = (ElemType *)malloc(sizeof(ElemType)*NUM); //初始化栈顶指针

if(NULL == s1->top)

{

return -1; //申请内存失败

}

s1->base = s1->top;

s1->count = 0;

return 0;

}

/*压栈*/

Status push(Stack *s, ElemType e)

{

if(s->top == MAXSIZE-1)

{

//栈满

return -1;

}

s->top++;

s->data[s->top] = e;

return 0;

}

Status push(Stack1 *s1, ElemType e)

{

if(s1->top == s1->base+NUM-1)

{

//栈满

return -1;

}

*(s1->top) = e;

s1->top++;

s1->count++;

return 0;

}

/*出栈*/

Status pop(Stack *s, ElemType *e)

{

if(s->top == -1)

{

//栈空

return -1;

}

*e = s->data[s->top];

s->top--;

return 0;

}

Status pop(Stack1*s1, ElemType *e)

{

if(s1->top == s1->base)

{

//栈空

return -1;

}

*e = *(s1->top);

s1->top--;

s->count--;

return 0;

}

/*链式栈*/

/*栈元素的(节点的结构)和栈结构的定义*/

typedef int ElemType;

typedef int Status;

/*结点的结构*/

typedef struct node

{

ElemType data;

struct node *next;

}Node;

/*栈的结构*/

typedef struct

{

struct node *top; //栈顶指针

int count; //用来记录栈元素的个数

}Stack;

/*链栈初始化*/

Status InitStack(Stack *s)

{

if(NULL == s)

{

return -1;

}

s->top = NULL; //栈空，栈顶指针指向NULL

s->count = 0;

return 0;

}

/*把链表的头指针当作栈的栈顶指针，链表的尾结点当作栈底*/

/*栈元素只在栈顶进栈或者出栈*/

/*压栈*/

Status push(Stack *s, ElemType e)

{

if(NULL == s)

{

return -1;

}

Node *p = (Node *)malloc(sizeof(Node)); //申请一个节点

if(NULL == p)

{

return -1;

}

p->data = e;

p->next = s->top; //令新创建的节点指向当前的栈顶

s->top = p; //栈顶指针指向新压栈的元素

s->count++;

return 0;

}

/*出栈*/

Status pop(Stack *s, ElemType *e)

{

if(NULL==s || NULL==s->top)

{

return -1;

}

*e = s->top->data; //取出栈顶元素的值

Node *temp = s->top; //保存当前要出栈的栈顶元素的地址

s->top = s->top->next; //将栈顶指针移向下一个元素

s->count--;

free(temp); //释放当前栈顶元素的指针

return 0;

}

/*循环队列(顺序结构)*/

#define MAXSIZE 10 //队列的大小

typedef int ElemType;

typedef int Status;

/*顺序队列结构*/

typedef struct

{

ElemType data[MAXSIZE]; //利用系统的栈来存放队列的元素

int front; //队头(出队)

int rear; //队尾(进队)

}Queue;

/*队列的初始化*/

Status InitQueue(Queue *q)

{

if(NULL == q)

{

return -1;

}

q->rear = 0;

q->front = 0;

return 1;

}

/*返回循环队列的元素个数*/

int NumQueue(Queue *q)

{

return (q->rear-q->front+MAXSIZE)%MAXSIZE;

}

/*进队列(从队尾进队)*/

Status EnQueue(Queue *q, ElemType e)

{

if(NULL==q || (q->rear+1)%MAXSIZE==q->front)

{

return -1;

}

q->data[q->rear] = e;

q->rear = (q->rear+1) % MAXSIZE;

return 0;

}

/*出队列(从队头出队)*/

Status OutQueue(Queue *q, ElemType *e)

{

if(q==NULL || q->rear==q->front)

{

return -1;

}

*e = q->data[q->front];

q->front = (q->front+1) % MAXSIZE;

return 0;

}

/*用链表实现队列*/

/*队列元素的结点结构和队列结构*/

/*队列存储的元素的类型*/

typedef int ElemType;

typedef int Status;

/*结点结构*/

typedef struct node

{

ElemType data;

struct node *next;

}Node;

/*队列结构(一个队头指针，一个队尾指针)*/

typedef struct

{

struct node *front;

struct node *rear;

}Queue;

/*链式队列的初始化*/

/*无头结点*/

Status InitQueue(Queue *q)

{

if(NULL == q)

{

return -1;

}

q->front = NULL;

q->rear = NULL;

return 0;

}

/*有头结点*/

Status InitQueue(Queue *q)

{

if(NULL == q)

{

return -1;

}

/*创建一个头结点*/

Node *p = (Node *)malloc(sizeof(Node));

if(NULL == p)

{

return -1;

}

/*初始化头结点和队头队尾指针*/

p->next = NULL;

q->front = p;

q->rear = p;

return 0;

}

/*元素进队列*/

Status EnQueue(Queue *q, ElemType e)

{

if(NULLL == q)

{

return -1;

}

Node *temp = (Node *)malloc(sizeof(Node));

if(NULL == temp)

{

//申请内存失败

return -1;

}

/*初始化新插入的节点*/

temp->next = NULL;

temp->data = e;

/*从队尾连接新插入的节点并把队尾指针指向新插入的节点*/

q->rear->next = temp;

q->rear = temp;

return 0;

}

/*元素出队列*/

/*无头结点版本，从队头出队*/

Statu OutQueue(Queue *q, ElemType *e)

{

if(NULL == q || (NULL==q->rear))

{

return -1;

}

if(q->front == q->rear)

{

/*如果大家都指向同一个节点证明队列只有一个元素，那么q->rear也应该要改变*/

free(q->front);

q->front = NULL;

q->rear = NULL;

return 0;

}

Node *temp = q->front;

*e = q->front->data;

q->front = q->front->next;

free(temp);

return 0;

}

/*有头结点版本*/

Status OutQueue(Queue *q, ElemType *e)

{

if(NULL==q || (q->rear==q->front))

{

return -1;

}

Node *temp = q->front->next;

if(q->front->next == q->rear)

{

q->rear = q->front;

}

q->front->next = temp->next;

*e = temp->data;

free(temp);

return 0;

}

/*计算队列元素的数量*/

/*无头结点*/

int NumQueue(Queue *q)

{

if(NULL == q)

{

return -1;

}

int count = 1;

Node *temp1 = q->front;

Node *temp2 = q->rear;

if(temp1==NULL && temp2==NULL)

{

return 0;

}

else if(temp1 == temp2)

{

return count;

}

while(temp1 != temp2)

{

count++;

temp1 = temp1->next;;

}

return count;

}