栈和队列的基本性质
- 栈是先进后出的结构(弹夹)
- 队列是先进先出的(排队)
- 栈和队列在实现结构上可以有数组和链表两种方式
栈结构的基本操作:
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;
}