C语言单链表代码实现

于 2024-04-09 23:12:02 发布
阅读量663 收藏 10
点赞数 18
分类专栏： 浙大版《C语言程序设计（第4版）》题目集参考答案 浙大版《C语言程序设计实验与习题指导（第4版）》题目集 c语言习题 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skhoole/article/details/137571590
版权
本文详细介绍了如何使用C语言设计算法，包括单链表的创建、元素操作（查找、插入、删除），以及链表转换为循环链表、有序表插入、元素逆置和两个有序表的合并。
摘要由CSDN通过智能技术生成

声明：著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除，求表长、有序表插入、元素逆置、2个有序表合并等。

#include <stdio.h>
#include <stdlib.h>

//单链表的定义：
typedef int DataType;		//DataType可以是任何相应的数据类型如int, float或char

typedef struct ListNode			//结点类型定义
{	DataType data;			//结点的数据域
	struct ListNode *next;		//结点的指针域
}ListNode;

typedef ListNode *LinkList;
//测试用例		1 2 3 4 5 6 7 8 9 10 -1
			//	4 6 8 10 12 -1
int main()
{
	int i,j;
	DataType key,x;
	LinkList head=NULL;

	LinkList CreateList();
	void PrintList(LinkList head);
	int LocateNode(LinkList head,DataType key);
	void InsertList(LinkList head,DataType x,int i);
	void DeleteList(LinkList head,int i);
    void ChangeCircList(LinkList head);
	void PrintCircList(LinkList head);
	void InsertOrderList(LinkList head,int x);
	LinkList reverseList(LinkList head);
	void MergeList_L(LinkList La,LinkList Lb,LinkList *Lc);

	char choice;
	while (1)
	{
		system("cls");
		printf("\n\n\n\n");
		printf("\t\t              链表操作  \n");
		printf("\t\t======================================");
		printf("\n\n");
		printf("\t\t             1：建立单链表            \n");
		printf("\t\t             2：显示单链表            \n");
		printf("\t\t             3：查找                  \n");
		printf("\t\t             4：插入                  \n");
		printf("\t\t             5：删除                  \n");
        printf("\t\t             6：改为循环单链表并显示  \n");
        printf("\t\t             7：有序表插入            \n");
        printf("\t\t             8：元素逆置              \n");
        printf("\t\t             9：2个有序表合并         \n");
		printf("\n");
		printf("\t\t             0：退出        \n");
		printf("\n");
		printf("\t\t请选择：");

		choice = getchar();
		system("cls");

		switch(choice)
		{
			case '1':
				printf("输入单链表：");
				head=CreateList();
				printf("链表创建成功！\n");
				getchar();/*第一个getchar会接收到上面createList函数中scanf最后敲击的回车
所以后面再加一个，这样系统才会等待下一个字符进入，才能看得到东西 */
				getchar();
				break;
			case '2':
				PrintList(head);
				getchar();
                getchar();
				break;
			case '3':
		        printf("输入要查找的值：");
            	scanf("%d",&key);
            	j=LocateNode(head,key);	//单链表查找
				printf("要查找的值在第%d个\n",j);
				getchar();
				getchar();
				break;
			case '4':
				printf("请输入欲插入元素的位置：");
	            scanf("%d",&i);
             	printf("请输入欲插入的元素：");
	            scanf("%d",&x);
	            InsertList(head,x,i);	//单链表插入
	            PrintList(head);			//输出顺序表
				getchar();
				getchar();
				break;
			case '5':
				printf("请输入欲删除结点的位置：");
	            scanf("%d",&i);
	            DeleteList(head,i);		//单链表删除
	            PrintList(head);			//输出顺序表
				getchar();
				getchar();
				break;
			case '6':
                ChangeCircList(head);	//修改为循环单链表
                printf("改为循环单链表成功：\n");
				PrintCircList(head);	//输出循环单链表
				getchar();
				getchar();

				break;
			case '7':
				printf("请输入欲插入有序表的元素：");
	            scanf("%d",&x);
				InsertOrderList(head,x);
				PrintList(head);
				getchar();
				getchar();
				break;
			case '8':
				head=reverseList(head);
				printf("逆置成功\n");
				PrintList(head);
				getchar();
				getchar();
				break;
			case '9':
				printf("输入要被合并的顺序表：");
				LinkList Lb;
				LinkList Lc;
				Lb=CreateList();
				printf("链表创建成功！\n");
				MergeList_L(head,Lb,&Lc);
				printf("顺序表合并成功！\n");
				PrintList(Lc);
				getchar();
				getchar();
				break;
			case '0':
				exit(0);
		}
	}
}

LinkList CreateList()
{
    int num;
    int head_data;
    struct ListNode *s, *r, *h = (struct ListNode *)malloc(sizeof(struct ListNode));
    scanf("%d", &head_data);
    h->data = head_data;
    r = h; /* 尾指针初值指向头结点 */
    scanf("%d", &num);
    while (num != -1)
    {
        s = (struct ListNode *)malloc(sizeof(struct ListNode)); /* 生成新结点*/
        if (s == NULL)
        {
            printf("内存分配失败\n");
            exit(-1);
        }
        s->data = num;
        r->next = s;

        r = s;
        scanf("%d", &num); // 更新输入的 num 值
    }
    r->next = NULL;
    return h; /* 返回头指针 */
}

//单链表的输出：
void PrintList(LinkList head)
{
	int c=0;
    LinkList cur;
    if (head != NULL)
        cur = head;
    else{
        printf("no node");
        return;
    };
	while (cur != NULL){
        printf("%d ", cur->data);
        c++;
        cur = cur->next;
	}
	printf("\n现在表长为：%d", c);
	return;

}

//单链表的查找：
int LocateNode(LinkList head,DataType key)
{
	int c=1;
	ListNode *p=head;//->next; /* 从开始结点比较 */
 	while (p&&p->data!=key){ /* 直到 p 为 NULL 或 p->data 是 key为止 */
 	p=p->next; /* 扫描下一结点 */
 	c++;}
 	return c;
}

//单链表的插入：
void InsertList(LinkList head,DataType x,int i)
{
	ListNode *p=head,*s;
	int j=0;
	int c=2;/* 寻找第 i-1 个结点 */
 	while (p&&c<i){ /* 直到 p 为 NULL 或 p->data 是 key为止 */
 	p=p->next; /* 扫描下一结点 */
 	c++;
	 }
if(p==NULL){
printf(" 插入位置非法 \n");
exit(0);
}
s=(LinkList)malloc(sizeof(ListNode));
s->data=x;
s->next=p->next;
 p->next=s;
}

//单链表的删除：
void DeleteList(LinkList head,int i)
{
	 ListNode *p=head,*q;
 int c=2;/* 寻找第 i-1 个结点 */
 	while (p&&c<i){ /* 直到 p 为 NULL 或 p->data 是 key为止 */
 	p=p->next; /* 扫描下一结点 */
 	c++;
	 }
 if(p==NULL||p->next==NULL){
 printf(" 删除位置非法 \n");
 exit(0);
 }
 q=p->next; // 临时保存被删结点的地址以备释放
 p->next=q->next; // 改变删除结点前驱结点的指针域

 free(q); // 释放删除结点的空间
}


//修改为循环单链表：
void ChangeCircList(LinkList head)
{
	ListNode *p=head;//->next; /* 从开始结点比较 */
 	while (p->next)/* 直到 p->next 为 NULL是 key为止 */
 	p=p->next; /* 扫描下一结点 */
 	p->next=head;

}


//循环单链表的输出：
void PrintCircList(LinkList head)
{
	LinkList cur;
	int c=0;
    if (head != NULL)
        cur = head;
    else{
        printf("no node");
        return;
    };
	while (cur->next != head){
        printf("%d ", cur->data);
        cur = cur->next;
        c++;
	}

	printf("%d ", cur->data);
	c++;
	printf("\n现在表长为：%d ", c);
	return;
}

void InsertOrderList(LinkList head,int x)
{
	ListNode *p=head,*s;
	int j=0;
 	while (p->data<x){
 	p=p->next; /* 扫描下一结点 */
  }
s=(LinkList)malloc(sizeof(ListNode));
s->data=x;
s->next=p->next;
 p->next=s;
}

LinkList reverseList(LinkList head)
{
	if (head == NULL || head->next == NULL) {
        return head;
    }
    // 例：1->2->3->4->5-null，从 if 递归出口返回时 newHead = 5, head = 4（递归特点：谁调用返回给谁）
    LinkList newHead =reverseList(head->next);
    // head = 4, newHead = 5, head.next.next = 4.next.next = 5.next = 4
    head->next->next = head;
    // 避免链表成环，5->4->null
    head->next = NULL;
    // 返回新的头节点
   	return newHead;
}


void MergeList_L(LinkList La, LinkList Lb, LinkList *Lc) { // 修改参数类型，
    LinkList pa = La;
    LinkList pb = Lb;
    LinkList pc;

    if (La->data < Lb->data) {
        pc = La;
        *Lc = La;
        pa = La->next;
    } else {
        pc = Lb;
        *Lc = Lb;
        pb = Lb->next;
    }

    while (pa && pb) {
        if (pa->data <= pb->data) {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        } else {
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }
    }

    pc->next = pa != NULL ? pa : pb; // 插入剩余段
    //free(Lb);
}
四、运行输出结果：
LinkList CreateList();
输入单链表：1 2 3 4 5 6 7 8 9 10 -1
链表创建成功！
	void PrintList(LinkList head);
1 2 3 4 5 6 7 8 9 10
现在表长为：10
	int LocateNode(LinkList head,DataType key);
输入要查找的值：5
要查找的值在第5个
	void InsertList(LinkList head,DataType x,int i);
请输入欲插入元素的位置：2
请输入欲插入的元素：4
1 4 2 3 4 5 6 7 8 9 10
现在表长为：11
	void DeleteList(LinkList head,int i);
请输入欲删除结点的位置：2
1 2 3 4 5 6 7 8 9 10
现在表长为：10
void ChangeCircList(LinkList head);void PrintCircList(LinkList head);
改为循环单链表成功：
1 2 3 4 5 6 7 8 9 10
现在表长为：10
	void InsertOrderList(LinkList head,int x);
请输入欲插入有序表的元素：4
1 2 3 4 4 5 6 7 8 9 10
现在表长为：11
	LinkList reverseList(LinkList head);
逆置成功
10 9 8 7 6 5 4 3 2 1
现在表长为：10
	void MergeList_L(LinkList La,LinkList Lb,LinkList *Lc);
输入要被合并的顺序表：4 6 8 10 12 -1
链表创建成功！
顺序表合并成功！
1 2 3 4 4 5 6 6 7 8 8 9 10 10 12
现在表长为：15

运行输出结果：

LinkList CreateList();

输入单链表：1 2 3 4 5 6 7 8 9 10 -1

链表创建成功！

void PrintList(LinkList head);

1 2 3 4 5 6 7 8 9 10

现在表长为：10

int LocateNode(LinkList head,DataType key);

输入要查找的值：5

要查找的值在第5个

void InsertList(LinkList head,DataType x,int i);

请输入欲插入元素的位置：2

请输入欲插入的元素：4

1 4 2 3 4 5 6 7 8 9 10

现在表长为：11

void DeleteList(LinkList head,int i);

请输入欲删除结点的位置：2

1 2 3 4 5 6 7 8 9 10

现在表长为：10

void ChangeCircList(LinkList head);void PrintCircList(LinkList head);

改为循环单链表成功：

1 2 3 4 5 6 7 8 9 10

现在表长为：10

void InsertOrderList(LinkList head,int x);

请输入欲插入有序表的元素：4

1 2 3 4 4 5 6 7 8 9 10

现在表长为：11

LinkList reverseList(LinkList head);

逆置成功

10 9 8 7 6 5 4 3 2 1

现在表长为：10

void MergeList_L(LinkList La,LinkList Lb,LinkList *Lc);

输入要被合并的顺序表：4 6 8 10 12 -1

链表创建成功！

顺序表合并成功！

1 2 3 4 4 5 6 6 7 8 8 9 10 10 12

现在表长为：15

C语言单链表代码
weixin_42104550的博客
08-26 2981
下面的内容对初学者来说很抽象，建议多画图理解，或者去看熟悉我的C语言内存结构以及指针研究的文章再来理解链表。 顺序表的缺点可以用链表来解决，链表也分为单链表和双链表。这一文只展示单链表的代码。为什么单链表的访问效率极高，而且不会因为表的长度而影响的。因为链表在每一个数据前面都有一个地址头，也就是说链表的每个数据其实是有头有尾的，头是一个指向尾的地址，尾部才是真正的用户存储的数据。 每个数据是这样存储的，next是地址指针 data才是数据。每个数据都是独立的一个节点，只是这些块节点有next指针把它们串
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2548
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //ADT 线性表（List） 链式存储结构 LinkList #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义单链表 typedef struct Node {
数据结构-单链表(C语言代码)
weixin_50246370的博客
08-05 355
数据结构纯属新手，小白一枚，欢迎批评指正！ 直接上代码OVO！ 定义结构体 typedef struct Node { int data; //数据域 struct Node* next; //指针域 }Node; 单链表只有数据域和指向下一个结点的指针域。 创建链表 //创建链表 Node* initList() { Node* L = (Node*)malloc(sizeof(Node)); //创建头指针 L->data = 0; L->next = NULL;//刚
c语言单链表代码
热门推荐
qq_41555580的博客
04-20 1万+
// 操作系统 win 8.1 // 编译环境 Visual Stuido 2017 #include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef int ElementType; // 定义数据类型,可根据需要进行其他类型定义 // 链表节点的定义 type...
数据结构-C语言版-单链表C语言代码
weixin_45404725的博客
07-21 594
最近终于搞定了单链表的查询，插入，删除，输出等等操作，但是在学习的时候发现严奶奶的书上，全是只有算法，对于我这种第一次学数据机构的人来说是很有难度的，因为习惯了C语言的书写规则，起初根本看不懂算法，无法将书上的算法翻译成C语言程序，经过一番资料查找后算是解决了，参考了网上的一些代码，但是均有小错误，请教之后没有回应，因该也不是作者本人只是转载的。故直接贴上我自己写的程序。注：算法部分还是和书上一样的。 注释：LinkList 就是单链表；GetElem:是查询函数；ListIsert:是插入函数，List
C语言单链表实现
01-16
通过这些基本操作，你可以构建和操作简单的C语言单链表。在学习过程中，理解指针和动态内存分配的重要性是至关重要的，因为它们是实现链表的关键。此外，实践编写和调试这些操作的代码将有助于加深对链表工作原理的...
C语言 单链表的实现
06-28
(1)熟悉将算法转换为程序代码的过程。 (2)了解顺序表的逻辑结构特性，熟练学握顺序表存储结构的 C 语言描述方法。 (3)熟练学握顺序表的基本运算:查找、插入、删除等，学握顺序表的随机存取特性。 (4)了解线性表的...
教师管理系统（C语言）（单链表）
07-03
1、实现软件：Dev-C++ 2、详细的测试页面可见我《资源》专栏下的《C语言系统资源测试》。 3、适合新手下载学习。 4、基于C语言的单链表实现。 5、代码共461行 6、注释多，排版有序
数据结构-单链表-C语言代码
qq_66518801的博客
07-31 1572
概念链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的//把要存储的数据重新定义一下typedefstructSListNode{//数据域structSListNode*next;//定义一个指针}SLTNode;//头指针SLTNode*plist=NULL;//plist永远指着第一个//头插//...以下是测试代码}............
C语言单链表(代码和讲解)
08-28
C语言单链表(代码和讲解) C语言单链表(代码和讲解) C语言单链表(代码和讲解) C语言单链表(代码和讲解)
单链表的C语言实现 完整C代码
11-06
单链表的C语言实现，按照严蔚敏数据结构（C语言版）给的ADT写的，可能不太全。
单链表(C语言)
09-29
C语言的单链表，有存储、查询、删除等功能，代码简单，有注释。适合初学者
c语言的单链表代码（数据结构）
weixin_43034048的博客
02-24 274
单链表基础代码
单链表C语言代码实现
去无人的岛，摸鲨鱼的角
09-21 2774
单链表的创建，删除，插入操作
c语言_单向链表代码
weixin_38293453的博客
02-15 258
一、LinkTable.h文件 //LinkTable结构体实现 typedef struct Link{ int elem; struct Link *next; }node; #define initTableSize 5 node * initLinkTable(); int selectElem(node *p, int elem); node *amendElem(node ...
数据结构链表（单链表、顺序表）的C语言代码以及实现
最新发布
changan277的博客
03-06 925
使用C语言实现数据结构中单链表和顺序表相关代码
线性表-单链表（含完整C代码）
weixin_54186646的博客
03-07 3068
单链表完整C语言代码实现
一个完整的c语言的单链表代码,单链表完整C语言纯代码.docx
weixin_39610724的博客
05-21 674
单链表完整C语言纯代码单链表完整C语言纯代码带头结点的单链表PAGE \* MERGEFORMAT 4单链表带头结点#include #include /*带头结点的单链表的操作在该链表中，数据元素是int，我们让头结点的数据域存储链表的实际长度*//*链表节点的类型定义*/struct node{int data;struct node *next;};/*链表的初始化函数在该函数中要分配头...
C语言单链表实现与测试代码下载
总结，该资源为读者提供了一个完整的C语言单链表实现的参考，不仅包含了基本的数据结构定义和操作函数实现，还包括了实际操作的测试代码。通过参考该资源，读者可以更好地理解单链表在C语言中的应用，并能够在自己的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值