linux */10 * * * *,Linux学习之路（10）

顺序栈：

main.c

#include #include "Stack.h"

int main()

{

stack s;

Data i;

Init(&s);

for (i = 0; i < SIZE; i++)

{

Push(&s, i);

}

while(!Empty(&s))

{

printf("%d\n",GetTop(&s));

Pop(&s);

}

printf("栈结束\n");

return 0;

}

stack.c:

#include "Stack.h"

#include

void Init(stack *s)

{

if(NULL == s)

return;

s->top = -1;

}

BOOL Full(stack *s)

{

if(NULL == s)

return FALSE;

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

return TRUE;

return FALSE;

}

BOOL Empty(stack *s)

{

if(NULL == s)

return FALSE;

if(-1 == s->top)

return TRUE;

return FALSE;

}

void Push(stack *s, Data data)

{

if(NULL == s)

return;

if(Full(s) == TRUE)

return;

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

}

void Pop(stack *s)

{

if(NULL == s)

return;

if(Empty(s) == TRUE)

return;

--s->top;

}

Data GetTop(stack *s)

{

if(NULL == s)

return;

if(Empty(s) == TRUE)

return;

return s->data[s->top];

}

stack.h:

#ifndef _STACK_H

#define _STACK_H

#define SIZE 10

typedef enum{FALSE,TRUE} BOOL;

typedef int Data;

typedef struct Stack

{

int top;

Data data[SIZE];

} stack;

//初始化栈

void Init(stack *s);

//进栈(压栈)

void Push(stack *s, Data data);

//出栈

void Pop(stack *s);

//判断栈满

BOOL Full(stack *s);

//判断栈空

BOOL Empty(stack *s);

//获取栈顶元素

Data GetTop(stack *s);

#endif

结果：

链式栈：

main.c:

#include #include "stack.h"

int main()

{

Stack s;

Init(&s);

int i;

for(i = 0 ; i < SIZE; i++)

{

Push(&s, i);

}

while(!Empty(&s))

{

printf("%d\n", Gettop(&s));

Pop(&s);

}

printf("栈结束\n");

return 0 ;

}

stack.c:

#include #include #include "stack.h"

// 初始化栈

void Init(Stack* s)

{

if (s == NULL)

return;

s->head.next = NULL;

}

// 判断空栈

BOOL Empty(Stack* s)

{

if (s == NULL)

return FALSE;

if(s->head.next == NULL)

return TRUE;

return FALSE;

}

// 入栈

void Push(Stack* s, Data data)

{

if (s == NULL)

return;

Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));

if (node == NULL)

return;

node->data = data;

node->next = s->head.next;

s->head.next = node;

}

// 出栈

void Pop(Stack* s)

{

if (s == NULL)

return;

if(Empty(s) == TRUE)

return;

Node* p = s->head.next;

s->head.next = p->next;

free(p);

}

// 获取栈顶元素

Data Gettop(Stack* s)

{

if (s == NULL)

return;

if(Empty(s) == TRUE)

exit(-1);

return s->head.next->data;

}

Stack.h:

#ifndef _STACK_H_

#define _STACK_H_

#define SIZE 10

typedef enum{FALSE, TRUE}BOOL;

typedef int Data;

typedef struct _node

{

Data data;

struct _node* next;

}Node;

typedef struct stack

{

Node head;

}Stack;

// 初始化栈

void Init(Stack* s);

// 入栈

void Push(Stack* s, Data data);

// 出栈

void Pop(Stack* s);

// 判断空栈

BOOL Empty(Stack* s);

// 获取栈顶元素

Data Gettop(Stack* s);

#endif // _STACK_H_

结果：

链式队列：

main.c:

#include #include "Queue.h"

int main()

{

Queue q;

Init(&q);

int i;

for(i = 0 ; i < SIZE; i++)

{

Push(&q, i);

}

while(!Empty(&q))

{

Data data = GetTop(&q);

printf("%d\n", data);

Pop(&q);

}

printf("队列结束\n");

return 0 ;

}

Queue.c

#include #include #include "Queue.h"

// 初始化队列

void Init(Queue* q)

{

if (q == NULL)

return;

q->front = NULL;

q->rear = NULL;

}

// 判断空队列

BOOL Empty(Queue* q)

{

if (q == NULL)

return FALSE;

if(q->front == NULL)

return TRUE;

return FALSE;

}

// 入队列(尾插)

void Push(Queue* q, Data data)

{

if (q == NULL)

return;

Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));

if (node == NULL)

return;

node->data = data;

node->next = NULL;

if(q->rear != NULL)

{

q->rear->next = node;

q->rear = node;

}

else

{

q->rear = node;

q->front = node;

}

}

// 出队列

void Pop(Queue* q)

{

if (q == NULL)

return;

if(Empty(q) == TRUE)

return;

Node* tmp = q->front;

q->front = tmp->next;

free(tmp);

if(q->front == NULL)

q->rear = NULL;

}

// 获取队头元素

Data GetTop(Queue* q)

{

if (q == NULL)

return;

if(Empty(q) == TRUE)

exit(-1);

return q->front->data;

}

Queue.h:

#ifndef _QUEUE_H_

#define _QUEUE_H_

#define SIZE 10

typedef enum{FALSE, TRUE}BOOL;

typedef int Data;

typedef struct _node

{

Data data;

struct _node* next;

}Node;

typedef struct queue

{

Node *front;         //队头指针

Node *rear;          //队尾指针

}Queue;

// 初始化队列

void Init(Queue* s);

// 输入队列

void Push(Queue* s, Data data);

// 输出队列

void Pop(Queue* s);

// 判断空队列

BOOL Empty(Queue* s);

// 获取队头元素

Data Gettop(Queue* s);

#endif // _STACK_H_

结果：

顺序队列：

main.c:

#include #include "Queue.h"

int main()

{

Queue q;

Init(&q);

int i;

for(i = 0 ; i < SIZE; i++)

{

Push(&q, i);

}

while(!Empty(&q))

{

Data data = GetTop(&q);

printf("%d\n", data);

Pop(&q);

}

printf("队列结束\n");

return 0 ;

}

queue.c:

#include #include #include "Queue.h"

// 初始化队列

void Init(Queue* q)

{

if (q == NULL)

return;

q->front = 0;

q->rear = 0;

}

// 判断空队列

BOOL Empty(Queue* q)

{

if (q == NULL)

return FALSE;

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

return TRUE;

return FALSE;

}

//判断满队列

BOOL Full(Queue* q)

{

if (q == NULL)

return FALSE;

if((q->rear+1)%SIZE == q->front)

return TRUE;

return FALSE;

}

// 入队列(尾插)

void Push(Queue* q, Data data)

{

if (q == NULL)

return;

if (Full(q) == TRUE)

return;

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

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

}

// 出队列

void Pop(Queue* q)

{

if (q == NULL)

return;

if(Empty(q) == TRUE)

return;

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

}

// 获取队头元素

Data GetTop(Queue* q)

{

if (q == NULL)

return;

if(Empty(q) == TRUE)

exit(-1);

return q->data[(q->front+1)%SIZE];

}

queue.h:

#ifndef _QUEUE_H_

#define _QUEUE_H_

#define SIZE 10

typedef enum{FALSE, TRUE}BOOL;

typedef int Data;

typedef struct _node

{

Data data;

struct _node* next;

}Node;

typedef struct queue

{

Data data[SIZE];

int front;         //队头指针

int rear;          //队尾指针

}Queue;

// 初始化队列

void Init(Queue* s);

// 输入队列

void Push(Queue* s, Data data);

// 输出队列

void Pop(Queue* s);

// 判断空队列

BOOL Empty(Queue* s);

// 获取队头元素

Data Gettop(Queue* s);

#endif // _STACK_H_

结果：