1 栈
1.1 顺序结构实现栈
#ifndef _SA_H
#define _SA_H
#include <sys/types.h>
typedef struct Stack{
int *arr;
size_t cap;
size_t top;
}STACK;
void stack_init(STACK* stack,size_t cap);
void stack_deinit(STACK* stack);
int stack_full(STACK* stack);
int stack_empty(STACK* stack);
void stack_push(STACK* stack,int data);
int stack_pop(STACK* stack);
int stack_top(STACK* stack);
size_t stack_size(STACK* stack);
#endif
#include <stdlib.h>
#include "sa.h"
void stack_init(STACK* stack,size_t cap){
stack->arr = malloc(cap * sizeof(int));
stack->cap = cap;
stack->top = 0;
}
void stack_deinit(STACK* stack){
free(stack->arr);
stack->arr = NULL;
stack->cap = 0;
stack->top = 0;
}
int stack_full(STACK* stack){
return stack->top >= stack->cap;
}
int stack_empty(STACK* stack){
return !stack->top;
}
void stack_push(STACK* stack,int data){
stack->arr[stack->top] = data;
stack-top++;
}
int stack_pop(STACK* stack){
stack->top--;
return stack->arr[stack->top];
}
int stack_top(STACK* stack){
return stack->arr[stack->top - 1];
}
size_t stack_size(STACK* stack){
return stack->top;
}
#include <stdio.h>
#include "sa.h"
int main(){
STACK stack;
stack_init(&stack,10);
int i;
for (i = 0;i < 7;i++){
stack_push(&stack,i + 1);
}
while(!stack_empty(&stack){
printf("%d\n",stack_pop(&stack));
}
stack_deinit(&stack);
}
1.2 链式结构实现栈
#ifndef _SL_H
#define _SL_H
#include <sys/types.h>
typedef struct StackNode{
int data;
struct StackNode* next;
}STACK_NODE;
typedef struct Stack{
STACK_NODE* top;
}STACK;
void stack_init(STACK* stack);
void stack_deinit(STACK* stack);
int stack_empty(STACK* stack);
void stack_push(STACK* stack,int data);
int stack_pop(STACK* stack);
int stack_top(STACK* stack);
size_t stack_size(STACK* stack);
#endif
#include <stdlib.h>
#include "sl.h"
static STACK_NODE* create_node(int data,STACK_NODE* next){
STACK_NODE* node = malloc(sizeof(STACK_NODE));
node->data = data;
node->next = next;
return node;
}
static STACK_NODE* destroy_node(STACK_NODE*){
STACK_NODE* next = node->next;
free(node);
return next;
}
void stack_init(STACK* stack){
stack->top = NULL;
}
void stack_deinit(STACK* stack){
while (stack->top)
stack->top = destroy_node(stack->top);
}
int stack_empty(STACK* stack){
return !stack->top;
}
void stack_push(STACK* stack,int data){
stack->top = create_node(data,stack->top);
}
int stack_pop(STACK* stack){
int data = stack->top->data;
stack->top = destroy_node(stack->top);
return data;
}
int stack_top(STACK* stack){
return stack->top->data;
}
size_t stack_size(STACK* stack){
size_t size = 0;
STACK_NODE* node = stack->top;
while (node){
size++;
node = node->next;
}
}
#include <stdio.h>
#include "sl.h"
int main(){
STACK stack;
stack_init(&stack);
int i;
for (i = 0;i < 7;i++){
stack_push(&stack,i + 1);
}
printf("size = %d\n",stack_size(&stack));
while(!stack_empty(&stack){
printf("%d\n",stack_pop(&stack));
}
stack_deinit(&stack);
}
2 队列
2.1 顺序结构实现队列
#ifndef _QA_H
#define _QA_H
#include <sys/types.h>
typedef struct Queue{
int *arr;
int cap;
size_t front;
size_t rear;
size_t size;
}QUEUE;
void queue_init(QUEUE* queue,size_t cap);
void queue_deinit(QUEUE* queue);
int queue_empty(QUEUE* queue);
int queue_full(QUEUE* queue);
void queue_push(QUEUE* queue,int data);
int queue_pop(QUEUE* queue);
int queue_front(QUEUE* queue);
size_t queue_size(QUEUE* queue);
#endif
#include <stdlib.h>
#include "qa.h"
void queue_init(QUEUE* queue,size_t cap){
queue->arr = malloc(cap * sizeof(int));
queue->cap = cap;
queue->front = 0;
queue->rear = 0;
queue->size = 0;
}
void queue_deinit(QUEUE* queue){
free(queue->arr);
queue->arr = 0;
queue->cap = 0;
queue->front = 0;
queue->rear = 0;
queue->size = 0;
}
int queue_empty(QUEUE* queue){
return !queue->size;
}
int queue_full(QUEUE* queue){
return queue->size >= queue->cap;
}
void queue_push(QUEUE* queue,int data){
if (queue->rear >= queue->cap)
queue->rear = 0;
queue->size++;
queue->arr[queue->rear] = data;
queue->rear++;
}
int queue_pop(QUEUE* queue){
if (queue->front >= queue->cap)
queue->front = 0;
queue->size--;
return queue->arr[queue->front++];
}
int queue_front(QUEUE* queue){
if (queue->front >= queue->cap)
queue->front = 0;
return queue->arr[queue->front];
}
size_t queue_size(QUEUE* queue){
return queue->size;
}
#include <stdlib.h>
#include "qa.h"
int main(){
QUEUE queue;
queue_init(&queue,5);
int i;
for (i = 0;!queue_full(&queue);i++){
queue_push(&queue,i + 1);
}
while (!queue_empty(&queue)){
printf("%d\n",queue_pop(&queue));
}
queue_deinit(&queue);
return 0;
}
2.2 链式结构实现队列
#ifndef _QL_H
#define _QL_H
#include <sys/types.h>
typedef struct QueueNode{
int data;
struct QueueNode* next;
}QUEUE_NODE;
typedef struct Queue{
QUEUE_NODE* front;
QUEUE_NODE* rear;
}QUEUE;
void queue_init(QUEUE* queue);
void queue_deinit(QUEUE* queue);
int queue_empty(QUEUE* queue);
void queue_push(QUEUE* queue,int data);
int queue_pop(QUEUE* queue);
int queue_front(QUEUE* queue);
size_t queue_size(QUEUE* queue);
#endif
#include <stdlib.h>
#include "ql.h"
static QUEUE_NODE* create_node(int data){
QUEUE_NODE* node = malloc(sizeof(QUEUE_NODE));
node->data = data;
node->next = NULL;
return node;
}
static QUEUE_NODE* destroy_node(QUEUE_NODE* node){
QUEUE_NODE* next = node->next;
free(node);
return next;
}
void queue_init(QUEUE* queue){
queue->front = NULL;
queue->rear = NULL;
}
void queue_deinit(QUEUE* queue){
while (queue->front)
queue->front = destroy_node(queue->front);
queue->rear = NULL;
}
int queue_empty(QUEUE* queue){
return !queue->front && !queue->rear;
}
void queue_push(QUEUE* queue,int data){
QUEUE_NODE* rear = create_node(data);
if (queue->rear)
queue->rear->next = rear;
else
queue->front = rear;
queue->rear = rear;
}
void queue_pop(QUEUE* queue){
int data = queue->front->data;
if (!(queue->front = destroy_node(queue->front)))
queue->rear = NULL;
return data;
}
int queue_front(QUEUE* queue){
return queue->front->data;
}
size_t queue_size(QUEUE* queue){
size_t size = 0;
QUEUE_NODE* node = queue->front;
for (;node;node = node->next)
size++;
return size;
}
#include <stdio.h>
#include "ql.h"
int main(){
QUEUE queue;
queue_init(&queue);
int i;
for (i = 0;i < 5;i++)
queue_push(&queue,i + 1);
printf("size = %d\n",queue_size);
while (!queue_empty(&queue))
printf("%d\n",queue_pop(&queue));
queue_deinit(&queue);
}