数据结构链表（单链表、顺序表）的C语言代码以及实现

最新推荐文章于 2024-04-23 15:14:23 发布
最新推荐文章于 2024-04-23 15:14:23 发布
阅读量612 收藏 11
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/changan277/article/details/136508596
版权

一、顺序表

1.顺序表的结构体定义：顺序表可使用数组来实现

#define MAXSIZE 20

typedef struct SqList
{
	int* data;//注意这里是数组
	int length;
}SqList;

2.顺序表的初始化：

初始化顺序表后为顺序表的data域申请内存空间,L可以认为是顺序表的头结点，头结点的data域用来存放链表的长度

#define MAXSIZE 100
#include <stdio.h>
#include <stdlib.h>

typedef struct SqList
{
	int* data;//注意这里是数组
	int length;
}SqList;

SqList InitSqList()
{
	SqList L;
	L.data = (int*)malloc(MAXSIZE * sizeof(int));
	L.length = 0;
	return L;
}

int main()
{
    SqList* L=InitSqList();
    return 0;
}

3.获取顺序表指定位置元素

注意判断要获取的数据是否在链表范围内

//获取顺序表指定位置的元素
int GetElem(SqList L, int i, int x)
{
	if (i<1||i>L.length)
		return 0;
	else
	{
		x = L.data[i];
		return x;
	}
}

4.查找链表中第一个值为x的数据，并获取其数组下标

//查找顺序表中第一个值等于x的元素
void SearchSqList(SqList L, int x)
{
	int i = 0;
	for (i = 0; i <= L.length; i++)
	{
		if (L.data[i] == x)
		{
			printf("表中第一个值为%d的元素下标为%d\n", x, i);
			return;
		}
	}
	printf("表中没有值为%d的元素\n", x);
}

5.插入元素

//插入元素
int InsertSqList(SqList L, int i, int x)
{
	if (i<0 || i>L.length || L.length == MAXSIZE)
		return 0;
	for (int j = L.length; j >= i; j--)
	{
		L.data[j + 1] = L.data[j];
	}
	L.data[i] = x;
	L.length++;
	return 1;

}

6.删除元素

//删除元素
int DeleteSqList(SqList L, int i)
{
	if (i<0 || i>L.length)
		return 0;
	for (int j = i; j <= L.length; j++)
	{
		L.data[j] = L.data[j + 1];
	}
	L.length--;
	return L.data[i];
}

总体代码实现：

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

#define MAXSIZE 20

typedef struct SqList
{
	int* data;//注意这里是数组
	int length;
}SqList;

SqList InitSqList()
{
	SqList L;
	L.data = (int*)malloc(MAXSIZE * sizeof(int));
	L.length = 0;
	return L;
}

//获取顺序表指定位置的元素
int GetElem(SqList L, int i, int x)
{
	if (i<1||i>L.length)
		return 0;
	else
	{
		x = L.data[i];
		return x;
	}
}

//查找顺序表中第一个值等于x的元素
void SearchSqList(SqList L, int x)
{
	int i = 0;
	for (i = 0; i <= L.length; i++)
	{
		if (L.data[i] == x)
		{
			printf("表中第一个值为%d的元素下标为%d\n", x, i);
			return;
		}
	}
	printf("表中没有值为%d的元素\n", x);
}

//以此打印表中数据
void PrintSqList(SqList L)
{
	printf("表中数据为：");
	for (int i = 0; i < L.length; i++)
	{
		printf("%d->", L.data[i]);
	}
	printf("NULL\n");
}

//插入元素
int InsertSqList(SqList L, int i, int x)
{
	if (i<0 || i>L.length || L.length == MAXSIZE)
		return 0;
	for (int j = L.length; j >= i; j--)
	{
		L.data[j + 1] = L.data[j];
	}
	L.data[i] = x;
	L.length++;
	return 1;

}

//删除元素
int DeleteSqList(SqList L, int i)
{
	if (i<0 || i>L.length)
		return 0;
	for (int j = i; j <= L.length; j++)
	{
		L.data[j] = L.data[j + 1];
	}
	L.length--;
	return L.data[i];
}


int main()
{
	SqList L = InitSqList();
	printf("请输入顺序表元素个数\n");
	int n = 0;
	scanf("%d", &n);
	printf("请依次输入顺序表元素\n");
	for (; L.length < n; L.length++)
	{
		scanf("%d", &L.data[L.length]);
	}
	printf("创建成功\n");
	PrintSqList(L);
	SearchSqList(L, 99);
	InsertSqList(L, 1, 99);
	PrintSqList(L);
	SearchSqList(L, 99);
	DeleteSqList(L, 1);
	PrintSqList(L);

	SearchSqList(L, 99);

	return 0;
}

二、单链表

1.单链表的结构体定义及初始化：

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

//单链表结构体定义：
typedef struct Node
{
	int data;
	struct Node* next;
}LNode;

//初始化单链表
Node* InitList()
{
	LNode* list = (LNode*)malloc(sizeof(LNode));
	list->data = 0;
	list->next = NULL;
	return list;
}

int main()
{
    LNode* list=InitList();
    return 0;
}

2.单链表的插入

①头插法：

此处需要注意node->next = list->next;不能放在list->next = node;之后，因为list->已经被赋值为node了。不管是头插法还是尾插法一定要注意有几行代码的顺序是不能颠倒的。

插入新结点的基本思想：

初始化一个临时变量并为其申请内存空间->为该变量的data域赋值->根据插入方法来寻找插入位置->插入新结点。

//单链表插入——头插法(默认含头结点)
void HeadInsert(LNode* list, int data)
{
	LNode* node = (LNode*)malloc(sizeof(LNode));
	node->data = data;
	node->next = list->next;
	list->next = node;
	list->data++;//list是头结点，头结点的data域用来记录结点的个数
}

②尾插法：

此处使用while循环来找到链表的最后一个结点，当head->next为空则循环条件不成立，退出循环，此时的head就是链表的最后一个结点

//单链表插入——尾插法(默认含头结点)
void TailInsert(LNode* list, int data)
{
	LNode* head = list;
	LNode* node = (LNode*)malloc(sizeof(LNode));
	node->data = data;
	node->next = NULL;
	while (head->next)
	{
		head = head->next;
	}
	head->next = node;
	list->data++;
}

3.删除单链表中值为data的结点：

此处需要定义一个临时变量pre来记录删除结点的上一个结点的地址，即是方便删除操作，也是为了避免结点删除后就找不到上一个结点的地址从而无法连接被删除结点的前后结点

//单链表删除结点
void Delete_Node(LNode* list, int data)
{
	if (list == NULL)
		return 1;
	LNode* pre = list;
	LNode* current = list->next;
	while (current)
	{
		if (current->data == data)
		{
			pre->next = current->next;
			free(current);
			break;//若要删除多个值相同的结点则注释break
		}
		pre = current;
		current = current->next;
	}
	if (current == NULL)
		return 1;
	list->data--;
}

4.遍历单链表

//遍历单链表
void PrintList(LNode* list)
{
	list = list->next;
	while (list)
	{
		printf("%d ", list->data);
		list = list->next;
	}
	printf("\n");
}

总体代码实现：

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

//单链表结构体定义：
typedef struct Node
{
	int data;
	struct Node* next;
}LNode;

//初始化单链表
LNode* InitList()
{
	LNode* list = (LNode*)malloc(sizeof(LNode));
	list->data = 0;
	list->next = NULL;
	return list;
}

//单链表插入——头插法(默认含头结点)
void HeadInsert(LNode* list, int data)
{
	LNode* node = (LNode*)malloc(sizeof(LNode));
	node->data = data;
	node->next = list->next;
	list->next = node;
	list->data++;//list是头结点，头结点的data域用来记录结点的个数
}

//单链表插入——尾插法(默认含头结点)
void TailInsert(LNode* list, int data)
{
	LNode* head = list;
	LNode* node = (LNode*)malloc(sizeof(LNode));
	node->data = data;
	node->next = NULL;
	while (head->next)
	{
		head = head->next;
	}
	head->next = node;
	list->data++;
}

//单链表删除结点
void Delete_Node(LNode* list, int data)
{
	if (list == NULL)
		return 1;
	LNode* pre = list;
	LNode* current = list->next;
	while (current)
	{
		if (current->data == data)
		{
			pre->next = current->next;
			free(current);
			break;//若要删除多个值相同的结点则注释break
		}
		pre = current;
		current = current->next;
	}
	if (current == NULL)
		return 1;
	list->data--;
}

//遍历单链表
void PrintList(LNode* list)
{
	list = list->next;
	while (list)
	{
		printf("%d ", list->data);
		list = list->next;
	}
	printf("\n");
}
int main()
{
	LNode* list = InitList();
	for(int i=1;i<=5;i++)
		HeadInsert(list, i);
	for (int j = 6; j <= 10; j++)
		TailInsert(list, j);

	PrintList(list);

	Delete_Node(list, 5);
	Delete_Node(list, 10);
	Delete_Node(list, 6);

	PrintList(list);
	return 0;
 }

changan277
关注
  • 6
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
纯C语言完整代码操作单链表(初始化、插入、删除、查找...)
qq_44697268的博客
08-26 1058
C语言操作单链表
建立一个单链表
12-17
建立一个单链表，在单链表上实现插入、删除和查找等操作，有菜单。 ⑴初始化字符型单链表H; ⑵采用尾插法建立单链表H，如（a,b,c,d,c）； ⑶输出单链表H的长度； ⑷输出单链表H的第i个元素，如输出单链表H的第3个元素； ⑸输出给定元素的位置，如输出元素a的位置； ⑹在第i个元素前插入给定元素，如在第4个元素前插入元素f； ⑺删除单链表H的第i个元素，如删除单链表H的第3个元素。 ⑻输出单链表
数据结构-链表（代码详解）
hcx009的博客
04-23 1027
数据结构与算法——线性表（链表篇）_线性链表-CSDN博客，但是这篇博客不能细看，也不能深究，因为错误和纰漏太多了，包括但不限于变量名的错误，函数传参的误导性，以及部分知识点错的离谱，本文也只是跟着这篇博客整理的知识点的结构来自己写的代码，毕竟：Talk is cheap, show me the code.//1.//2.//这里的typedef是取别名的意思//把 struct LNode取个简单的名字为 LNode。
链表（c语言实现）
热门推荐
zjq_love的博客
03-30 2万+
1.链表的分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： （1）单向或者双向 （2）带头或者不带头 （3）循环或者非循环 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。 2.无头单向非循环链表的实现 // ...
创建链表代码
rookiepythoner的博客
10-07 147
创建链表 #include<iostream> using namespace std; struct ListNode{ int val; ListNode *next; ListNode():val(0),next(nullptr){}; ListNode(int val):val(val),next(nullptr){}; ListNode(int val,ListNode *ptr):val(val),next(ptr){}; }; int ma
链表的创建代码实现
2301_81296146的博客
03-27 88
【代码】链表的创建代码实现。
新建一个链表的代码
weixin_44772147的博客
04-21 374
#include <stdio.h> #include <stdlib.h> struct node { int data; node* next; }; //创建链表 node* create(int Array[]) { node *p, *pre, *head; //pre保存当前结点的前驱节点，head为头结点 head = new node; ...
数据结构-C语言实现单链表-数据结构学习
最新发布
05-26
用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插法，任意位置插入法) 删除顺序表中的元素(头删法，尾删法，任意位置删除法) 修改指定位置的...
双向链表API及C语言实现
03-29
双向链表的API和C语言...另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
(数据结构C语言版)顺序表和单链表的逆置.docx
07-07
以下是顺序表和单链表的逆置操作的C语言程序代码： 顺序表逆置操作： ```c #include #include #define MAX_LIST_SIZE 100 typedef struct { int *elem; int length; } list_node; list_node L; void init()...
数据结构-单链表删除绝对值相同的元素-c语言代码
11-07
在本文中，我们将深入探讨如何使用C语言实现一个数据结构操作——删除单链表中绝对值相同的元素。首先，我们要了解单链表的基本概念。单链表是一种线性数据结构，其中每个节点包含一个数据域和一个指向下一个节点的...
数据结构单链表实验（C语言）
01-08
单链表的接本操作，有在单链表中插入，删除数据的功能，以及两个单链表的合并，多项式的表达。1．单链表的数据结构的建立实现。 2．单链表元素结点插入操作实现。 3．单链表元素结点删除操作实现。 4．实现单链表的合并。 5．实现一元多项式的相加。
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列，动态顺序队列，链式队列；静态顺序栈，动态顺序栈，链式栈；二叉树，线索二叉树；排序算
链表的创建，增添，删除，及代码详解
weixin_44313771的博客
07-31 433
kmp的学习告一段落了，现在回顾一下前段段时间学习的链表，链表一开始接触的时候我也是很难理解他，特别是链表与指针和结构题掺和在一起，对于初学者来说可能一时间有点难以接受，其实真真学起来之后，你就会发现其实链表的操作也并不是太难。好了下面来讲一些链表的基础知识，看了之后相信你对链表一定会有一个新的认识。 最好理解的就是拿代码来解释，一些基础知识都是在代码中介绍到的。 代码如下： #include&...
单链表的创建
会编程的大厨的博客
08-12 453
链表
单链表的创建、添加、删除
写写代码
06-08 414
创建 头插法： ①什么是头插法？ #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node * next; }Node; //create函数如下: Node * create(int n) { int i; Node * head= (N...
【数据结构】C语言实现顺序表（超级详细）
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
单链表|附完整源码—c语言版
fight_for1的博客
04-20 442
我们都知道数组在内存中是连续存储的，顺序表就是由链表存储的，它有一个其他数据结构都没有的优点——支持随机访问（就是利用下标访问元素），这可以让其支持一些排序算法的操作。但是顺序表也有一些如下缺点：1. 中间/头部的插入删除，时间复杂度为O(N)2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
C语言 链表-链表全家桶（附完整代码）香饽饽！！嘎嘎香！！！
Discod_lim的博客
03-18 2275
文章介绍了链表的一些基本操作，所有代码均在子函数中编写，文章最下方附带完整代码，Copy即可食用。
c语言链表是怎么存储数据结构,数据结构（C语言）用单链表存储一元多项式，并实现... 数据结构一元多项式计算(急求)...
06-12
C语言链表是由节点构成，每个节点包含两个部分：数据域和指针域。数据域用来存储具体的数据，指针域则指向下一个节点的位置，最后一个节点的指针域指向NULL。链表的头指针指向第一个节点。 用单链表存储一元多项式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值