我的数据结构c（给自己用的）
目录
顺序表：
链表：
栈：
队列：
我想在之后的大学数据结构课上需要自己写来做题，但每次都自己写，那太麻烦了，所以我就将这个博客来把所有的C语言的数据结构弄上去，
问我为什么不用GitHub，虽说也托管上去了，哈哈机房访问的GitHub太慢了！
顺序表：
头文件
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include
// 队列先进先出
typedef int QUDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QUDataType x;
}QueueNode;
typedef struct QUEUE
{
QueueNode* head;
QueueNode* tail;
}Queue;
//初始化
void QueueInit(Queue* pq);
//入队列
void QueuePush(Queue* pq,QUDataType x);
//出队列
void QueuePop(Queue* pq);
//取头数据
QUDataType QueueFront(Queue* pq);
//取尾数据
QUDataType QueueBack(Queue* pq);
//有几个数据
int QueueSize(Queue* pq);
//是否为空
bool QueueEmpty(Queue* pq);
//打印
void Print(Queue* pq);
函数文件：
#define _CRT_SECURE_NO_WARNINGS 1
#include"main.h"
void Checkcapacity(SL* pc)
{
if (pc->size == pc->capacity)
{
int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
SLDataType* str = (SLDataType*)realloc(pc->a, newcapacity * sizeof(SLDataType));
if (str == NULL)
{
perror("realloc");
exit(-1);
}
}
}
void print(SL* pc)
{
int i = 0;
for (i = 0; i < pc->size; i++)
{
printf("%d ", pc->a[i]);
}
}
//回收空间
void SeqlistDestory(SL* pc)
{
free(pc->a);
pc->a = NULL;
pc->capacity = pc->size = 0;
}
void SeqListInit(SL* pc)
{
pc->a = NULL;
pc->size = 0;
pc->capacity = 0;
}
void SeqListPushback(SL* pc, SLDataType x)
{
//如果没有空间或根本没有就增容：
if (pc->size == pc->capacity)
{
int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
SLDataType* str = (SLDataType*)realloc(pc->a,newcapacity*sizeof(SLDataType));
if (str == NULL)
{
perror("realloc");
exit(-1);
}
pc->a = str;
str = NULL;
pc->capacity = newcapacity;
}
pc->a[pc->size] = x;
pc->size++;
}
void SeqlistPopback(SL* pc)
{
if (pc->size == 0)
{
printf("没有了喵~\n");
return;
}
pc->a[pc->size - 1] = 0;
pc->size--;
}
void SeqlistPushfront(SL* pc, SLDataType x)
{
if (pc->size == pc->capacity)
{
int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
SLDataType* str = (SLDataType*)realloc(pc->a, newcapacity * sizeof(SLDataType));
if (str == NULL)
{
perror("realloc");
exit(-1);
}
pc->a = str;
str = NULL;
pc->capacity = newcapacity;
}
pc->size += 1;
for (int i = pc->size; i>=0; i--)
{
pc->a[i+1] = pc->a[i];
}
pc->a[0]=x;
}
void SeqlistPopfront(SL* pc)
{
if (pc->size == 0)
{
printf("没u删除的元素喵~\n");
}
int i = 1;
for (i = i; i <= pc->size+1; i++)
{
pc->a[i - 1] = pc->a[i];
}
pc->size -= 1;
}
//插入数字
void Seqlistinsert(SL* pc, int pos, SLDataType x)
{
Checkcapacity(pc);
pc->size += 1;
int i=pos;
for (i = pos; i < pc->size; i++)
{
pc->a[i] = pc->a[i - 1];
}
pc->a[pos - 1] = x;
}
//查找数字()
int Seqlistfind_bydata(SL* pc, SLDataType x)
{
int i = 0;
for (i; i < pc->size; i++)
{
if (pc->a[i] == x)
{
printf("返回第一个下标\n");
return i;
}
}
printf("找不到\n");
return -1;
}
//删除指定数字
void Seqlistdelet(SL* pc, SLDataType x)
{
int i = 0;
for (i = 0; i < pc->size; i++)
{
if (x == pc->a[i])
{
for (i; i < pc->size; i++)
{
pc->a[i] = pc->a[i + 1];
}
pc->size--;
break;
}
}
printf("没这个数字哦\n");
return;
}
链表：
头文件：
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
//单链表的英文 Single linked list
typedef int SLLdatatype;
typedef struct SListNode
{
SLLdatatype data;
struct SListNode*next;
}SLL;
//打印
void SLLprint(SLL* phead);
//尾部存储
void SLLpushback(SLL**phead,SLLdatatype x);
//头部存储
void SLLpushfront(SLL** phead, SLLdatatype x);
void SLLpushfront2(SLL** phead, SLLdatatype x);
//尾部删除
void SLLpopback(SLL** phead);
//头部删除
void SLLpopfront(SLL** phead);
//查找
void SLL_find_print(SLL* phead, SLLdatatype x);
//查下标
SLL* SLL_findpos(SLL* phead, SLLdatatype x);
// 指定位置插入
void SLL_inset(SLL** phead, SLL* pos, SLLdatatype x);
//指定位置删除
void SLL_pos_del(SLL** phead, SLL* pos);
//销毁链表
void SLL_destory(SLL* *phead);
函数文件：
#define _CRT_SECURE_NO_WARNINGS 1
#include"main.h"
SLL* creatnode( SLLdatatype x)
{
SLL* newnode = (SLL*)malloc(sizeof(SLL));
if (newnode == NULL)
{
perror("malloc");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}
//打印
void SLLprint(SLL* phead)
{
/*SLL* cur = phead;*/
while (phead != NULL)
{
printf("%d ", phead->data);
phead = phead->next;
}
printf("->NULL\n");
}
void SLLpushback(SLL**phead,SLLdatatype x)
{
SLL* newnode = (SLL*)malloc(sizeof(SLL));
newnode->data = x;
newnode->next = NULL;
if (*phead == NULL)
{
*phead = newnode;
}
else
{
SLL* tail = *phead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}
void SLLpushfront(SLL** phead, SLLdatatype x)
{
SLL* newnode = (SLL*)malloc(sizeof(SLL));
newnode->data = x;
newnode->next = NULL;
if (phead == NULL)
{
*phead = newnode;
}
else
{
newnode->next = *phead;
*phead = newnode;
}
}
void SLLpushfront2(SLL** phead, SLLdatatype x)
{
SLL* newnode = creatnode(x);
newnode->next = *phead;
*phead = newnode;
}
//尾部删除
void SLLpopback(SLL** phead){
SLL*tail = *phead;
SLL* str = NULL;
if (*phead==NULL)
{
return ;
}
if (tail->next ==NULL)
{
free(tail);
*phead = NULL;
}
else
{
while (tail->next!=NULL)
{
str = tail;
tail = tail->next;
}
free(tail);
tail = NULL;
str->next = NULL;
}
}
//头部删除
void SLLpopfront(SLL** phead)
{
if (*phead == NULL)
{
return;
}
if ((*phead)->next == NULL)
{
*phead = NULL;
}
else
{
SLL* front = *phead;
(*phead)=(*phead)->next;
free(front);
front = NULL;
}
}
//找加打印
void SLL_find_print(SLL* phead, SLLdatatype x)
{
if (phead == NULL)
{
return;
}
while (phead->data!=x)
{
if (phead->next== NULL)
{
break;
}
phead = phead->next;
}
if (phead->next == NULL)
{
printf("找不到喵~\n");
}
else
{
printf("%d\n", phead->data);
}
}
//查下标
SLL* SLL_findpos(SLL* phead, SLLdatatype x)
{
if (phead == NULL)
{
return NULL;
}
else
{
while (phead)
{
if (phead->data == x)
{
return phead;
}
phead = phead->next;
}
}
printf("找不到\n");
return NULL;
}
// 指定位置插入
void SLL_inset(SLL** phead, SLL* pos, SLLdatatype x)
{
if (*phead == NULL)
{
return;
}
else
{
SLL* find = *phead;
while (find)
{
if (find->next == pos)
{
SLL* newnode = creatnode(x);
newnode->next = find->next;
find->next = newnode;
return;
}
find = find->next;
}
}
}
//指定位置删除
void SLL_pos_del(SLL** phead, SLL* pos)
{
if (*phead == NULL)
{
return;
}
else
{
SLL* find = *phead;
SLL* findpos = NULL;
while (find)
{
if (find->next == pos)
{
findpos = find->next;
find->next = findpos->next;
free(findpos);
findpos = NULL;
return;
}
find = find->next;
}
}
}
//销毁链表
void SLL_destory(SLL** phead)
{
if (*phead == NULL)
{
return;
}
else
{
while ((*phead)->next!=NULL)
{
SLL* tailpos = *phead;
SLL* tail = NULL;
while (tailpos->next != NULL)
{
tail = tailpos;
tailpos = tailpos->next;
}
free(tailpos);
tail->next = NULL;
tailpos = NULL;
}
free(*phead);
*phead = NULL;
}
}
栈：
头文件：
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
//初始化栈
void StackIint(ST* ps);
//销毁栈
void Stackdestory(ST* pc);
//push
void StackPush(ST* ps, STDataType x);
//pop
void StackPop(ST* ps);
//取栈顶数据
STDataType Stacktop(ST* ps);
//有多少数据
int StackSize(ST* ps);
//判断是否为空
bool StackEmpty(ST* ps);
int minStackGetMin(ST* obj);
函数：
#define _CRT_SECURE_NO_WARNINGS 1
#include"main.h"
//初始化单链表
void StackIint(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
//销毁栈
void Stackdestory(ST* pc)
{
assert(pc);
free(pc->a);
pc->a = NULL;
pc->capacity = pc->top = 0;
}
//push
void StackPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->capacity == ps->top)
{
ps->capacity =ps->capacity== 0 ? 4 : 2 * ps->capacity;
STDataType* temp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity);
if (temp == NULL)
{
printf("realloc fail\n");
exit(-1);
}
ps->a = temp;
}
ps->a[ps->top] = x;
ps->top += 1;
}
int minStackGetMin(ST* obj) {
int i = 0;
int min = obj->a[i];
for (i = 1; itop; i++)
{
if (obj->a[i] < min)
{
min = obj->a[i];
}
}
return min;
}
//pop
void StackPop(ST* ps)
{
assert(ps->top > 0);
ps->top--;
}
//取栈顶数据
STDataType Stacktop(ST* ps)
{
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
//有多少数据
int StackSize(ST* ps)
{
assert(!StackEmpty(ps));
return ps->top;
}
//判断是否为空
bool StackEmpty(ST* ps)
{
return ps->top == 0;
}
队列：
头文件：
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include
// 队列先进先出
typedef int QUDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QUDataType x;
}QueueNode;
typedef struct QUEUE
{
QueueNode* head;
QueueNode* tail;
}Queue;
//初始化
void QueueInit(Queue* pq);
//入队列
void QueuePush(Queue* pq,QUDataType x);
//出队列
void QueuePop(Queue* pq);
//取头数据
QUDataType QueueFront(Queue* pq);
//取尾数据
QUDataType QueueBack(Queue* pq);
//有几个数据
int QueueSize(Queue* pq);
//是否为空
bool QueueEmpty(Queue* pq);
//打印
void Print(Queue* pq); 函数：
#define _CRT_SECURE_NO_WARNINGS 1
#include"main.h"
//初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = NULL;
pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
while (cur!=NULL)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = NULL;
pq->tail = NULL;
}
//入队列
void QueuePush(Queue* pq, QUDataType x)
{
assert(pq);
if (pq->head == NULL && pq->tail == NULL)
{
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
newnode->x = x;
newnode->next = NULL;
pq->head=newnode;
pq->tail=newnode;
}
else
{
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
newnode->x = x;
newnode->next = NULL;
QueueNode* tail1 = NULL;
tail1 = pq->tail;
tail1->next = newnode;
pq->tail = newnode;
}
}
//出队列
void QueuePop(Queue* pq)
{
assert(pq);
if (pq->head ==NULL)
{
exit(-1);
}
QueueNode* head1 = pq->head->next;
free(pq->head);
pq->head = head1;
if (pq->head == NULL)
{
pq->head = pq->tail = NULL;
}
}
//取头数据
QUDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->head->x;
}
//取尾数据
QUDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->tail->x;
}
//有几个数据
int QueueSize(Queue* pq)
{
assert(pq);
int count = 0;
QueueNode*pos = pq->head;
while (pos != NULL)
{
count += 1;
pos = pos->next;
}
return count;
}
//是否为空
bool QueueEmpty(Queue* pq)
{
assert(pq);
if (pq->head)
{
return false;
}
return true;
}
//打印
void Print(Queue* pq)
{
assert(pq);
assert(pq->head);
QueueNode* pos = pq->head;
while (pos != NULL)
{
printf("%d ", pos->x);
pos = pos->next;
}
printf("\n");
}
typedef struct {
Queue* q1;
Queue* q2;
} MyStack;
MyStack* myStackCreate() {
MyStack* st = (MyStack*)malloc(sizeof(MyStack));
st->q1 = (QUEUE*)malloc(sizeof(QUEUE));
st->q2 = (QUEUE*)malloc(sizeof(QUEUE));
return st;
}
void myStackPush(MyStack* obj, int x) {
if (!QueueEmpty(obj->q1))
{
QueuePush(obj->q1, x);
}
else
{
QueuePush(obj->q2, x);
}
}
int myStackPop(MyStack* obj) {
Queue* empty = obj->q1;
Queue* noempty = obj->q2;
if (!QueueEmpty(obj->q1))
{
empty = obj->q2;
noempty = obj->q1;
}
int top = QueueBack(noempty);
while (QueueSize(noempty) > 0)
{
QueuePush(empty, QueueFront(noempty));
QueuePop(noempty);
}
return top;
}
int myStackTop(MyStack* obj) {
if (!QueueEmpty(obj->q1))
{
return QueueBack(obj->q1);
}
return QueueBack(obj->q2);
}
bool myStackEmpty(MyStack* obj) {
if (QueueEmpty(obj->q1) || QueueEmpty(obj->q2))
{
return false;
}
return true;
}
void myStackFree(MyStack* obj) {
free(obj->q1);
free(obj->q2);
free(obj);
}