二：单链表的实现（附带运行截图，亲测有效）

已于 2024-05-26 10:24:48 修改
阅读量519 收藏 8
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法
于 2024-04-23 21:44:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76781059/article/details/138138830
版权

一：结点的定义：

#include<stdio.h>
#include<stdlib.h>
typedef  int ElemType;
typedef struct LNode {//定义一个结点结构
	ElemType data;//数据域
	struct LNode* next;//指针域，next是下一个结点的地址
}LNode,*LinkList;

（1）注意： LNode *相当于LinkList

（2）搞清楚带头结点和不带头结点的区别（下面按顺序分别是带头结点链表，不带头结点单链表）

二：单链表的初始化(带头结点）

bool HaveHead_InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));//创建一个头结点，并为该头结点开辟一个结点所需要的空间（所以后面要是要加新结点，则需要另辟结点空间）
	if (L == NULL)   return false;//即：如果空间分配失败
	L->next = NULL;
	return true;
}

三：单链表的初始化(不带头结点）

bool NoHead_InitList(LinkList& L) {
	L== NULL;//即空表，需要特别初始化为空   是因为：防止L在没有赋值的情况下携带脏数据而影响后序操作
	return true;
}

四：判空(带头结点）

bool HaveHead_Empty(LinkList L) {
	if (L->next == NULL) //不带头结点则是  if(L==NULL)  return true;  else   return false;
		return true;
	else return false;
}

五：判空(不带头结点）

bool HaveHead_Empty(LinkList L) {
	  if(L==NULL)  return true;  
	else return false;
}

六：建单链表----头插法(带头结点）

//建单链表----头插法(逆向建立单链表）（带头结点）
LinkList Havehead_List_HeadInsert(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));     //建立头结点 
	L->next = NULL; //初始尾空链表 （必须初始化） 
	LNode* s;
	int x;
	scanf("%d", &x);
	while (x != -1) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;              //即头结点指向新的结点 
		scanf("%d", &x);
	}
	return L;
}

七：建单链表----头插法(不带头结点）

//建单链表----头插法(逆向建立单链表）（不带头结点）
LinkList  Nohead_List_HeadInsert(LinkList& L){
	LNode* s;  //声明一个临时结点
	int x;
	L = NULL;
	scanf("%d", &x);  //输入结点的值
	while (x != -1){
		s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		s->data = x;
		if (L == NULL) { // 若第一次创建节点，则将该点设置为头结点
			L = s;
			s->next = NULL;
		}else {                   // 若不是第一次创建节点，则直接将新节点接到链表头
			s->next = L;
			L = s;
		}
		scanf("%d", &x);
	}
	return L;
}

八：建单链表----尾插法(带头结点）

//建单链表----尾插法(正向建立单链表）（带头结点）
 LinkList Havehead_List_TailInsert1(LinkList &L){  //采用带有头结点的尾插法正向建立单链表
	 int x;
	 L = (LinkList)malloc(sizeof(LNode));  //创建头结点
	 LNode* s;
	 LNode *r=L;  //s为临时结点，r为表尾指针
	scanf("%d", &x);  //输入结点的值
	while (x != -1){
		s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		s->data = x;
		r->next = s;
		r = s;  //r指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;      //尾结点指针置空
	return L;
}

九：建单链表----尾插法(不带头结点）

//建单链表----尾插法(正向建立单链表）（不带头结点）
 LinkList Nohead_List_TailInsert(LinkList& L)  //采用不带有头结点的尾插法正向建立单链表
 {
	 int x;
	 LNode* s;
	 LNode* r = L=NULL;  //s为临时结点，r为表尾指针
	 scanf("%d", &x);  //输入结点的值
	 while (x != -1) {
		 s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		 s->data = x;
		 if (L == NULL){  // 创建链表的第一个节点
			 L = s;
			 r = s;
			 s->next = NULL;
		 } else {
			 r->next = s;
			 r = s;
		 }
		 scanf("%d", &x);
	 }
	 r->next = NULL;  //尾结点指针为空
	 return L;
 }

十：按位查找,返回第i位的地址（带头结点)

//按位查找,返回第i位的地址（带头结点)
LNode* Head_GetElem(LinkList L, int i) {
	if (i < 1)  return NULL;  //位置是第负数个的结点不存在
	LNode* p = L->next;               //因为头结点不保存数据，数据从头结点的下一个结点才开始保存
	int j = 0;//因为指针的值的是下一个结点的地址，所以注意这里不是int j=1;
	while (p != NULL && j < i) {//即当j=i的时候跳出循环
		p = p->next;
		j++;
	}
	return p;
}

十一：按位查找,返回第i位的地址（不带头结点)

//按位查找（不带头结点),返回第i位的地址
LNode* NoHead_GetElem(LinkList L, int i) {
	if (L == NULL || i <= 0) {
		return NULL;
	}
	LNode* p = L;
	int j = 0;//因为指针的值的是下一个结点的地址，所以注意这里不是int j=1;
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}

十二：按位序插入（带头结点）

//按位序插入（带头结点）
bool Havehead_ListInsert(LinkList& L, int i, ElemType e) {//即插入在第几个，插入的元素是i
	if (i < 1)  return false;
	/*如果是不带头结点的话,，则如果删除或插在第一个位置（这里是插入的情况下），需要更改头指针L，即加上下面的判断
	if (i==1){
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L= s;
		return true;
	}
	*/
	LNode* p = L;
	int j = 0;//表示当前p指向的是第几个结点,如果是不带头结点的话，则是  int j=1;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
}

十三：按位序插入（不带头结点）

//按位序插入（不带头结点）
//即插入在第几个，插入的元素是i
bool Nohead_ListInsert(LinkList & L, int i, ElemType e) {
	if (i < 1)  return false;
	if (i == 1) {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	LNode* p = L;
	int j = 1;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
}

十四:按位序删除（带头结点）

//按位序删除（带头结点）
bool HaveHead_ListDelete(LinkList& L, int i) {
	if (i < 1)    return false;
	LNode* p;                    //指针p指向当前扫描到的节点
	p = L;                           //令L指向头节点，头节点是第0个节点（不存数据）
	int j = 0;                   // 当前p指向的是第几个节点
	while (p != NULL && j < i - 1) {     //循环到第i-1个节点 
		p = p->next;
		j++;
	}
	if (p == NULL) return false;   //前面和插入操作差不多
	if (p->next == NULL) return false;          //第i-1个节点之后没有其他节点 
	LNode* q = p->next;                       //q指向被删除的节点 
	p->next = q->next;
	free(q);
	return true;
}

十五：按位序删除（不带头结点）

//按位序删除（不带头结点）
bool NoHead_ListDelete(LinkList& L, int i) {
	if (i < 1) {
		return false;
	}
	if (i == 1) {
		LNode* q = L;		// 头指针L指向链表第一个结点，声明一个指针变量q用来存储链表的第一个结点
		L = q->next;		//让头指针L指向链表的第二个结点
		free(q);		// 释放q结点，头指针L又指向原链表的第二个结点，那么就表示q结点被删了
	}
	LNode* p=L;
	int j = 0;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	if (p = NULL) {
		return false;
	}
	LNode* q = p->next;
	p->next = q->next;
	free(q);
	return true;
}

十六：求表长

int Length(LinkList  L) {//不带头结点的单链表操作中， //除了初始化InitList()，判空isEmpty(),按位查找GetElem()，插入ListInsert()，删除ListDelete()操作与带头结点的单链表有差别外，其它的操作基本上一样。
	int len = 0;                 
	LNode* p = L;//定义一个结点指向第一个结点
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

十七：基本测试代码

int main() {
	LinkList L;
	printf("下面先展示带头结点的单链表基本操作测试");

	printf("利用头插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Havehead_List_HeadInsert(L);
	HaveHead_PrintList(L);

	printf("利用尾插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Havehead_List_TailInsert1(L);
	HaveHead_PrintList(L);

	printf("在第1个位置插入元素11后:\n");
	Havehead_ListInsert(L, 1, 11);
	HaveHead_PrintList(L);

	printf("删除第一个元素后:\n");
	HaveHead_ListDelete(L, 1);
	HaveHead_PrintList(L);

	printf("查找第一个元素:\n");
	Head_GetElem(L, 1);
	HaveHead_PrintList(L);

	int len = Length(L);
	printf("表长 = %d\n",len);
	


	printf("\n***************************************************************************************************************************\n");
	printf("下面展示不带头结点的单链表基本操作测试");
	printf("利用头插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Nohead_List_HeadInsert(L);
	NoHead_PrintList(L);

	printf("利用尾插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Nohead_List_TailInsert(L);
	NoHead_PrintList(L);

	printf("在第1个位置插入元素11后:\n");
	Nohead_ListInsert(L, 1, 11);
	NoHead_PrintList(L);

	printf("删除第一个元素后:\n");
	NoHead_ListDelete(L, 1);
	NoHead_PrintList(L);

	printf("查找第一个元素:\n");
	NoHead_GetElem(L, 1);
	NoHead_PrintList(L);

	return 0;
}

十八：运行截图

十九：完整代码

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef  int ElemType;
typedef struct LNode {//定义一个结点结构
	ElemType data;//数据域
	struct LNode* next;//指针域，next是下一个结点的地址
}LNode,*LinkList;

//初始化(带头结点）
bool HaveHead_InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));//创建一个头结点，并为该头结点开辟一个结点所需要的空间（所以后面要是要加新结点，则需要另辟结点空间）
	if (L == NULL)   return false;//即：如果空间分配失败
	L->next = NULL;
	return true;
}

//初始化(不带头结点）
bool NoHead_InitList(LinkList& L) {
	L== NULL;//即空表，需要特别初始化为空   是因为：防止L在没有赋值的情况下携带脏数据而影响后序操作
	return true;
}

//判空(带头结点）
bool HaveHead_Empty(LinkList L) {
	if (L->next == NULL) //不带头结点则是  if(L==NULL)  return true;  else   return false;
		return true;
	else return false;
}

//建单链表----头插法(逆向建立单链表）（带头结点）
LinkList Havehead_List_HeadInsert(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));     //建立头结点 
	L->next = NULL; //初始尾空链表 （必须初始化） 
	LNode* s;
	int x;
	scanf("%d", &x);
	while (x != -1) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;              //即头结点指向新的结点 
		scanf("%d", &x);
	}
	return L;
}

//建单链表----头插法(逆向建立单链表）（不带头结点）
LinkList  Nohead_List_HeadInsert(LinkList& L){
	LNode* s;  //声明一个临时结点
	int x;
	L = NULL;
	scanf("%d", &x);  //输入结点的值
	while (x != -1){
		s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		s->data = x;
		if (L == NULL) { // 若第一次创建节点，则将该点设置为头结点
			L = s;
			s->next = NULL;
		}else {                   // 若不是第一次创建节点，则直接将新节点接到链表头
			s->next = L;
			L = s;
		}
		scanf("%d", &x);
	}
	return L;
}

//建单链表----尾插法(正向建立单链表）（带头结点）
 LinkList Havehead_List_TailInsert1(LinkList &L){  //采用带有头结点的尾插法正向建立单链表
	 int x;
	 L = (LinkList)malloc(sizeof(LNode));  //创建头结点
	 LNode* s;
	 LNode *r=L;  //s为临时结点，r为表尾指针
	scanf("%d", &x);  //输入结点的值
	while (x != -1){
		s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		s->data = x;
		r->next = s;
		r = s;  //r指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;      //尾结点指针置空
	return L;
}

//建单链表----尾插法(正向建立单链表）（不带头结点）
 LinkList Nohead_List_TailInsert(LinkList& L)  //采用不带有头结点的尾插法正向建立单链表
 {
	 int x;
	 LNode* s;
	 LNode* r = L=NULL;  //s为临时结点，r为表尾指针
	 scanf("%d", &x);  //输入结点的值
	 while (x != -1) {
		 s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		 s->data = x;
		 if (L == NULL){  // 创建链表的第一个节点
			 L = s;
			 r = s;
			 s->next = NULL;
		 } else {
			 r->next = s;
			 r = s;
		 }
		 scanf("%d", &x);
	 }
	 r->next = NULL;  //尾结点指针为空
	 return L;
 }

//按位查找,返回第i位的地址（带头结点)
LNode* Head_GetElem(LinkList L, int i) {
	if (i < 1)  return NULL;  //位置是第负数个的结点不存在
	LNode* p = L->next;               //因为头结点不保存数据，数据从头结点的下一个结点才开始保存
	int j = 0;//因为指针的值的是下一个结点的地址，所以注意这里不是int j=1;
	while (p != NULL && j < i) {//即当j=i的时候跳出循环
		p = p->next;
		j++;
	}
	return p;
}

//按位查找（不带头结点),返回第i位的地址
LNode* NoHead_GetElem(LinkList L, int i) {
	if (L == NULL || i <= 0) {
		return NULL;
	}
	LNode* p = L;
	int j = 0;//因为指针的值的是下一个结点的地址，所以注意这里不是int j=1;
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}

//按位序插入（带头结点）
bool Havehead_ListInsert(LinkList& L, int i, ElemType e) {//即插入在第几个，插入的元素是i
	if (i < 1)  return false;
	/*如果是不带头结点的话,，则如果删除或插在第一个位置（这里是插入的情况下），需要更改头指针L，即加上下面的判断
	if (i==1){
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L= s;
		return true;
	}
	*/
	LNode* p = L;
	int j = 0;//表示当前p指向的是第几个结点,如果是不带头结点的话，则是  int j=1;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
}

	//按位序插入（不带头结点）
	//即插入在第几个，插入的元素是i
	bool Nohead_ListInsert(LinkList & L, int i, ElemType e) {
		if (i < 1)  return false;
		if (i == 1) {
			LNode* s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			s->next = L;
			L = s;
			return true;
		}
		LNode* p = L;
		int j = 1;
		while (p != NULL && j < i - 1) {
			p = p->next;
			j++;
		}
	}

	//按位序删除（带头结点）
	bool HaveHead_ListDelete(LinkList& L, int i) {
		if (i < 1)    return false;
		LNode* p;                    //指针p指向当前扫描到的节点
		p = L;                           //令L指向头节点，头节点是第0个节点（不存数据）
		int j = 0;                   // 当前p指向的是第几个节点
		while (p != NULL && j < i - 1) {     //循环到第i-1个节点 
			p = p->next;
			j++;
		}
		if (p == NULL) return false;   //前面和插入操作差不多
		if (p->next == NULL) return false;          //第i-1个节点之后没有其他节点 
		LNode* q = p->next;                       //q指向被删除的节点 
		p->next = q->next;
		free(q);
		return true;
	}


	//按位序删除（不带头结点）
	bool NoHead_ListDelete(LinkList& L, int i) {
		if (i < 1) {
			return false;
		}
		if (i == 1) {
			LNode* q = L;		// 头指针L指向链表第一个结点，声明一个指针变量q用来存储链表的第一个结点
			L = q->next;		//让头指针L指向链表的第二个结点
			free(q);		// 释放q结点，头指针L又指向原链表的第二个结点，那么就表示q结点被删了
		}
		LNode* p=L;
		int j = 0;
		while (p != NULL && j < i - 1) {
			p = p->next;
			j++;
		}
		if (p = NULL) {
			return false;
		}
		LNode* q = p->next;
		p->next = q->next;
		free(q);
		return true;
	}


//求表长
int Length(LinkList  L) {//不带头结点的单链表操作中， //除了初始化InitList()，判空isEmpty(),按位查找GetElem()，插入ListInsert()，删除ListDelete()操作与带头结点的单链表有差别外，其它的操作基本上一样。
	int len = 0;                 
	LNode* p = L;//定义一个结点指向第一个结点
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

//带头结点的打印
void HaveHead_PrintList(LinkList L)
{

	LinkList p;
	p = L->next;
	printf("链表元素如下：\n");
	while (p != NULL)
	{

		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

//不带头结点的打印
void NoHead_PrintList(LinkList L)
{

	LinkList p;
	p = L;
	printf("链表元素如下：\n");
	while (p != NULL)
	{

		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}


int main() {
	LinkList L;
	printf("下面先展示带头结点的单链表基本操作测试");

	printf("利用头插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Havehead_List_HeadInsert(L);
	HaveHead_PrintList(L);

	printf("利用尾插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Havehead_List_TailInsert1(L);
	HaveHead_PrintList(L);

	printf("在第1个位置插入元素11后:\n");
	Havehead_ListInsert(L, 1, 11);
	HaveHead_PrintList(L);

	printf("删除第一个元素后:\n");
	HaveHead_ListDelete(L, 1);
	HaveHead_PrintList(L);

	printf("查找第一个元素:\n");
	Head_GetElem(L, 1);
	HaveHead_PrintList(L);

	int len = Length(L);
	printf("表长 = %d\n",len);
	


	printf("\n***************************************************************************************************************************\n");
	printf("下面展示不带头结点的单链表基本操作测试");
	printf("利用头插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Nohead_List_HeadInsert(L);
	NoHead_PrintList(L);

	printf("利用尾插法建立单链表,请输入一系列值最后以-1结束，例如请输入 21 32 6 30 15 89 43 -1:\n");
	L = Nohead_List_TailInsert(L);
	NoHead_PrintList(L);

	printf("在第1个位置插入元素11后:\n");
	Nohead_ListInsert(L, 1, 11);
	NoHead_PrintList(L);

	printf("删除第一个元素后:\n");
	NoHead_ListDelete(L, 1);
	NoHead_PrintList(L);

	printf("查找第一个元素:\n");
	NoHead_GetElem(L, 1);
	NoHead_PrintList(L);

	return 0;
}

*.✧屠苏隐遥(ﾉ◕ヮ◕)ﾉ*.✧
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的基本操作（3）：单链表实现栈
灰太狼
07-29 2338
我们知道，栈是一种“后进先出”的数据结构，对栈的插入和删除操作都是在栈头位置进行的，这与在单链表的表头插入和删除元素的原理类似，因此可以用单向链表实现栈。   单链表实现栈的Java代码： package parking; import java.util.Stack; class Node { Object data; Node next; public Node(Objec...
单链表的建立
热门推荐
m0_69300400的博客
04-11 1万+
一、顺序建立链表（尾插法） 1、首先建立一个只需头结点的空链表，此时头指针、尾指针均指向头结点 head=(struct node*)malloc(sizeof(struct node)); head->next=NULL; 2、在头结点后插入第一个节点 p=(struct node*)malloc(sizeof(struct node)); scanf("%d",&p->data); p->next=NULL; tail=head; tail->next..
单链表基础操作程序截图
06-12
单链表的基础操作程序，里面有详细的代码以及部分的截图
实验报告 基于C语言的数据结构单链表的操作（含完整代码运行截图）
weixin_47758084的博客
03-25 2307
②链式存储，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针，相较于顺序存储，插入或删除元素时很方便，使用灵活。（7）编写查找函数int ListLocate(ListItem x,List L)，该函数在链表中查找值为x的元素，没找到返回0，否则返回对应位置。（4）编写删除函数ListItem ListDelete(int k,List L)，实现在单链表L中删除位置k处的元素。typedef struct llist{/* 单链表类型 */
【数据结构实验一】- 单链表的实现，附-集合A、B的交并差集
m0_46233342的博客
02-13 2228
一、实验题目： 单链表的实现 二、实验目的： ⑴ 掌握线性表的链接存储结构； ⑵ 验证单链表及其基本操作的实现； ⑶ 进一步理解算法与程序的关系，能够将单链表算法转换为程序。 三、实验提示： 定义单链表的数据类型——单链表结构体Node在Node基础上实现题目要求的插入、删除、查找等基本操作，为便于查看操作结果，设计一个输出函数依次输出顺序表的元素。简单起见，本实验假定线性表的数据元素为int型，要求学生： （1）将实验程序调试通过后，用模板类改写； （2）加入求线性表的长度等基本操作； （3）重新给定测试
【详细图解加源代码和测试截图】单链表的一系列操作合集
记录学习点滴
04-26 1807
面试，笔试，刷题必备的单链表基本操作，内容涉及二级指针传参，每IT人都少不了经历， 进来瞅瞅后请各位自行细品！
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
Java单链表源码分析-DataStructures:该项目使用两种数据结构实现长整型ADT：单链表和数组。QuestionProgrammi
06-05
Java单链表源码分析数据结构 该项目使用两种数据结构实现长整型 ADT：单链表和数组。 QuestionProgramming Project 文件解释了该项目的前提。 许多应用程序，例如密码学，需要非常大的整数（比适合 32 位或 64 位...
数据结构与算法实验（C++）：单链表实验-代码
01-18
1）熟练掌握单链表的存储特点； 2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。 （2）实验内容： 1）在主函数中定义对象，并调用成员函数，验证单链表...
C语言版本 单链表实现，亲测可用
04-25
在标题提到的“C语言版本 单链表实现，亲测可用”，我们可以推断这是一个实现了常见单链表操作的C语言程序，包括创建链表、插入节点、删除节点、遍历链表等。代码风格良好且注释清晰，适合初学者理解和学习。 在...
《数据结构》实验二：线性表综合实验——（5）间接寻址
hpnynljy的博客
03-20 577
《数据结构》实验二：                线性表综合实验一．实验目的     巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二．实验时间   准备时间为第3周到第4周，具体集中实验时间为第4周第2次课。2个学时。 三．.实验内容1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入...
数据结构实验3、单链表的基本操作实现
Scarlett的博客
11-06 5769
实验三： 作者说： 写的如果有不太好的地方，欢迎大佬指点！ 一、运行效果截图 二、实验要求 实验3、单链表的基本操作实现 （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要
数据结构实验2.1（单链表）
Hpsyche的博客
09-23 1283
一．实验目的      巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。   二．.实验内容   建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 （用单链表来实现）。   三．.源代码 #include&lt;iostream&gt; using n...
数据结构之单链表实验
// 在校菜鸟大学生的日常学习博客
09-01 5921
单链表实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 掌握线性表的定义、特点、逻辑结构，理解线性表的抽象数据类型。 熟练掌握线性表的两种存储结构的结构类型定义、特点和基本操作的实现。 通过本次实验帮助学生加深对线性表的理解，并加以应用； 实验环境 CodeBlocks 实验要求 1.熟悉c语言的语法知识； 2.了解线性表的逻辑结构特性； 3.掌握线性表的链式存储结构—单链表的定义、创建、插入、删除、取值等基本操作； 实验内容 完成单链表的基本操作（定义、初始化、插入、删除、定位等）的汇总，
【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长
sjsjs11的博客
09-04 891
这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1049
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构(6.4_6)——拓扑排序
最新发布
m0_65240792的博客
09-04 293
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 655
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
C语言详解：单链表实现与操作
C语言单链表的实现是数据结构编程中一种基本且实用的数据结构，它通过一组动态分配的内存单元来存储线性表中的元素，每个元素由一个数据域（DataTypex）和一个指向下一个元素的指针（next）组成。本文档详细介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值