C语言 链表 案例

已于 2023-10-13 00:02:12 修改
阅读量130 收藏
点赞数
文章标签： c语言 链表 开发语言
于 2023-10-03 21:58:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhwx666/article/details/133529796
版权
一、案例内容：

1．建立单链表。

2．在单链表上实现插入、删除和查找等操作。

二、案例要求：

编写实现单链表基本操作的以下函数，并在此基础上设计一个主程序完成如下功能：

⑴初始化单链表L,类型自选;

⑵用头插法建立单链表L；

⑶用尾插法建立单链表L；

⑷输出单链表L的长度；

⑸输出单链表L的第i个元素(按位置查找)；

⑹输出给定元素的位置(按内容查找)；

⑺在第i个元素前插入给定元素（在第i个位置插入）；

⑻删除单链表L的第i个元素；

⑼输出单链表；

⑽清空单链表（只保留头结点）；

⑾菜单函数；

⑿单链表逆置；

⒀建立一个非递减排序的单链表。

三，案例设计

结构体

/*链表*/

typedef struct Linklist

{

    MOLD Data;

    struct Linklist* next;

}*Head,Node;

01-初始化链表

Init_Linklist()

/*1.在堆区开辟Node*类型的空间一块

* 2.将此head头指针指向此空间，即首节点

* 3.初始化数据，date存放节点个数，起始为0，next指向空

*/

02-尾插法 --从末尾依次插入

void Input_Linklist(Head head)

/*1.确定该链表的尾结点

* 2.输入数据

* 3.在堆区开辟新空间node

* 4.将数据赋给node->date，并将node->指向空，保证数据不会越界

* 5.将node地址赋给链表最后一个元素的next，head->Date，即结点个数加一

* 6.原来指向最后一个结点的指针向后移动一位

*/

03-头插法 将新结点插在首结点后面

void Head_insert(Head head)

/*1.输入数据

* 2.开辟新结点

* 3.新结点赋值

* 4.新结点指向首结点next

* 5.首结点next指向新结点

*/

04-链表输出

void Output_Linklist(Head head)

/*1.定义结点指针类型now接受链表中的每个结点

* 2.遍历链表，输出数据，当now->next为空，结束

*/

05-求长度

int Link_list_Length(Head head)

/*1.设置记录变量L,每遍历一次链表加一

* 2.返回L

* 3.也可以直接返回head->date，其中便存储结点长度

*/

06-定点查找

Node* Num_Find(Head head)

/*1.输入位置n

* 2.判断n值是否合理

* 3.遍历链表，直到找到第n个结点

* 4.返回该结点指针

*/

07-定值查找

Node* Ele_Find(Head head)

/*1.输入所要查找的元素

* 2.在链表中遍历寻找，直到找到该元素或链表遍历完

* 3.依据2的结果返回该链表地址或空指针

*/

08-删除元素

void LinkedList_Erase(Head head)

删除元素 定点删除  定元素删除

/*1.选择调用，插入查找也可以这样做*/

// 定点删除 

void Erase_Post(Head head)

/*1.定义两指针，分别表示当前结点，与其前驱结点的地址(当然，也可以只用当前元素前驱地址遍历链表，省空间)

*2.遍历链表，找到位置n

*3.将目标结点的后继地址赋给其前驱

* 4.释放目标节点，链表长度减一

*/

定元素删除

void Erase_Ele(Head head)

/*1.输入所要删除的元素，遍历链表找到目标元素，与查找元素方法相同

*2.更改目标元素前驱的后继为目标元素的后继

*3.释放目标节点，链表长度减一

*/

09-定点前插入 插入位置小于等于长度大于0

void Ahead_Insert(Head head)

/*1.判断插入位置是否合理

* 2.堆区开辟新空间给node指针，将之赋予该指针

* 3.将目标结点的后继赋给新指针的后继

* 4.将新结点地址赋给目标结点前驱的后继

* 5.结点数量加一

*/

10-定点后插入 0<n<=Length

void After_Insert(Head head)

/*1.找到目标结点

* 2.开辟新结点并赋值

* 3.将新结点后继指向目标结点后继

* 4.将新结点前驱改为目标结点

* 5.链表长度加一

*/

11-清空链表

void  Linked_list_Clear(Head head)

/*1.从前向后，找到最后的结点

 *2.将其前驱的后继改为空指针

 *3.释放最后的结点，链表长度减一

 *4.继续循环上述操作，直至链表清空

*/

12-排序 --此排序只是更改了本来链表中元素的值，并非对链表的链接进行改变

void Sort_list(Head head)

/*1.定义一个数据类型临时变量存储两个相邻结点中较大元素

* 2.将较小元素值赋给前面的结点

* 3.降临时变量值赋给后面结点，实现数据交换

*/

13-逆置

Head Invert_List(Head head)

/*1.将原来链表元素从头到尾使用前插法构建新的链表

* 2.将原链表的头指针指向新链表并返回新链表的头指针

*/

四，案例结果
菜单/初始化/头插法

尾插法

输出

长度

定点前插入

定点后插入

定值查找

定点查找

删除元素
定点

定值

排序

逆置

清空

五、案例总结
问题1:开始并没有考虑随时向链表中增添元素，尾插法只满足传入空链表，进行插入操作

改进:利用head->Date/遍历操作，找到该链表的尾结点，在尾结点后插入元素

问题2：清空链表如果只是将链表首结点的后继改为空，会造成空间浪费

改进：从前向后找寻尾结点，逐个改变其前驱的next指针，释放尾结点

但时间代价很大

经验1：开始在指定位置插入/删除元素时，习惯上只考虑了定义两个指针解决，实际上也可以只用目标结点前驱指针，修改边界条件即可完成上述操作，

或者化繁为简，将前驱上的操作经过赋值操作改编为后继结点上的操作，更为简单

六，案例源代码
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define MOLD int
/*链表*/
typedef struct Linklist
{
	MOLD Data;
	struct Linklist* next;
}*Head,Node;


//01-初始化链表
/*1.在堆区开辟Node*类型的空间一块
* 2.将此head头指针指向此空间，即首节点
* 3.初始化数据，date存放节点个数，起始为0，next指向空
*/
Head Init_Linklist()
{
	Node* node = (Node*)malloc(sizeof(Node));
	
	if (node)
	{	
		node->Data = 0;
		node->next = NULL;
		printf("初始化成功!!!\n");
	}
	Head head = node;
	return head;
}

//02-尾插法 --从末尾依次插入
/*1.确定该链表的尾结点
* 2.输入数据
* 3.在堆区开辟新空间node
* 4.将数据赋给node->date，并将node->指向空，保证数据不会越界
* 5.将node地址赋给链表最后一个元素的next，head->Date，即结点个数加一
* 6.原来指向最后一个结点的指针向后移动一位
*/
void Input_Linklist(Head head)
{	
	
	MOLD X;
	Node* Box,*last;
	last = head;
	for (int i = 0; i < head->Data; ++i)
	{
		last = last->next;
	}
	Box = last;
	while (1)
	{	

		printf("请输入所要增添的元素\n");
		scanf("%d", &X);
		Node* node= (Node*)malloc(sizeof(Node));
		
		if (node&&Box)
		{	
			node->Data = X;
			node->next = NULL;
			head->Data+=1;	
			Box->next = node;
		}

		int Key = 1;
		printf("是否继续输入(0/1)\n");
		scanf("%d", &Key);
		if (Key == 0) break;
		Box = Box->next;

	}
}
//04-链表输出
/*1.定义结点指针类型now接受链表中的每个结点
* 2.遍历链表，输出数据，当now->next为空，结束
*/
void Output_Linklist(Head head)
{
	Node* now = head->next;
	printf("该链表元素如下:\n");
	while (1)
	{
		if(now) printf("%d\t", now->Data);
		
		if (now&&now->next) now = now->next;
		else break;
	}
	printf("\n");
	
}
//03-头插法 将新结点插在首结点后面
/*1.输入数据
* 2.开辟新结点
* 3.新结点赋值
* 4.新结点指向首结点next
* 5.首结点next指向新结点
*/
void Head_insert(Head head)
{
	//Node* ptr = head->next;
	int Key = 6;
	printf("请输入所要插入的元素/输入666结束输入\n");
	while (1)
	{	
		Node* node = (Node*)malloc(sizeof(Node));
		scanf("%d", &Key);
		if (Key == 666) return;
		node->Data = Key;
		++head->Data;
		node->next = head->next;
		head->next= node;

	}
	
}
//05-求长度
/*1.设置记录变量L,每遍历一次链表加一
* 2.返回L
* 3.也可以直接返回head->date，其中便存储结点长度
*/
int Link_list_Length(Head head)
{
	Node* ptr = head->next;
	int L = 0;
	while (ptr)
	{
		++L;
		ptr = ptr->next;
	}
	printf("Length=%d\n", L);
	printf("该链表的长度为:%d\n", head->Data);
	return L;
}

//06-定点查找
/*1.输入位置n
* 2.判断n值是否合理
* 3.遍历链表，直到找到第n个结点
* 4.返回该结点指针
*/
Node* Num_Find(Head head)
{	
	printf("该链表的长度为:%d\n", Link_list_Length(head));
	printf("请输入所要查找的的元素位置:\n");
	int i=1,n;
	scanf("%d", &n);
	if (n == 0)
	{
		printf("输入不合理!!!\n");
		return NULL;
	}
	Node* ptr = head->next;
	while (i < n && ptr)
	{
		
		ptr = ptr->next;
		++i;
	}
	if (i == n)
	{
		printf("找到!!!\n");
		printf("该元素为%d\n", ptr->Data);
		return ptr;
	}
	printf("No找到!!!\n");
	return NULL;
}
//07-定值查找
/*1.输入所要查找的元素
* 2.在链表中遍历寻找，直到找到该元素或链表遍历完
* 3.依据2的结果返回该链表地址或空指针
*/
Node* Ele_Find(Head head)
{
	int x,n=0;
	Node* ptr = head->next;
	printf("请输入所要查找的元素:\n");
	scanf("%d", &x);
	while (ptr)
	{
		++n;
		if (x == ptr->Data)
		{	
			printf("找到!!!\n");
			printf("在第%d个位置\n", n);
			return ptr;
		}
		ptr = ptr->next;
	}
	printf("No找到!!!\n");
	return NULL;
}
//08-删除元素 
// 定点删除  
/*1.定义两指针，分别表示当前结点，与其前驱结点的地址(当然，也可以只用当前元素前驱地址遍历链表，省空间)
*2.遍历链表，找到位置n
*3.将目标结点的后继地址赋给其前驱
* 4.释放目标节点，链表长度减一
*/
void Erase_Post(Head head)
{
	//printf("该链表的长度为:%d\n", Link_list_Length(head));
	printf("该链表的长度为:%d\n", head->Data);
	printf("请输入所要删除的的元素位置:\n");
	int i = 1, n;
	scanf("%d", &n);
	if (n == 0)
	{
		printf("输入不合理!!!\n");
		return;
	}
	Node* ptr = head->next, * lastptr = head;
	while (i < n && ptr)
	{
		lastptr = ptr;
		ptr = ptr->next;
		++i;
	}
	if (i == n)
	{
		lastptr->next = ptr->next;
		free(ptr);
		--head->Data;
		printf("删除成功!!!\n");
	}
	

}

void Erase_Post_Plus(Head head)
{
	//printf("该链表的长度为:%d\n", Link_list_Length(head));
	printf("该链表的长度为:%d\n", head->Data);
	printf("请输入所要删除的的元素位置:\n");
	int i = 1, n;
	scanf("%d", &n);
	if (n == 0)
	{
		printf("输入不合理!!!\n");
		return;
	}
	Node* ptr = head;
	while (i < n && ptr)
	{
		
		ptr = ptr->next;
		++i;
	}
	if (i == n)
	{
		ptr->next = ptr->next->next;
		//free(ptr);  //额找不到 要删除的指针啦，此计可依，但非全策
		--head->Data;
		printf("删除成功!!!\n");
	}


}
//定元素删除
/*1.输入所要删除的元素，遍历链表找到目标元素，与查找元素方法相同
*2.更改目标元素前驱的后继为目标元素的后继
*3.释放目标节点，链表长度减一
*/
void Erase_Ele(Head head)
{
	int x;
	Node* ptr = head->next,*lastptr=head;
	printf("请输入所要删除的元素:\n");
	scanf("%d", &x);
	while (ptr)
	{	
		
		if (x == ptr->Data)
		{	
			lastptr->next = ptr->next;
			
			ptr = ptr->next;
			--head->Data;
			printf("删除成功!!!!\n");
			
		}
		else
		{
			lastptr = ptr;
			ptr = ptr->next;
		}
	}
	
}

//删除元素 定点删除  定元素删除
/*1.选择调用，插入查找也可以这样做*/
void LinkedList_Erase(Head head)
{
	int chose = 1;
	printf("Please chose the way to erase elemt \n");
	printf("01-定点删除\n02-定元素删除\n");
	scanf("%d", &chose);
	switch (chose)
	{
	/*case 1:Erase_Post_Plus(head);
		break;*/
	case 1:Erase_Post(head);
		break;
	case 2:Erase_Ele(head);
		break;
	}
}

//09-定点前插入 插入位置小于等于长度大于0
/*1.判断插入位置是否合理
* 2.堆区开辟新空间给node指针，将之赋予该指针
* 3.将目标结点的后继赋给新指针的后继
* 4.将新结点地址赋给目标结点前驱的后继
* 5.结点数量加一
* 也可以直接将所要插入元素的值赋给目标结点，将其改为后插
*/
void Ahead_Insert(Head head)
{	
	int i = 1, n;
	int X;
	printf("该链表的长度为:%d\n", head->Data);	
	printf("请输入所要插入的的元素位置:\n");
	scanf("%d", &n);
	
	if (n == 0||n>head->Data)
	{
		printf("输入不合理!!!\n");
		return;
	}
	printf("请输入所要插入的的元素:\n");
	scanf("%d", &X);
	Node* ptr = head->next, * lastptr = head;
	Node* New_node = (Node*)malloc(sizeof(Node));
	while (i < n && ptr)
	{
		lastptr = ptr;
		ptr = ptr->next;
		++i;
	}
	if (i == n)
	{	
		New_node->Data = X;
		New_node->next = ptr;
		lastptr->next =New_node;
		++head->Data;
		printf("添加成功!!!\n");
	}
}
//10-定点后插入 0<n<=Length
/*1.找到目标结点
* 2.开辟新结点并赋值
* 3.将新结点后继指向目标结点后继
* 4.将新结点前驱改为目标结点
* 5.链表长度加一
*/
void After_Insert(Head head)
{
	int i = 1, n;
	int X;
	printf("该链表的长度为:%d\n", head->Data);
	printf("请输入所要插入的的元素位置:\n");
	scanf("%d", &n);
	
	if (n == 0||n>head->Data)
	{
		printf("输入不合理!!!\n");
		return;
	}
	printf("请输入所要插入的的元素:\n");
	scanf("%d", &X);
	Node* ptr = head->next;
	Node* New_node = (Node*)malloc(sizeof(Node));
	while (i < n && ptr)
	{
		ptr = ptr->next;
		++i;
	}
	if (i == n)
	{
		New_node->Data = X;
		New_node->next = ptr->next;
		ptr->next = New_node;
		++head->Data;
		printf("添加成功!!!\n");
	}

}
//11-清空链表
//找最后一个，不好用
//Node* Last_Node(Node* node)
//{
//	if (node->next == NULL) return node;
//	else return Last_Node(node->next);
//}
//
//Node* Last02_Node(Node* node)
//{
//	
//		if (node->next&&node->next->next == NULL) return node;
//	else return Last_Node(node->next);
//}

/*1.从前向后，找到最后的结点
 *2.将其前驱的后继改为空指针
 *3.释放最后的结点，链表长度减一
 *4.继续循环上述操作，直至链表清空 
*/
void  Linked_list_Clear(Head head)
{	
	

	while (head->Data)
	{
		Node* ptr = head->next, * lastptr = head;
		for (int i = 1; i <= head->Data; ++i)
		{	
			
			if (i == head->Data)
			{
				lastptr->next = NULL;
				free(ptr);
				--head->Data;
			}
			lastptr = ptr;
			ptr = ptr->next;
			
		}
	}
	printf("清除成功!!!\n");
}

//12-排序 --此排序只是更改了本来链表中元素的值，并非对链表的链接进行改变
/*1.定义一个数据类型临时变量存储两个相邻结点中较大元素
* 2.将较小元素值赋给前面的结点
* 3.降临时变量值赋给后面结点，实现数据交换
*/
void Sort_list(Head head)
{	
	
	int temp = 0;
	for (int i = 0; i < head->Data-1; ++i)
	{	
		Node* ptr = head->next;
		for (int j = 0; j < head->Data-1-i; ++j)
		{
			if (ptr->Data > ptr->next->Data)
			{
				temp = ptr->Data;
				ptr->Data = ptr->next->Data;
				ptr->next->Data = temp;
			}
			ptr = ptr->next;
		}
	}
}

//13-逆置
/*1.将原来链表元素从头到尾使用前插法构建新的链表
* 2.将原链表的头指针指向新链表并返回新链表的头指针
*/
Head Invert_List(Head head)
{	
	Head temp=Init_Linklist();
	Node* ptr = head->next;
	for(int i=0;i<head->Data;++i)
	{
		Node* node = (Node*)malloc(sizeof(Node));
		node->Data =ptr->Data ;
		++temp->Data;
		node->next = temp->next;
		temp->next = node;
		ptr = ptr->next;
	}
	Output_Linklist(temp);
	head->next = temp->next;
	return temp;
}

//00-Menu
void Menu()
{
	printf("*****02-尾插法*********\n");
	printf("*****03-头插法*********\n");
	printf("*****04-链表输出*******\n");
	printf("*****05-求长度*********\n");
	printf("*****06-定点查找*******\n");
	printf("*****07-定值查找*******\n");
	printf("*****08-删除元素*******\n");
	printf("*****09-定点前插入*****\n");
	printf("*****10-定点后插入*****\n");
	printf("*****11-清空链表*******\n");
	printf("*****12-排序***********\n");
	printf("*****13-逆置***********\n");
	printf("******00-exit**********\n");
	printf("请选择你的操作:\n");

}

//测试1
void test01()
{
	Head head = Init_Linklist();
	Input_Linklist(head);
	Output_Linklist(head);
	printf("\nlength=%d", head->Data);
}

//
void test05()
{
	Head head=Init_Linklist();
	Head_insert( head);
	Output_Linklist( head);
	Link_list_Length(head);
	Num_Find(head);
	Ele_Find(head);
	Erase_Ele(head);
	Output_Linklist(head);
}

//
void test06()
{	
	Head head = Init_Linklist();
	int Key = 0;
	while (1)
	{
		Menu();
		scanf("%d", &Key);
		switch (Key)
		{
		case 2:Input_Linklist( head);
			break;
		case 3:Head_insert(head);
			break;
		case 4:Output_Linklist( head);
			break;
		case 5:Link_list_Length( head);
			break;
		case 6:Num_Find( head);
			break;
		case 7:Ele_Find(head);
			break;
		case 8:LinkedList_Erase(head);
			break;
		case 9:Ahead_Insert(head);
			break;
		case 10:After_Insert(head);
			break;
		case 11:Linked_list_Clear(head);
			break;
		case 12:Sort_list(head);
			break;
		case 13:Invert_List(head);
			break;
		case 0:exit(0);
		}
		system("pause");
		system("cls");

	}
}

int main()
{
	test06();
}

hhhwx666
关注
数据结构——单链表
m0_75013084的博客
04-23 642
（1）链表是以节点的方式来存储，是链式存储。（2）每个节点包含data域：存放数据，next域：指向下一个节点。（3）最后一个节点的next为null，表示链表结束。（4）链表是有序的列表，但是它在内存中。
单链表的基本功能C实现（各个功能：初始化，插入，删除，遍历，查询等）
qq_45784913的博客
08-23 809
C实现单链表的基本操作，可以利用工程更方便的书写代码，把方法的声明和实现测试分别放在不同的文件里，提高写代码的效率，附上代码： 方法的声明：link.h link.h //link.h文件，主要用于声明数据类型，结构体类型，以及方法的定义等 #pragma once typedef int ElemType;//定义数据的类型，方便更改 typedef struct LNOde//定义结点 { ElemType data; struct LNOde* next; }LNode, * LinkList;
单链表--数据结构实验
Khalid的博客
09-28 1657
数据结构实验--单链表 /*实现顺序表的各种基本运算；并在此基础上设计一个主程序，完成如下功能： （1） 初始化顺序表L（元素类型为char型） （2） 依次采用尾插法插入a, b, c, d, e元素 （3） 输出顺序表L （4） 输出顺序表L的长度 （5） 判断顺序表L是否为空 （6） 输出顺序表L的第3个元素 （7） 输出元素'a' 的位置 （8） 在第4个元素位置上插入'
第四周项目3-单链表的应用（1）单链表算法
ku258的博客
10-14 622
问题及代码： /* *Copyright (c) 2014,烟台大学计算机学院 *All rights reserved. *文件名称:单链表的应用 *作者：李子伦 *完成日期：2015年10月14日 * *问题描述：设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置， 即第一个结点的数据域变为an，…，最后一个结点的数据域为a1。实现这个算法，并完成
数据结构教程实验二链表基本操作的实现
Annzz123的博客
06-16 1730
1.实现单链表各种基本运算在实现单链表各种基本运算的基础上，设计主程序，完成如下功能：（1）初始化单链表h。（2）依次采用尾插法插入12，25，7，9，10共5个元素。（3）输出单链表h。 4）输出单链表h的长度5）判断单链表h是否为空。（6）输出单链表h第4个元素。（7）输出元素5的位置。（8）在第4个元素的位置上插入元素100。（9）输出单链表h。（10）删除单链表h的第3个元素。（11）输出单链表h。（12）释放单链表h。
学生信息管理系统C语言链表版.rar
08-28
本项目"学生信息管理系统C语言链表版"就是一个很好的实践案例，它利用链表这一数据结构来存储和操作学生信息，具有较高的学习价值。 链表是一种线性数据结构，与数组不同，它不连续存储元素，而是通过指针将各个...
商品库存管理系统C语言 链表结构
06-05
### 商品库存管理系统C语言链表结构知识点解析 #### 核心知识点概述 本文将围绕“商品库存管理系统C语言链表结构”这一主题展开讨论。主要介绍如何利用C语言中的链表来实现一个基本的商品库存管理系统，包括添加...
C语言链表实现学生信息管理
01-21
### 题目：C语言链表实现学生信息管理 #### 描述： 这是一个用C语言编写的简单程序，通过链表技术实现了学生信息的管理功能。用户可以通过简单的命令行界面执行各种操作，如添加、删除、修改、查询学生信息以及保存...
基于c语言链表的员工管理系统案例（包含对员工数据的，插入、删除、查询、修改 ）的实训报告
06-09
**基于C语言链表的员工管理系统案例** 在计算机科学与技术领域，开发一个员工管理系统是学习数据结构和程序设计的常见实践项目。本实训报告主要关注使用C语言实现基于链表的数据结构来构建一个简单的员工管理系统。...
精选_基于C语言链表实现的订餐系统_源码打包
04-04
在本项目中，"精选_基于C语言链表实现的订餐系统_源码打包"是一个用C语言编写的订餐系统，它充分利用了链表这一数据结构来管理餐厅的菜单、订单和客户信息。下面将详细介绍这个系统的核心知识点。 1. **C语言**：...
数据结构第二次上机 第二章之单链表
Haruno_Sakura的博客
11-04 3166
实验题 2：实现单链表的各种基本运算的算法 2. 编写一个程序linklist.cpp，实现单链表的各种基本运算和整体建表运算（假设单链表的元素类型为char），并在此基础上设计一个程序exp2-2.cpp完成以下功能： （1）初始化单链表h； （2）采用尾插法依次插入元素a，b，c，d，e； （3）输出单链表h； （4）输出单链表h长度； （5）判断单链表h是否为
数据结构-实验2 单链表
weixin_43488714的博客
11-28 1205
【问题描述】 设计一个单链表操作演示程序。 【基本要求】 设计实现一个带头结点的单链表的操作演示程序，提供一个用户界面，可演 示的基本功能包括： （1）初始化单链表； （2）输入并建立单链表；（头插入法、尾插入法均可） （3）输出单链表中的元素； （4）在单链表指定位置插入元素； （5）在单链表指定元素之前插入元素； （6）删除单链表指定位置的元素； （7）删除单链表指定元素之前的元素； （8）删...
数据结构上机实验：单链表操作
逆风的方向 更适合飞翔
03-19 4176
#include #include using namespace std; typedef struct Node { char c; struct Node *next; }*LinkList,LNode; //初始化单链表h LinkList Init(LinkList &h) { h=(LNode*)malloc(sizeof(LN
单链表的基本操作
Fitz的博客
01-18 1687
实验题目；单链表基本操作 实验目的；1．掌握用 C/C++语言调试程序的基本方法。 2．掌握线性表的基本运算，如插入、删除等 •  实验内容；编写程序实现单链表的各种基本运算，并在此基础上设计一个主程序完成如下功能： •  （1）初始化单链表h； •  （2）依次采用头插法插入元素-1,21,13,24,8； •  （3）输出单链表h; •  （4）输出单链表h长度； •  （5）
编写实现单链表的各种基本运算，并在此基础上设计一个主函数完成如下功能：
Helioj的博客
05-28 3132
##单链表基本运算的笔记（可供一些初学者学习） （1）初始化单链表L。 （2）依次采用尾插法插入h、e、l、l、o。 （3）输出单链表L。 （4）输出单链表L的长度。 （5）判断单链表L是否为空。 （6）输出单链表L的第2个和第4个元素。 （7）输出元素o位置。 （8）在单链表L的第4个位置上插入元素r。 （9）输出单链表L。 （10）删除单链表L的第3个元素。 （11）输出单链表L。 （12）释放单链表L。 #include <stdio.h> #include <malloc.h&gt
单链表应用实例
jefferyfg的博客
09-25 2641
在学习单链表之前，先简单了解一下链表 链表是有序的链表，但它在内存中是存储如下 链表是以节点的方式来存储的，是链式存储 每个节点包含data域、next域：指向下一个节点 链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头结点的列表，根据实际需求来定 单链表（带头结点）逻辑结构示意图如下： 单链表的应用实例： 使用带head头节点的单向链表实现水浒英雄人物的增删改查操作 ， 1....
C 语言中 & 符号的两种用途
m0_46398975的博客
09-23 405
C 语言中 `&` 符号的两种用途
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1752
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
永磁同步电机（PMSM）基于高阶滑模观测器（HSMO）的无位置传感器速度控制仿真
最新发布
10-01
永磁同步电机（PMSM）基于高阶滑模观测器（HSMO）的无位置传感器速度控制仿真。
C语言链表实现贪吃蛇教程
这个C语言实现的贪吃蛇游戏是一个很好的学习案例，它展示了如何用基本的数据结构（链表）和控制台I/O来构建一个功能完备的游戏。对于初学者来说，它提供了一个实践C语言编程技巧，特别是链表操作和控制台交互的好...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值