数据结构（顺序单链表、链式单链表、顺序栈、链式栈、顺序队列、链式队列）

/*顺序单链表*/#include  <stdio.h>#define N 10typedef int data_t;typedef struct{data_t data[N];int len;}seqlist_t;//创建顺序表seqlist_t *create_seqlist(){seqlist_t *sl = (seqlist_t *)malloc(sizeof(seqlist_t));sl->len = 0;return sl;}//销毁顺序表int destroy_seqlist(seqlist_t *sl){free(sl);return 0;}//清空顺序表int clear_seqlist(seqlist_t *sl){sl->len = 0;return 0;}//判断顺序表是否满了int full_seqlist(seqlist_t *sl){return sl->len == N ? 0 : -1;}//判断顺序表是否为空int empty_seqlist(seqlist_t *sl){return sl->len == 0 ? 0 : -1;}//顺序插入元素，将data插入到最后一个有效元素的后一个位置int insert_seqlist(seqlist_t *sl, data_t *data){if(full_seqlist(sl) == 0)return -1;sl->data[sl->len] = *data;sl->len++;return 0;}//指定位置插入元素int insert_seqlist_index(seqlist_t *sl, data_t *data, int index){if(index < 0 || index > sl->len || full_seqlist(sl) == 0)return -1;int i;for(i = sl->len - 1; i >= index; i--){sl->data[i + 1] = sl->data[i];}sl->data[index] = *data;sl->len++;return 0;}//顺序删除int delete_seqlist(seqlist_t *sl){if(empty_seqlist(sl) == 0)return -1;sl->len--;return 0;}int delete_seqlist_index(seqlist_t *sl, int index){int i;if(index < 0 || index > sl->len - 1 || empty_seqlist(sl) == 0)return -1;for(i = index; i < sl->len - 1; i++)sl->data[i] = sl->data[i + 1];sl->len--;return 0;}int getdata_seqlist(seqlist_t *sl, int index, data_t *data){if(index < 0 || index > sl->len - 1)return -1;*data = sl->data[index];return 0;}void print_seqlist(seqlist_t *sl){int i;for(i = 0; i < sl->len; i++)printf("%d ", sl->data[i]);putchar(10);return;}int main(int argc, const char *argv[]){seqlist_t * seqlist = create_seqlist();int i;for(i = 0; i < N; i++)insert_seqlist(seqlist, &i);print_seqlist(seqlist);delete_seqlist(seqlist);delete_seqlist_index(seqlist, 2);print_seqlist(seqlist);return 0;}

/*链式单链表*/#include <stdio.h>#include <stdlib.h>typedef char data_t;typedef struct node_t {data_t data;struct node_t *next;}linklist_t, linknode_t;//创建链表//1.创建头结点malloc//2.将头结点的next置为NULL//3.返回创建好的头结点的首地址linklist_t *create_linklist();//删除一个节点，删除ll节点的下一个节点int delete_linklist(linklist_t *ll);int delete_linklist_index(linklist_t *ll, int index);//头插法和尾插法//1.创建一个节点//2.对创建的节点进行赋值//3.进行插入int insert_linklist(linklist_t *ll, data_t *data);int insert_linklist_index(linklist_t *ll, data_t *data, int index);//长度int length_linklist(linklist_t *ll);//清空链表int clear_linklist(linklist_t *ll);//销毁int destroy_linklist(linklist_t *ll);int getdata_linklist(linklist_t *ll, int index, data_t *data);void print_linklist(linklist_t *ll);int main(int argc, const char *argv[]){linklist_t *ll = create_linklist();int i;char j;for(i = 0; i < 6; i++){scanf("%c", &j);insert_linklist(ll, &j);}print_linklist(ll);j = 'E';insert_linklist_index(ll, &j, 1);print_linklist(ll);delete_linklist(ll);delete_linklist_index(ll, 3);print_linklist(ll);return 0;}//创建链表//1.创建头结点malloc//2.将头结点的next置为NULL//3.返回创建好的头结点的首地址linklist_t *create_linklist(){linklist_t *ll = (linklist_t *)malloc(sizeof(linklist_t));ll->next = NULL;return ll;}//删除一个节点，删除ll节点的下一个节点int delete_linklist(linklist_t *ll){if(ll->next == NULL)return -1;linklist_t *p = ll->next;ll->next = p->next;free(p);return 0;}int delete_linklist_index(linklist_t *ll, int index){if(ll->next == NULL || index < 0)return -1;int i;for(i = 0; i < index; i++){ll = ll->next;if(ll->next == NULL)break;}if(i != index)return -1;delete_linklist(ll);return 0;}//头插法和尾插法//1.创建一个节点//2.对创建的节点进行赋值//3.进行插入int insert_linklist(linklist_t *ll, data_t *data){linklist_t *node = (linklist_t *)malloc(sizeof(linklist_t));node->data = *data;node->next = ll->next;ll->next = node;return 0;}int insert_linklist_index(linklist_t *ll, data_t *data, int index){if(index < 0)return -1;int i;for(i = 0; i < index; i++){ll = ll->next;if(ll->next == NULL)break;}if(i != index)return -1;insert_linklist(ll, data);return 0;}//长度int length_linklist(linklist_t *ll){int len = 0;while(ll->next != NULL){len++;ll = ll->next;}return len;}//清空链表int clear_linklist(linklist_t *ll){while(ll->next != NULL)delete_linklist(ll);return 0;}//销毁int destroy_linklist(linklist_t *ll){clear_linklist(ll);free(ll);return 0;}int getdata_linklist(linklist_t *ll, int index, data_t *data){if(index < 0)return -1;int i;for(i = 0; i <= index; i++){ll = ll->next;if(ll == NULL)break;}if(i != index + 1)return -1;*data = ll->data;return 0;}void print_linklist(linklist_t *ll){while(ll->next != NULL){printf("%c ", ll->next->data);ll = ll->next;}putchar(10);}

/*顺序栈*/#include <stdio.h>#include <stdlib.h>typedef int data_t;typedef struct {data_t *data;int top;int max_len;}seqstack_t;//创建顺序栈//1.开辟一个顺序表的空间//2.开辟数据区域的空间//3.给每一个顺序表的成员赋值//4.返回顺序表的首地址seqstack_t *create_seqstack(int len);//销毁顺序表//释放数据区域，再释放顺序表int destroy_seqstack(seqstack_t *ss);//清空int clear_seqstack(seqstack_t *ss);//入栈int push_seqstack(seqstack_t *ss, data_t *data);//出栈int pop_seqstack(seqstack_t *ss, data_t *data);//获得栈顶元素的数据int gettop_seqstack(seqstack_t *ss, data_t *data);//判断栈是否为空int empty_seqstack(seqstack_t *ss);//判断栈是否为满int full_seqstack(seqstack_t *ss);int get_pro(char opt){switch(opt){case '*':case '/':return 1;case '+':case '-':return 2;}return 1000;}int my_calc(int opd_1, char opt, int opd_2){switch(opt){case '*':return opd_1 * opd_2;case '/':return opd_1 / opd_2;case '+':return opd_1 + opd_2;case '-':return opd_1 - opd_2;}return -1;}int main(int argc, const char *argv[]){if(argc != 2){printf("Input error!\n");return -1;}const char *p = argv[1];int opd_1, opd_2, opt;seqstack_t *operand, *operator;operand = create_seqstack(10);operator = create_seqstack(10);while(*p != '\0'){if(*p <= '9' && *p >= '0'){opd_1 = 0;while(*p >= '0' && *p <= '9'){opd_1 = opd_1 * 10 + *p - '0';p++;}push_seqstack(operand, &opd_1);continue; }else{while(1){if(empty_seqstack(operator) == 0){opt = *p;push_seqstack(operator, &opt);break;}else{gettop_seqstack(operator, &opt);if(get_pro(*p) < get_pro(opt)){opt = *p;push_seqstack(operator, &opt);break;}else{pop_seqstack(operand, &opd_2);pop_seqstack(operand, &opd_1);pop_seqstack(operand, &opt);opd_1 = my_calc(opd_1, (char)opt, opd_2);push_seqstack(operand, &opd_1);}}}}p++;}while(empty_seqstack(operator) != 0){pop_seqstack(operand, &opd_2);pop_seqstack(operand, &opd_1);pop_seqstack(operand, &opt);opd_1 = my_calc(opd_1, (char)opt, opd_2);push_seqstack(operand, &opd_1);}pop_seqstack(operand, &opd_2);destroy_seqstack(operand);destroy_seqstack(operator);printf("The result is :%d\n", opd_2);return 0;}//创建顺序栈//1.开辟一个顺序表的空间//2.开辟数据区域的空间//3.给每一个顺序表的成员赋值//4.返回顺序表的首地址seqstack_t *create_seqstack(int len){seqstack_t *ss = (seqstack_t *)malloc(sizeof(seqstack_t));ss->data = (data_t *)malloc(sizeof(data_t) * len);ss->top = -1;//初始化栈，表明栈当前为空ss->max_len = len;return ss;}//销毁顺序表//释放数据区域，再释放顺序表int destroy_seqstack(seqstack_t *ss){free(ss->data);free(ss);return 0;}//清空int clear_seqstack(seqstack_t *ss){ss->top = -1;return 0;}//入栈int push_seqstack(seqstack_t *ss, data_t *data){if(full_seqstack(ss) == 0)return -1;ss->top++;//ss->data[ss->top] = *data;*(ss->data + ss->top) = *data;return 0;}//出栈int pop_seqstack(seqstack_t *ss, data_t *data){if(empty_seqstack(ss) == 0)return -1;*data = *(ss->data + ss->top);ss->top--;return 0;}//获得栈顶元素的数据int gettop_seqstack(seqstack_t *ss, data_t *data){if(empty_seqstack(ss) == 0)return -1;*data = *(ss->data + ss->top);return 0;}int  empty_seqstack(seqstack_t *ss){return ss->top == -1 ? 0 : -1;}int full_seqstack(seqstack_t *ss){return ss->top + 1 == ss->max_len ? 0 : -1;}

/*链式栈*/#include <stdio.h>#include <stdlib.h>#include "mytypes.h"//创建链表//1.创建头节点malloc//2.将头节点的next置NULL//3.返回头节点首地址linkstack_t *create_linkstack(){linkstack_t *ls = (linkstack_t *)malloc(sizeof(linkstack_t));ls->next = NULL;return ls;}int clear_linkstack(linkstack_t *ls){while(ls->next != NULL){linkstack_t *p = ls->next;ls->next = p->next;free(p);}return 0;}int destroy_linkstack(linkstack_t *ls){clear_linkstack(ls);free(ls);return 0;}int push_linkstack(linkstack_t *ls, ln_data_t *data){linkstack_t *node = (linkstack_t *)malloc(sizeof(linkstack_t));node->data = *data;node->next = ls->next;ls->next = node;return 0;}int pop_linkstack(linkstack_t *ls, ln_data_t *data){if(ls->next == NULL)return -1;*data = ls->next->data;linkstack_t *p = ls->next;ls->next = p->next;free(p);return 0;}int empty_linkstack(linkstack_t *ls){return ls->next == NULL ? 0 : -1;}int gettop_linkstack(linkstack_t *ls,ln_data_t *data){*data = ls->next->data;return 0;}

/*顺序队列*/#include <stdlib.h>#include "mytypes.h"//创建//1.开辟顺序队列的大小//2.开辟数据区域的大小//3.给成员赋值// 1)sq->front = sq->rear = 0;// 2)seq->max_len = len;//4.返回创建好的队列的首地址sequeue_t *create_sequeue(int len){sequeue_t *sq = (sequeue_t *)malloc(sizeof(sequeue_t));sq->data = (q_data_t *)malloc(sizeof(q_data_t) * len);sq->front = sq->rear = 0;sq->max_len = len;return sq;}//销毁int destroy_sequeue(sequeue_t *sq){free(sq->data);free(sq);return 0;}//清空队列int clear_sequeue(sequeue_t *sq){sq->front = sq->rear;return 0;}//入队操作int en_sequeue(sequeue_t *sq, q_data_t *data){sq->rear = (sq->rear + 1) % sq->max_len;sq->data[sq->rear] = *data;return 0;}//出队int de_sequeue(sequeue_t *sq, q_data_t *data){sq->front = (sq->front + 1) % sq->max_len;*data = *(sq->front + sq->data);return 0;}//获得队头元素int getfront_sequeue(sequeue_t *sq, q_data_t *data){*data = sq->data[(sq->front + 1) % sq->max_len];return 0;}int empty_sequeue(sequeue_t *sq){return sq->front == sq->rear ? 0 : -1;}int full_sequeue(sequeue_t *sq){return (sq->rear + 1) % sq->max_len == sq->front ? 0 : -1;}

/*链式队列*/#include <stdio.h>#include <stdlib.h>#include "mytypes.h"//创建linkqueue_t *create_linkqueue(){linkqueue_t *lq = (linkqueue_t *)malloc(sizeof(linkqueue_t));lq->front = lq->rear = (linknode_t *)malloc(sizeof(linknode_t));lq->len = 0;lq->rear->next = NULL;return lq;}int empty_linkqueue(linkqueue_t *lq){return lq->front == lq->rear ? 0 : -1;}int de_linkqueue(linkqueue_t *lq, n_data_t *data){if(empty_linkqueue(lq) == 0)return -1;linknode_t *q = lq->front;lq->front = lq->front->next;free(q);*data = lq->front->data;lq->len--;return 0;}int clear_linkqueue(linkqueue_t *lq){n_data_t data;while(de_linkqueue(lq, &data) == 0);return 0;}int destroy_linkqueue(linkqueue_t *lq){clear_linkqueue(lq);free(lq->front);free(lq);return 0;}int en_linkqueue(linkqueue_t *lq, n_data_t *data){linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));node->data = *data;node->next = NULL;lq->rear->next = node;lq->rear = node;lq->len++;return 0;}int getfront_linkqueue(linkqueue_t *lq, n_data_t *data){if(empty_linkqueue(lq) == 0)return -1;*data = lq->front->next->data;return 0;}