C语言：顺序表、链表、队列、栈 及基本操作

顺序表

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct Vector{
	int *data;
	int size, length;

}Vector;

Vector *init(int n){
	Vector *vec = (Vector *)malloc(sizeof(Vector));
	vec->data = (int *)malloc(sizeof(int) * n);
	vec->size = n;
	vec->length = 0;
	return vec;
}

int expand(Vector *vec){
	int extr_size = vec->size;
	int *p;
	while(extr_size){
		p = (int *)realloc(vec->data, sizeof(int) * (vec->size + extr_size));
		if (p) break;
		//没有成功
		extr_size /= 2;
	}
	if (extr_size == 0) return 0;
	vec->data = p;
	vec->size += extr_size;
	return 1;
}

int insert(Vector *vec, int ind, int val){
	if (vec == NULL) return 0;
	if (ind < 0 || ind > vec->length) return 0;
	if (vec->length == vec->size){
		if (!expand(vec)) return 0;
		printf("Success to expand!\n");
	}
	for (int i = vec->length; i > ind; i++){
		vec->data[i] = vec->data[i-1];
	}
	vec->data[ind] = val;
	vec->length += 1;
	return 1;
}

int erase(Vector *vec, int ind){
	if (vec == NULL) return 0;
	if (ind < 0 || ind > vec->length) return 0;//老师这里写大于等于？？
	for (int i = ind + 1; i < vec->length; i++){
		vec->data[i-1] = vec->data[i];
	}
	vec->length -= 1;
	return 1;
}

void output(Vector *vec){
	printf("VECTOR : [");
	for (int i = 0; i <vec->length; i++){
		i && printf(", ");
		printf("%d", vec->data[i]);
	}
	printf("]\n");
	return;
}

void clear(Vector *vec){
	free(vec->data);
	free(vec);
	return;
}

int main(){
	srand(time(0));
#define maxop 20
	Vector *vec = init(maxop);
	for (int i = 0; i <maxop; i++){
		insert(vec, i, rand()%100);
	}
	output(vec);
	return 0;
}

链表

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct ListNode{
	int data;
	struct ListNode *next;
}ListNode;

typedef struct List{
	ListNode head;
	int length;
}List;

void reverse(List *l);

ListNode *init_node(int val){
	ListNode *p = (ListNoded *)malloc(sizeof(ListNode));
	p->data = val;
	p->next = NULL;
	return p;
}

//head为虚拟头结点，数据字段无意义，只代表链表头
List *init_list(){
	List *l = (List *)malloc(sizeof(List));
	l->head.next = NULL;
	l->length = 0;
	return l;
}

void clear_node(ListNode *node){
	if (node == NULL) return;
	free(node);
	return;
}

//不断地用q标识p下一个节点，然后销毁p
void clear(List *l){
	if (l == NULL) return;
	ListNode *p = l->head.next, *q;
	while(p){
		q = p->next;
		clear_node(p);
		p = q;
	}
}

//2种特殊情况，p始终标识待插入的前一个位置，如果ind=0，p就是头结点（第1个元素前）
int insert(List *l, int ind, int val){
	if (l == NULL) return 0;
	if (ind < 0 || ind > l->length) return 0;
	ListNode *p = &(l->head), *node = init_node(val);
	while(ind --) p = p->next;
	node->next = p->next;
	p->next = node;
	l->length++;
	return 1;
}

//头插法
void reverse(List *l){
	ListNode *p = l->head.next, *q;
	l->head.next = NULL;
	q = p->next;
	while(p){
		printf("q=%d p=%d\n", q->data, p->data);
		//p = q;//注意位置
		q = p->next;
		p->next = l->head.next;
		l->head.next = p;
		p = q;
	}
	return;
}

//同理，q标识待删除节点，p标识待删除的前一节点
int erase(List *l, int ind){
	if (l == NULL) return 0;
	if (ind < 0 || ind >= l->length) return 0;
	ListNode *p = &(l->head), *q;
	while(ind --) p = p->next;
	q = p->next;
	p->next = q->next;
	free(q);
	l->length--;
	return 1;
}

void output(List *l){
	if (l == NULL) return ;
	printf("List(%d) is [", l->length);
	for (ListNode *p = l->head.next; p; p = p->next){
		printf("%d->", p->data);
	}
	printf("NULL]\n");
	return ;
}

int main(){
	setvbuf(stdout, NULL, _IONBF, 0);
	srand(time(0));
#define max_op 20
	List *l = init_list();
	for (int i = 0; i < max_op;i++){
		int val = rand() % 100;
		if(insert(l, i, val)) printf("insert %d success!\n", val);
	}
	output(l);
	reverse(l);
	output(l);
}

队列

//由于循环队列很难判定队列满，若是front=rear或front>rear，则和队空情况一致
//因此引入计数变量，计算已存入队列的元素个数
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct Queue{
	int *data;
	int head, tail, length, cnt;
}Queue;

Queue *init(int n){
	Queue *q = (Queue *)malloc(sizeof(Queue));
	q->data = (int *)malloc(sizeof(int) * n);
	q->length = n;
	q->head = q->tail = q->cnt = 0;//用法很独特！
	return q;
}

int front(Queue *q){
	return q->data[q->head];
}

/*
int tail(Queue *q){
	return q->data[q->tail];
}
*/

void clear(Queue *q){
	if (q == NULL) return;
	free(q->data);
	free(q);
	return;
}

//tail指向待插入元素的位置，即当前元素的后一个位置
//判断队空
int empty(Queue *q){
	//return q->head == q->tail;
	return q->cnt == 0;
}

//入队
int push(Queue *q, int val){
	if (q == NULL) return 0;
	//if (q->tail == q->length){
	if (q->cnt == q->length){
		//return 0;//队满
		if (!expand(q)) return 0;
		printf("EXPAND SUCCESSFULLY!\n")
	}
	//expand
	q->data[q->tail++] = val;
	if (q->tail == q->length) q->tail = 0;
	q->cnt ++;
	return 1;
}

//出队
int pop(Queue *q){
	if (q == NULL) return 0;
	if (empty(q)) return 0;
	q->head ++;
	if (q->head == q->length) q->head = 0;
	q->cnt --;
	return 1;
}

//int expand(Queue *q){}

//打印元素
void output(Queue *q){
	printf("Queue : [");
	for (int i = q->head, j = 0; j < q->cnt; i++, j++){
		printf("%d ", q->data[i % q->length]);
	}
	printf("]\n");
	return;
}

int expand(Queue *q){
	return 0;//???
}


int main(){
	srand(time(0));
#define max_op 20
	Queue *q = init(max_op);
	for (int i = 0; i < max_op; i++){
		int val = rand() % 100;
		push(q, val);
		output(q);
	}
#undef max_op
	return 0;
}

栈

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

typedef struct Stack{
	int *data;
	int size, top;
}Stack;

Stack *init(int n){
	Stack *s = (Stack *)malloc(sizeof(Stack));
	s->data = (int *)malloc(sizeof(int)* n);
	s->size  = n;
	s->top = -1;
	return s;
}

void clear(Stack *s){
	if (s == NULL) return ;
	free(s->data);
	free(s);
	return;
}

int top(Stack *s){//为空怎么办？？
	return s->data[s->top];
}

int empty(Stack *s){
	return s->top == -1;
}

int push(Stack *s, int val){
	if (s == NULL) return 0;
	if (s->top == s->size - 1) return 0;
	//expand
	s->data[++(s->top)] = val;
	return 1;
}

int pop(Stack *s){
	if (s == NULL) return 0;
	if (empty(s)) return 0;
	s->top--;
	return 1;
}

void output(Stack *s){
	printf("Stack(%d) = [", s->top + 1);
	for (int i = 0; i <= s->top; i++){
		i && printf(", ");
		printf("%d", s->data[i]);
	}
	printf("]\n");
	return ;
}

int main(){
	srand(time(0));
#define max_op 20
	Stack *s = init(max_op);
	for (int i = 0; i < max_op; i++){
		int val = rand() % 100;
		push(s, val);
		output(s);
	}
}

循环队列扩容

int expand(){
	int extr_size = q->length;
	int *p;
	while(extr_size){
		p = (int *)malloc(sizeof(int) * (q->length + extr_size));
		if (p) break;
		extr_size >>= 1;
	}
	if (p== NULL) return 0;
	//空间开辟成功
	for (int i = q->head, j = 0; j < q->cnt; j++){
		p[j] = q->data[(i + j) % q->length];
	}
	free(q->data);
	q->data = p;
	q->length += extr_size;
	q->head = 0;
	q->tail = q->cnt;
	return 1;
}