栈的顺序结构
//用数组实现顺序栈
#include <stdio.h>
#include <stdlib.h>
#define T 1
#define F 0
#define MAX 20//栈的最大容量
typedef int Elementype;
typedef int Status;
typedef struct stack
{
Elementype date[MAX];//栈数组
int top;//栈顶指针
}Stack;
Status init(Stack* s);
Status push(Stack* s,Elementype value);
void print(Stack s);
Status pop(Stack* s,Elementype* value);
Status empty(Stack s);//判断是否为空栈
Status gettop(Stack s,Elementype* value);
int length(Stack s);
Status clear(Stack* s);
int main()
{
Stack stack;
init(&stack);
int i;
for(i = 0;i < 21;i++)
{
push(&stack,i+1);
}
print(stack);
int value;
pop(&stack,&value);
printf("the value of pop is %d\n",value);
print(stack);
if(T != empty(stack))
{
gettop(stack,&value);
printf("the value of gettop is : %d\n",value);
}
print(stack);
printf("the length of stack is %d\n",length(stack));
clear(&stack);
if(T == empty(stack))
{
printf("the stack is empty\n");
}
return 0;
}
Status init(Stack* s)
{
s->top = -1;
return T;
}
Status push(Stack* s,Elementype value)
{
if(s->top == MAX - 1)
{
printf("the stack is full\n");
return F;
}
s->top++;
s->date[s->top] = value;
return T;
}
void print(Stack s)
{
int i;
for(i = 0;i <= s.top;i++)
{
printf("%d ",s.date[i]);
}
printf("\n");
}
Status pop(Stack* s,Elementype* value)
{
if(-1 == s->top)
{
printf("the stack is empty\n");
return F;
}
*value = s->date[s->top];
s->top--;
return T;
}
Status empty(Stack s)
{
if(-1 == s.top)
{
return T;
}
return F;
}
Status gettop(Stack s,Elementype* value)
{
if(-1 == s.top)
{
printf("the stack is empty\n");
return F;
}
*value = s.date[s.top];
return T;
}
int length(Stack s)
{
return s.top + 1;
}
Status clear(Stack* s)
{
s->top = -1;
return T;
}
栈的链式结构
#include <stdio.h>
#include <stdlib.h>
#define T 1
#define F 0
typedef int Elementype;
typedef int Status;
typedef struct node//链栈的结点结构体
{
Elementype value;
struct node* next;
}*StackNode;
typedef struct//链栈结构体
{
StackNode top;//链栈栈顶指针
int count;//链栈的实际长度
}LinkStack;
Status init(LinkStack* s);
Status push(LinkStack* s,Elementype value);
void print(LinkStack s);
Status pop(LinkStack* s,Elementype* value);
Status empty(LinkStack s);
Status gettop(LinkStack s,Elementype* value);
int length(LinkStack s);
Status clear(LinkStack* s);
int main()
{
LinkStack linkstack;
init(&linkstack);
int i;
for(i = 0;i < 10;i++)
{
push(&linkstack,i+1);
}
print(linkstack);
int value;
pop(&linkstack,&value);
printf("the value of pop is %d\n",value);
print(linkstack);
if(T != empty(linkstack))
{
gettop(linkstack,&value);
printf("the value of gettop is %d\n",value);
}
print(linkstack);
printf("the length of linkstack is %d\n",length(linkstack));
clear(&linkstack);
if(T == empty(linkstack))
{
printf("the linkstack is empty\n");
}
return 0;
}
Status init(LinkStack* s)
{
s->top = NULL;
s->count = 0;
return T;
}
Status push(LinkStack* s,Elementype value)
{
StackNode newnode = (StackNode)malloc(sizeof(struct node));
if(NULL == newnode)
{
return F;
}
newnode->value = value;
newnode->next = s->top;
s->top = newnode;
s->count++;
return T;
}
void print(LinkStack s)
{
int i;
for(i = 0;i < s.count;i++)
{
printf("%d ",s.top->value);
s.top = s.top->next;
}
printf("\n");
}
Status pop(LinkStack* s,Elementype* value)
{
if(0 == s->count)
{
printf("the linkstack is empty\n");
return F;
}
*value = s->top->value;
StackNode temp = s->top;
s->top = s->top->next;
free(temp);
s->count--;
return T;
}
Status empty(LinkStack s)
{
if(0 == s.count)
return T;
return F;
}
Status gettop(LinkStack s,Elementype* value)
{
if(0 == s.count)
return F;
*value = s.top->value;
return T;
}
int length(LinkStack s)
{
return s.count;
}
Status clear(LinkStack* s)
{
int i;
for(i = 0;i < s->count;i++)
{
StackNode temp = s->top;
s->top = s->top->next;
free(temp);
}
s->count = 0;
return T;
}
循环队列
#include <stdio.h>
#include <stdlib.h>
#define T 1
#define F 0
#define MAX 20
typedef int Elementype;
typedef int Status;
typedef struct
{
Elementype date[MAX];//循环队列的数组
int front;
int rear;
}Queue;
Status init(Queue* q);
Status enqueue(Queue* q,Elementype value);
void print(Queue q);
Status dequeue(Queue* q,Elementype *value);
Status empty(Queue q);
Status gethead(Queue q,Elementype* value);
int length(Queue q);
Status clear(Queue* q);
int main()
{
Queue queue;
init(&queue);
int i;
for(i = 0;i < 10;i++)
{
enqueue(&queue,i+1);
}
print(queue);
int value;
if(T != empty(queue))
{
dequeue(&queue,&value);
printf("the value of dequeue is %d\n",value);
}
print(queue);
printf("the length of queue is %d\n",length(queue));
clear(&queue);
if(T == empty(queue))
{
printf("the queue is empty\n");
}
return 0;
}
Status init(Queue *q)
{
q->front = 0;
q->rear = 0;
return T;
}
Status enqueue(Queue* q,Elementype value)
{
if((q->rear+1) % MAX == q->front)
{
printf("the queue is full\n");
return F;
}
q->date[q->rear] = value;
q->rear = (q->rear+1) % MAX;
return T;
}
void print(Queue q)
{
while(q.front != q.rear)
{
printf("%d ",q.date[q.front]);
q.front = (q.front + 1) % MAX;
}
printf("\n");
}
Status dequeue(Queue* q,Elementype *value)
{
if(q->front == q->rear)
{
printf("the queue is empty\n");
return F;
}
*value = q->date[q->front];
q->front = (q->front + 1) % MAX;
return T;
}
Status empty(Queue q)
{
if(q.front == q.rear)
return T;
return F;
}
Status gethead(Queue q,Elementype* value)
{
if(q.front == q.rear)
{
printf("the queue is empty\n");
return F;
}
*value = q.date[q.front];
return T;
}
int length(Queue q)
{
return (q.rear - q.front + MAX) % MAX;
}
Status clear(Queue* q)
{
q->rear = 0;
q->front = 0;
return T;
}
链队列
#include <stdio.h>
#include <stdlib.h>
#define T 1
#define F 0
#define MAX 20
typedef int Elementype;
typedef int Status;
typedef struct linknode//链队列的结点结构体
{
Elementype value;
struct linknode* next;
}*LinkNode;
typedef struct//链队列结构体
{
LinkNode front,rear;
}LinkQueue;
Status init(LinkQueue* q);
Status enqueue(LinkQueue* q,Elementype value);
void print(LinkQueue q);
Status dequeue(LinkQueue* q,Elementype* value);//只剩最后一个结点时注意处理
Status empty(LinkQueue q);
Status gethead(LinkQueue q,Elementype* value);
int length(LinkQueue q);
Status clear(LinkQueue* q);//可以保留头结点
int main()
{
LinkQueue linkqueue;
init(&linkqueue);
int i;
for(i = 0;i < 10;i++)
{
enqueue(&linkqueue,i+1);
}
print(linkqueue);
return 0;
}
Status init(LinkQueue* q)
{
LinkNode newnode = (LinkNode)malloc(sizeof(struct linknode));
if(NULL == newnode)
{
return F;
}
newnode->next = NULL;
q->front = newnode;
q->rear = newnode;
return T;
}
Status enqueue(LinkQueue* q,Elementype value)
{
LinkNode newnode = (LinkNode)malloc(sizeof(struct linknode));
if(NULL == newnode)
{
return F;
}
newnode->value = value;
newnode->next = NULL;
q->rear->next = newnode;
q->rear = newnode;
return T;
}
void print(LinkQueue q)
{
while(q.front != q.rear)
{
printf("%d ",q.front->next->value);
q.front = q.front->next;
}
printf("\n");
}
Status dequeue(LinkQueue* q,Elementype* value);//只剩最后一个结点时注意处理
Status empty(LinkQueue q);
Status gethead(LinkQueue q,Elementype* value);
int length(LinkQueue q);
Status clear(LinkQueue* q);//可以保留头结点