栈、队列、链表、数组的相关操作（C语言实现，均可用于期末大作业）

已于 2023-04-01 17:11:53 修改
阅读量80 收藏 2
点赞数
分类专栏： # 我的C语言学习之旅 文章标签： 链表 c语言 数据结构
于 2023-03-30 11:24:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51913750/article/details/129838949
版权

写在前面：我们在学习数据结构与算法这门课时，其中很重要的一部分就是线性结构（数组和链表），而栈和队列就是线性结构的两个重要应用，所以我整理了这部分的源代码（C语言），要是有什么地方看不懂，可以直接在评论区告诉我，我一定第一时间解答。非线性结构（树和图）有时间我再整理。

我的一点想法：相信很多朋友都学习过C语言，但谈及C语言的指针和结构体的相关内容，大家可能都比较头疼，因为这部分内容本来就十分抽象，加上大家在校期间课程又紧，所以一部分朋友应该和我一样，都是一知半解的就过去了。但在学完C语言之后，我又深入学习了C++和Java语言，发现指针和结构体十分重要，对理解许多重要知识点是必不可少的东西，所以我只能重新学习这些令人头疼的问题。
可能有人会问，C语言是面向过程的语言，而C++和Java是面向对象的语言，C语言和其他这些语言又有什么关系呢？接下来我说说我自己的理解：C++和Java里面有类的概念，可以用类实例化一个具体的对象，与此同时，我们将属性和行为封装在同一个类中，这对我们后面的编程具有十分重要的作用，而且这种方法相比C语言有了很大的进步。但对于结构体并不太理解的朋友，你也可以将结构体理解为一个类，不过结构体默认是可以公开访问的（public），而大多数面向对象语言在默认情况下只能私有访问（private）。所以说，C语言的结构体在实现复杂结构（如学生类型，有姓名、年龄、学号等属性）时也十分有用。
接下来再说说指针。相信学过C++和Java的朋友对new这个运算符并不陌生，而new的本质就是向操作系统申请一块内存，然后返回这块内存的首地址，而这个地址就存放在一个指针中。尤其在C++中，利用new创建的数据，会返回该数据对应的类型的指针。所以，理解指针是十分必要的。
除上述原因外，我觉得我们这些搞编程、搞开发的，是不是一定要会数据结构呢？答案是肯定的。数据结构简单来说就是学习数据在内存中的存储方式以及对数据的操作（算法），而在数据结构中，链表是极其重要的一种线性结构，而它的实现离不开指针（当然Java有自己的数据结构实现方式），所以我说这么多的目的就是希望大家可以好好理解指针和结构体的知识，为之后的学习做铺垫。

推荐一个非常好的数据结构的视频：哔站郝斌老师数据结构

本文目录

1. 数组的定义及相关操作

#include<stdio.h>
#include <stdbool.h> //有些编译器不包含可能会报错，说不认识 bool 
#include<malloc.h>
#include<stdlib.h> //包含exit函数 

//定义了一个数据类型，该数据类型的名字叫做 struct Arr，含有三个成员 
struct Arr
{
	int * pBase; //存储的是数组的第一个元素的地址
	int len; //数组所能容纳的最大元素的个数
	int cnt; //当前数组有效元素的个数 
};

void init_arr(struct Arr * pArr, int length); //初始化数组 
bool append_arr(struct Arr * pArr, int val); //在数组末尾追加元素 
bool insert_arr(struct Arr * pArr, int pos, int val); //在指定位置插入元素，pos的值从1开始 
bool delete_arr(struct Arr * pArr, int pos, int * pVal); //删除指定位置的元素，并返回给用户这个被删除的值 
int get(struct Arr * pArr, int pos); //获得某一位置的元素，pos从1开始 
bool is_empty(struct Arr * pArr); //判断数组是否为空 
bool is_full(struct Arr * pArr); //判断数组是否已满 
void sort_arr(struct Arr * pArr); //将数组排序，本程序用的是冒泡排序 
void show_arr(struct Arr * pArr); //打印数组 
void inversion_arr(struct Arr * pArr); //将数组倒置 

int main()
{
	struct Arr arr;
	int val;
	
	init_arr(&arr, 6);	
	
	show_arr(&arr);
	
	append_arr(&arr, 5);
	append_arr(&arr, 1);
	append_arr(&arr, 2);
	append_arr(&arr, 7);
	append_arr(&arr, 6);
	
	printf("添加元素之后的数组：\n");
	show_arr(&arr);
	
	printf("数组中第三个位置的元素为：\n");
	int x = get(&arr, 3);
	printf("%d\n", x);
	
	if(delete_arr(&arr, 4, &val))
	{
		printf("删除成功！\n");
		printf("您删除的元素是：%d\n", val);
	}
	else
	{
		printf("删除失败！\n");	
	}
	
/*	insert_arr(&arr, 2, 99);
	append_arr(&arr, 6);
	append_arr(&arr, 7);
	if(append_arr(&arr, 8))
	{
		printf("追加成功\n");
	}
	else
	{
		printf("追加失败\n");
	}
*/
	
	printf("删除之后的数组：\n");
	show_arr(&arr);
	
	inversion_arr(&arr);
	printf("倒置之后的数组：\n");
	show_arr(&arr);
	
	sort_arr(&arr);
	printf("排序之后的数组：\n");
	show_arr(&arr);
	
	return 0;
}

void init_arr(struct Arr * pArr, int length) //初始化数组 
{
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if(pArr->pBase == NULL)
	{
		printf("动态分配内存失败！");
		exit(-1); //终止整个程序 
	}
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	}
	return; 
}

bool is_empty(struct Arr * pArr) //判断数组是否为空 
{
	if(pArr->cnt == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool is_full(struct Arr * pArr) //判断数组是否已满 
{
	if(pArr->len == pArr->cnt)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void show_arr(struct Arr * pArr) //打印数组 
{
	if(is_empty(pArr))
	{
		printf("数组为空！\n");
	}
	else
	{
		int i = 0;
		for(i = 0; i < pArr->cnt; ++i)
		{
			printf("%d ", pArr->pBase[i]);
		}
		printf("\n");
	}	
}

bool append_arr(struct Arr * pArr, int val) //在数组末尾追加元素 
{
	//满时返回false 
	if(is_full(pArr))
	{
		return false;
	}
	
	//不满时追加 
	pArr->pBase[pArr->cnt] = val;
	pArr->cnt++;
	return true;
}

int get(struct Arr * pArr, int pos) //获得某一位置的元素，pos从1开始 
{
	if(pos < 1 || pos > pArr->cnt)
	{
		printf("数组中没有该位置的元素！\n");
		return -1;
	}
	return pArr->pBase[pos - 1];		
}

bool insert_arr(struct Arr * pArr, int pos, int val) //在指定位置插入元素，pos的值从1开始 
{
	if(is_full(pArr))
	{
		return false;
	}
	
	if(pos < 1 || pos > pArr->cnt + 1)
	{
		return false;
	}
	
	int i;
	for(i = pArr->cnt - 1; i >= pos - 1; --i)
	{
		pArr->pBase[i + 1] = pArr->pBase[i];
	}
	pArr->pBase[pos - 1] = val;
	pArr->cnt++; 
	return true;
}

bool delete_arr(struct Arr * pArr, int pos, int * pVal) //删除指定位置的元素，并返回给用户这个被删除的值 
{
	if(is_empty(pArr))
	{
		return false;
	}
	if(pos < 1 || pos > pArr->cnt)
	{
		return false;
	}
	
	int i;
	*pVal = pArr->pBase[pos - 1];
	for(i = pos; i < pArr->cnt; ++i)
	{
		pArr->pBase[i - 1] = pArr->pBase[i];
	}
	pArr->cnt--;
	return true;
}

void inversion_arr(struct Arr * pArr) //将数组倒置 
{
	int i = 0;
	int j = pArr->cnt - 1;
	int temp;
	
	while(i < j)
	{
		temp = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = temp;
		++i;
		--j;
	} 
	return;
}

void sort_arr(struct Arr * pArr) //将数组排序，本程序用的是冒泡排序 
{
	int i, j, temp;
	for(i = 0; i < pArr->cnt; ++i)
	{
		for(j = i + 1; j < pArr->cnt; ++j)
		{
			if(pArr->pBase[i] > pArr->pBase[j])
			{
				temp = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = temp;
			}
		}
	}
}

2. 链表的定义及相关操作

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include <stdbool.h> //有些编译器不包含可能会报错，说不认识 bool 

typedef struct Node
{
	int data; //数据域
	struct Node * pNext; //指针域 
}NODE, *PNODE; //NODE等价于 struct Node， PNODE等价于 struct Node *

//函数声明，函数声明的时候可以不写形参 
PNODE create_list(void);  //创建一个链表 
void traverse_list(PNODE pHead); //遍历链表 
bool is_empty(PNODE pHead); //判断链表是否为空 
int length_list(PNODE); //求链表的长度 
bool insert_list(PNODE, int, int); //在链表某个特定节点的前面插入一个指定的元素，pos从1开始 
bool delete_list(PNODE, int, int *); //删除链表中某个元素 
void sort_list(PNODE); //将链表排序 

int main()
{
	PNODE pHead = NULL;
	
	int val; //用来存放被删除的节点的值 
	
	pHead = create_list(); //create_list()功能：创建一个非循环单链表，并将该链表的头结点地址赋给pHead
	printf("初始化后的链表为：\n");
	traverse_list(pHead);
/*	
	if(insert_list(pHead, 4, 22))
	{
		printf("插入成功！\n");
		printf("插入该元素后的链表为：\n");
		traverse_list(pHead);
	}
	else
	{
		printf("插入失败！\n");
	}
*/

	if(delete_list(pHead, 4, &val))
	{
		printf("删除成功，您删除的元素是：%d\n", val);
	}
	else
	{
		printf("删除失败！\n");
	}	
	traverse_list(pHead);
	
/*	if(is_empty(pHead))
	{
		printf("链表为空！\n");
	}
	else
	{
		printf("链表不为空！\n");
	}

	int len = length_list(pHead);
	printf("链表的长度是：%d\n", len);	
	
	sort_list(pHead);
	printf("链表排序后：\n");
	traverse_list(pHead);
*/	
	return 0;
}

PNODE create_list(void)
{
	int len; //用来存放有效节点的个数
	int i;
	int val; //用来临时存放用户输入的节点的值
	
	//分配了一个不存放有效数据的头结点 
	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	if(pHead == NULL)
	{
		printf("分配失败，程序终止！");
		exit(-1);
	}
	
	PNODE pTail = pHead;
	pTail->pNext = NULL;
	
	printf("请输入您要生成链表节点的个数：len = ");
	scanf("%d", &len);
	
	for(i = 0; i < len; ++i)
	{
		printf("请输入第%d个节点的值：", i + 1);
		scanf("%d", &val);
		
		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if(pNew == NULL)
		{
			printf("分配失败，程序终止！");
			exit(-1);
		}
		pNew->data = val;
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew;
	} 
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	while(p != NULL)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}
	printf("\n");
	return;
}

bool is_empty(PNODE pHead)
{
	if(pHead->pNext == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;
	while(p != NULL)
	{
		++len;
		p = p->pNext;
	}
	return len;
}

void sort_list(PNODE pHead) //选择排序 
{
	int i, j, t;
	int len = length_list(pHead);
	PNODE p, q;
	
	for(i = 0, p = pHead->pNext; i < len - 1; ++i, p = p->pNext)
	{
		for(j = i + 1, q = p->pNext; j < len; ++j, q = q->pNext)
		{
			if(p->data > q->data) //类似于数组中的：a[i] > a[j] 
			{
				t = p->data; //类似于数组中的：t = a[i]
				p->data = q->data; //类似于数组中的：a[i] = a[j]
				q->data = t; //类似于数组中的：a[j] = t
			}
		}
	}
	return;
}

//在pHead所指向的链表的第pos个节点的前面插入一个新的节点，该节点的值为val 
//pos的值从1开始 
bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;
	while(p != NULL && i < pos - 1)
	{
		p = p->pNext;
		++i;
	}
	if(i > pos - 1 || p == NULL)
	{
		return false;
	}
	
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if(pNew == NULL)
	{
		printf("动态分配内存失败！\n");
		exit(-1);
	}
	
	pNew->data = val;
	
	PNODE q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;
	
	return true;
}

bool delete_list(PNODE pHead, int pos, int * pVal)
{
	int i = 0;
	PNODE p = pHead;
	while(p->pNext != NULL && i < pos - 1)
	{
		p = p->pNext;
		++i;
	}
	if(i > pos - 1 || p->pNext == NULL)
	{
		return false;
	}
	
	//删除节点p后面的节点 
	PNODE q = p->pNext;
	*pVal = q->data;
	p->pNext = p->pNext->pNext;
	free(q);
	q = NULL;
	
	return true;
}

3. 栈的定义及相关操作

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include <stdbool.h> //有些编译器不包含可能会报错，说不认识 bool 

typedef struct Node
{
	int data;
	struct Node * pNext;
}NODE, * PNODE;

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK, * PSTACK; //PSTACK等价于 struct Stack *


void init(PSTACK);  //初始化栈，也就是造出一个空栈 
void push(PSTACK, int); //压栈 
bool is_empty(PSTACK); //判断栈是否为空 
bool pop(PSTACK, int *); //出栈 
void traverse(PSTACK); //遍历栈 
void clear(PSTACK); //清空栈 


int main()
{
	STACK S; //STACK等价于struct Stack 
	int val; //记录出栈的那个元素的值 
	
	init(&S);
	
	push(&S, 1);
	push(&S, 2);
	push(&S, 3);
	push(&S, 4);
	push(&S, 5);
	
	traverse(&S);
	
/*	clear(&S);
	traverse(&S);
*/	
	if(pop(&S, &val))
	{
		printf("出栈成功！出栈的元素是：%d\n", val);
	}
	else
	{
		printf("出栈失败！");
	}
	traverse(&S);
		
	return 0;
}

void init(PSTACK pS)
{
	//初始化的时候，pS->pTop和pS->pBottom都指向头结点（不存放有效数据） 
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if(pS->pTop == NULL)
	{
		printf("动态分配内存失败！\n");
		exit(-1);
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL; //pS->pBottom->pNext = NULL;
	}
}

void push(PSTACK pS, int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	
	pNew->data = val;
	pNew->pNext = pS->pTop; //pS->pTop不能改成 pS->pBottom 
	pS->pTop = pNew;
	
	return;
}

bool is_empty(PSTACK pS)
{
	if(pS->pBottom == pS->pTop)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool pop(PSTACK pS, int * pVal)
{
	if(is_empty(pS))
	{
		return false;
	}
	else
	{
		PNODE r = pS->pTop;
		* pVal = r->data;
		pS->pTop = pS->pTop->pNext; //pS->pTop = t->pNext;
		free(r);
		r = NULL;
		return true;
	}
}

void traverse(PSTACK pS)
{
	PNODE p = pS->pTop;
	
	while(p != pS->pBottom)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}
	printf("\n");
	
	return;
}

void clear(PSTACK pS)
{
	if(is_empty(pS))
	{
		return;
	}
	else
	{
		PNODE p = pS->pTop;
		PNODE q = NULL;
		while(p != pS->pBottom)
		{
			q = p->pNext;
			free(p);
			p = q;	
		}
		pS->pTop = pS->pBottom;
	}
}

4. 循环队列的定义及相关操作

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h> //有些编译器不包含可能会报错，说不认识 bool 

typedef struct Queue
{
	int * pBase; //可以理解为：pBase代表数组 
	int front;
	int rear;
}QUEUE;

void init(QUEUE *); //队列初始化，初始化的时候 front == 0 && rear == 0 
bool is_full_queue(QUEUE *); //判断队列是否已满 
bool is_empty_queue(QUEUE *); //判断队列是否为空 
bool en_queue(QUEUE *, int); //入队
void traverse_queue(QUEUE *); //遍历队列 
bool out_queue(QUEUE *, int *); //出队 


int main()
{
	QUEUE Q;
	init(&Q);
	int val; //用来存放出队的那个元素 
	traverse_queue(&Q);
	en_queue(&Q, 1);
	en_queue(&Q, 2);
	en_queue(&Q, 3);
	en_queue(&Q, 4);
	en_queue(&Q, 5);
	en_queue(&Q, 6);
	en_queue(&Q, 7);
	en_queue(&Q, 8);
	traverse_queue(&Q);
	
	if(out_queue(&Q, &val))
	{
		printf("出队成功！出队的元素是：%d\n", val);
	}
	else
	{
		printf("出队失败！\n");
	}
	traverse_queue(&Q);
	
	return 0;
}

void init(QUEUE * pQ) //初始化队列，初始化的时候 front == 0 && rear == 0 
{
	pQ->pBase = (int *)malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}

bool is_full_queue(QUEUE * pQ) //判断队列是否已满 
{
	if((pQ->rear + 1) % 6 == pQ->front)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool is_empty_queue(QUEUE * pQ) //判断队列是否为空 
{
	if(pQ->rear == pQ->front)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool en_queue(QUEUE * pQ, int val) //入队
{
	if(is_full_queue(pQ))
	{
		return false;
	}
	else
	{
		pQ->pBase[pQ->rear] = val;
		pQ->rear = (1 + pQ->rear) % 6;
		return true;
	}
}

void traverse_queue(QUEUE * pQ) //遍历队列 
{
	int i = pQ->front;
	while(i != pQ->rear)
	{
		printf("%d ", pQ->pBase[i]);
		i = (i + 1) % 6;
	}
	printf("\n");
	
	return;
}

bool out_queue(QUEUE * pQ, int * pVal) //出队 
{
	if(is_empty_queue(pQ))
	{
		return false;
	}
	else
	{
		* pVal = pQ->pBase[pQ->front];
		pQ->front = (pQ->front + 1) % 6;	
		return true;
	}	
}
mortalོ  
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C语言实现的链表、栈、队列、排序算法以及二叉树源码(课程作业).zip
01-16
1.项目代码功能经验证ok，确保稳定可靠运行。欢迎下载使用！在使用过程中，如有问题或建议，请及时私信沟通，帮助解答。 ...基于C语言实现的链表、栈、队列、排序算法以及二叉树源码(课程作业).zip
c语言期末大作业
12-14
【C语言期末大作业】 C语言作为一门基础且强大的编程语言，是计算机科学教育中的必修课程，尤其在期末时，学生们通常会被分配一个大作业，以检验他们在整个学期对C语言的理解和应用能力。这个“C语言期末大作业”...
数据结构C语言期末实验作业
08-15
C语言是一种底层编程语言，常用于实现这些数据结构，因为它提供了对内存的直接控制。本实验作业针对大一、大二学生，旨在通过实际操作加深对数据结构的理解。 1. **顺序表**：顺序表是最基础的数据结构，它在内存中...
湘潭大学C语言期末复习资料
06-24
《湘潭大学C语言期末复习资料》是一份专为湘潭大学学生准备的C语言学习资源，旨在帮助学生们在期末复习阶段巩固基础知识，提升编程能力。这份资料涵盖了C语言的基础概念、语法结构、程序设计等多个方面，旨在通过...
数据结构期末大作业-停车场管理系统（含收费功能、车辆号码······等等）（C语言）
04-24
在这个数据结构期末大作业中，学生们被要求设计并实现一个基于C语言的停车场管理系统，它包含了一系列关键功能，如车辆的进出管理、收费计算等。这个系统不仅要求具备基本的数据处理能力，还需要利用数据结构来优化...
结构体[C语言]
Q741_147的博客
07-20 244
在 C 语言中，我们使用struct关键字来定义结构体。// 定义学生结构体int age;// 后续代码...return 0;在这个例子中，我们定义了一个名为Student的结构体，它包含一个字符数组name用于存储姓名，一个整数age用于存储年龄，以及一个浮点数score用于存储成绩。
Windows图形界面(GUI)-DLG-C/C++ - 月历控件(MonthCalendar)
最新发布
0xCC说逆向
07-21 247
【代码】Windows图形界面(GUI)-DLG-C/C++ - 月历控件(MonthCalendar)
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 二进制游戏(200分)- 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
07-20 817
A先生和LYA最近在玩一个有趣的二进制游戏。游戏规则如下: A先生给出一个正整数 $n$,LYA需要找到一个比 $n$ 大的数字 $m$,使得 $m$ 和 $n$ 对应的二进制表示中1的个数相同。例如,4的二进制表示为100,有1个1;8的二进制表示为1000,也有1个1。因此,如果A先生给出2,LYA可以选择4作为 $m$。 现在,请你帮助LYA找到满足条件的最小的 $m$。
Windows图形界面(GUI)-DLG-C/C++ - 树形视图(TreeView)
0xCC说逆向
07-18 728
【代码】Windows图形界面(GUI)-DLG-C/C++ - 树形视图(TreeView)
入门C语言只需一个星期（星期五)
m0_45463480的博客
07-21 405
");return 0;}函数由两部分组成​void myFunction() { // 声明 declaration // 函数体（要执行的代码）(definition)}Declaration 声明函数名称、返回类型和参数 (如果有)Definition 函数体 (要执行的代码)// 函数声明void myFunction();// 主要方法int main() { myFunction();// --> 调用函数 return 0;
C语言 ——— 在控制台上打印动态变化的菱形
weixin_55341642的博客
07-18 198
输入，菱形的上半部分的长度就为菱形由 "" 号构成。
C基础入门题：石头剪刀布
我就知道你会来，我们一起进步吧！
07-14 445
简单明了的规则，使得石头剪子布没有任何规则漏洞可钻，单次玩法比拼运气，多回合玩法比拼心理博弈，使得石头剪子布这个古老的游戏同时用于“意外"与“技术”两种特性深受世界人民喜爱。接下来 N 行的每一行包括两个字符串，表示游戏参与者 Player1，Player2 的选择(石头、剪子或者是布):S1,S2。输出包括 N 行，每一行对应一个胜利者(Player1 或者 Player2)，或者游戏出现平局，则输出 Tie。现在，需要你写一个程序来判断石头剪子布游戏的结果。游戏规则:石头打剪刀，布包石头，剪刀剪布，
深度剖析整型和浮点型数据在内存中的存储（C语言）
m0_62646213的博客
07-19 6361
整型家族，整型数据在内存中的存储，原码。反码。补码，有符号整型，无符号整型，大端字节序和小端字节序，浮点型家族，浮点数在内存中的存储
Windows图形界面(GUI)-DLG-C/C++ - 列表视图(ListView)
0xCC说逆向
07-17 673
详细信息视图（Report View）：数据以列的形式显示，每个项目可以有多个属性或字段。图标视图（Icon View）：数据以图标的形式显示，通常用于文件和文件夹等对象。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1049
可以参考以下视频。
数组算法--基本查找
2303_78660417的博客
07-20 304
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
数据结构day3
qq_55245263的博客
07-18 267
顺序表实现学生管理系统
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 879
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 233
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值