Canvas is not supported in your browser.
首页 课程 文章
无痕注入 APC注入 线程注入 读写驱动 注入技术 句柄表 进程线程 系统调用 保护模式 内存管理 远程CALL 软件调试 驱动封装 云下发 驱动开发 FPS数据 方框透视 FPS方框 FPS自瞄 CE D3DHOOK D3D绘制 Imgui绘制 DWM
内核课程 驱动出租 学习路线 聊天室 免责声明 提问技巧

c语言-我的数据结构c（给自己用的）

推荐 原创

周杰伦

文章分类 其他 c语言 数据结构 驱动开发 开发语言 阅读数 : 169 阅读时长 : 9分钟


【c语言-我的数据结构c（给自己用的）】此文章归类为：["c语言","数据结构","驱动开发","开发语言"]。

目录

顺序表：

链表：

栈：

队列：

我想在之后的大学数据结构课上需要自己写来做题，但每次都自己写，那太麻烦了，所以我就将这个博客来把所有的C语言的数据结构弄上去，

问我为什么不用GitHub，虽说也托管上去了，哈哈机房访问的GitHub太慢了！

顺序表：

头文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>



//  队列先进先出


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<stdio.h>
#include<stdlib.h>

//单链表的英文  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<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

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; i<obj->top; 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<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>



//  队列先进先出


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);
}


更多【c语言-我的数据结构c（给自己用的）】相关视频教程：www.yxfzedu.com




相关文章推荐

记录自己的技术轨迹
文章规则：
1)：文章标题请尽量与文章内容相符
2)：严禁色情、血腥、暴力
3)：严禁发布任何形式的广告贴
4)：严禁发表关于中国的政治类话题
5)：严格遵守中国互联网法律法规
6)：有侵权,疑问可发邮件至service@yxfzedu.com
近期原创 更多
友情链接
内核结构 FAQ
免责声明
课程目录
Windows内核
游戏逆向(FPS)
技术交流QQ群
342478842 215039827 137189196
314055665 159620936
微信公众号
www.yxfzedu.com是一个分享游戏安全,游戏外挂与反外挂,游戏驱动保护的视频网站！
接各种驱动定制如：游戏读写驱动，软件内存保护，防止调试等功能定制。
出租读写驱动，调试驱动，无痕注入支持各种游戏。
邮箱：service@yxfzedu.com
QQ：851920120
特别说明：不接游戏数据分析，外挂编写，登陆协议等类似业务。