[c语言]单链表的实现

最新推荐文章于 2022-11-05 20:12:51 发布
最新推荐文章于 2022-11-05 20:12:51 发布
阅读量922 收藏 1
点赞数
分类专栏： c语言 数据结构 c语言练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XHfight/article/details/51550450
版权

一、基础知识：链表（线性表的链式存储结构）

（1）特点：逻辑关系相邻，物理位置不一定相邻。

（2）分类：

     a.不带头节点

    b.带头节点

           wKiom1cd_6ijVRHJAAAaP1x2gqE446.png

（3）单链表的存储结构：

typedef struct SListNode

{

 DataType data;

 struct SListNode* next;

}SListNode;

 

二、代码实现(因避开使用二级指针，所以代码中使用了c++中的引用)：此处构造的为不带头节点的链表

方法一：

(1)sList.h

 
#pragma once
typedef int DataType;
typedef struct SListNode
{
 DataType data;
 struct SListNode* next;
}SListNode;
void PushBack(SListNode* & pHead, DataType d);
void PopBack(SListNode* & pHead);
void PushFront(SListNode* & pHead, DataType d);
void PopFront(SListNode* & pHead);
void PrintList(SListNode* pHead);
SListNode* Find(SListNode* & pHead, DataType d);
void Insert(SListNode* & pos, DataType d);

(2)sList.cpp

#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include "sList.h"
SListNode* MakeNode(DataType d)
{
 SListNode* tmp = (SListNode*)malloc(sizeof(SListNode));
 tmp->data = d;
 tmp->next = NULL;
 return tmp;
}
void PushBack(SListNode* & pHead, DataType d)
{
 //1.空
 //2.不空
 if(pHead == NULL)
 {
  pHead = MakeNode(d);
 }
 else
 {
  //先找尾，再插入新节点
  SListNode* tail = pHead;
  while(tail->next != NULL)
  {
   tail = tail->next;
  }
  tail->next = MakeNode(d);
 }
}
void PopBack(SListNode* & pHead)
{
 //1.空
 //2.一个节点
 //3.多个节点
 if(pHead == NULL)
 {
  return;
 }
 else if (pHead->next == NULL)
 {
  free(pHead);
  pHead = NULL;
 }
 else
 {
  SListNode* tail = pHead;
  SListNode* prev = NULL;
  while(tail->next != NULL)
  {
   prev = tail;
   tail = tail->next;
  }
  prev->next = NULL;
  free(tail);
 }
}
void PushFront(SListNode* & pHead, DataType d)
{
 if(pHead == NULL)
 {
  pHead = MakeNode(d);
 }
 else
 {
  SListNode* tmp = pHead;
  pHead = MakeNode(d);
  pHead->next = tmp;
 }
}
void PopFront(SListNode* & pHead)
{
 if(!pHead)
 {
  printf("List is empty!");
  return;
 }
 else
 {
  SListNode* tmp = pHead;
  pHead = pHead->next;
  free(tmp);
 }
}
SListNode* Find(SListNode* & pHead, DataType d)
{
 SListNode* find = pHead;
 while(find)
 {
  if(find->data == d)
   return find;
  find = find->next;
 }
 return NULL;
}
void Insert(SListNode* & pos, DataType d)
{
 assert(pos);
 /*
 方法一：
 SListNode* tmp = MakeNode(d);
 tmp->next = pos->next;
 pos->next = tmp;
 */
 //方法二：
 SListNode* next = pos->next;
 pos->next = MakeNode(d);
 pos->next->next = next;
}
void Erase(SListNode*& pHead,SListNode* & pos)
{
 assert(pos&&pHead);
 SListNode* prev = pHead;
 while(prev->next != pos)
 {
  prev = prev->next;
 }
 prev->next = pos->next;
 free(pos);
 pos = NULL;
}
void PrintList(SListNode* pHead)
{
 SListNode* tmp = pHead;
 while(tmp)
 {
  printf("%d->", tmp->data);
  tmp = tmp->next;
 }
 printf("NULL\n");

（3）test.cpp

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

void test1()
{
 //不带头节点
 SListNode* list = NULL;
 PushBack(list, 1);
 PushBack(list, 2);
 PushBack(list, 3);
 PushBack(list, 4);
// PushFront(list,0);
// PopFront(list);
// PopBack(list);
 SListNode* ret = Find(list, 2);
 if(ret == NULL)
 {
  printf("No Exist!\n");
  return;
 }
// Insert(ret, 4);
 Erase(list,ret);
 PrintList(list);
}
int main()
{
 test1();
 system("pause");
 return 0;

 方法二：

这种方法定义了两个结构体，方便以后对链表的操作，你可以在LinkList这个结构体中加入尾指针或者长度等等信息，来使操作更加简单。

typedef struct ListNode    //单链表的一个结点
{
	DataType data;
	struct ListNode* next;
}ListNode,*pListNode;
 
typedef struct LinkList   //链表的信息                                                                                            {
	pListNode pHead;
}LinkList,*pLinkList;

 

源文件：

1.LinkList.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

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

typedef int DataType;
typedef struct ListNode
{
	DataType data;
	struct ListNode* next;
}ListNode,*pListNode;

typedef struct LinkList
{
	pListNode pHead;
}LinkList,*pLinkList;

void InitLinkList(pLinkList plist);
void DestoryLinkList(pLinkList plist);
void PushBack(pLinkList plist, DataType x);
void PopBack(pLinkList plist);
void PushFront(pLinkList plist, DataType x);
void PopFront(pLinkList plist);
void PrintLinkList(pLinkList plist);
pListNode Find(pLinkList plist, DataType x);
void Insert(pLinkList plist, pListNode pos, DataType x);
void Remove(pLinkList plist, DataType x);
void RemoveAll(pLinkList plist, DataType x);
void Erase(pLinkList plist, pListNode pos);
void BubbleSort(pLinkList plist);

#endif


 

2.LinkList.c

#include "LinkList.h"

void InitLinkList(pLinkList plist)
{
	assert(plist);
	plist->pHead = NULL;
}
void DestoryLinkList(pLinkList plist)
{
	pListNode cur = NULL;
	assert(plist);
	cur = plist->pHead;
	while(cur)
	{
		pListNode del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	plist->pHead = NULL;
}

pListNode BuyNode(DataType x) //创建一个结点
{
	pListNode newNode = (pListNode)malloc(sizeof(ListNode));
	if(NULL == newNode)
	{
		printf("out of memory!");
		exit(0);
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}
void PushBack(pLinkList plist, DataType x)
{
	pListNode cur = NULL;
	pListNode newNode = NULL;
	assert(plist);
	cur = plist->pHead;
	newNode = BuyNode(x);
	if(NULL == cur)   //空链表
	{
		plist->pHead = newNode;
	}
	else              //链表不为空
	{
		while(cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newNode;
	}
}
void PopBack(pLinkList plist)
{
	pListNode cur = NULL;
	assert(plist);
	cur = plist->pHead;
	if(NULL == cur)    //链表为空
	{
		printf("LinkList is Empty\n");
	}
	else if(NULL == cur->next) //链表只有一个结点
	{
		free(cur);
		cur = NULL;
		plist->pHead = NULL;
	}
	else    //链表有两个及以上结点
	{
		while(cur->next->next != NULL)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}
void PushFront(pLinkList plist, DataType x)
{
	pListNode newNode = NULL;
	assert(plist);
	newNode = BuyNode(x);
	newNode->next = plist->pHead;
	plist->pHead = newNode;
}
void PopFront(pLinkList plist)
{
	assert(plist);
	if(NULL == plist->pHead)
	{
		printf("LinkList is Empty\n");
		return;
	}
	else
	{
		pListNode del = plist->pHead;
		plist->pHead = del->next;
		free(del);
		del = NULL;
	}
}
void PrintLinkList(pLinkList plist)
{
	pListNode cur = NULL;
	assert(plist);
	cur = plist->pHead;
	while(cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
pListNode Find(pLinkList plist, DataType x)
{
	pListNode cur = NULL;
	assert(plist);
	cur = plist->pHead;
	while(cur)
	{
		if(cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void Insert(pLinkList plist, pListNode pos, DataType x) //在pos之前插入
{
	pListNode newNode = NULL;
	assert(plist);
	assert(pos);
	newNode = BuyNode(x);
	if(pos == plist->pHead)
	{
		PushFront(plist, x);
	}
	else
	{
		pListNode cur = plist->pHead;
		while(cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = newNode;
		newNode->next = pos;
	}
}
void Remove(pLinkList plist, DataType x)  //删除数据为x的结点
{
	pListNode pos = NULL;
	assert(plist);
	pos = Find(plist, x);
	if(pos == NULL)
	{
		printf("no find\n");
	}
	else if(pos == plist->pHead)
	{
		PopFront(plist);
	}
	else
	{
		pListNode cur = plist->pHead;
		while(cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
void RemoveAll(pLinkList plist, DataType x)
{
	pListNode cur = NULL;
	assert(plist);
	cur = plist->pHead;
	if(plist->pHead == NULL)//空链表
	{
		return;
	}
	else if(plist->pHead->next == NULL)  //只有一个结点
	{
		free(cur);
		cur = NULL;
		plist->pHead =NULL;
		return;
	}
	while(cur->data == x)  //头
	{
		pListNode del = cur;
		cur = cur->next;
		plist->pHead = cur;
		free(del);
		del = NULL;
	}
	while(cur && cur->next)                  //中间和尾
	{
		if(cur->next->data == x)
		{
			
			pListNode del = cur->next;
			cur->next = del->next;
			free(del);
			del = NULL;
		}
		cur = cur->next;
	}
}
void Erase(pLinkList plist, pListNode pos)
{

	assert(pos);
	assert(plist);
	if(pos == plist->pHead)
	{
		PopFront(plist);
	}
	else
	{
		pListNode cur = plist->pHead;
		while(cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
void BubbleSort(pLinkList plist)
{
	int flag = 0;
	pListNode cur = NULL;   //控制外循环排序的趟数
	pListNode log= NULL;   //记录内循环上一次交换的最后一个数
	pListNode cmp = NULL;  //记录内循环的当前比较值
	assert(plist);
	log = plist->pHead;
	cur = plist->pHead;

	while(log)
	{
		log = log->next;
	}
	while(cur->next != NULL)
	{
		pListNode node = NULL;
		cmp = plist->pHead;
		log = node;
		flag = 0;
		while(cmp->next!=log)
		{
			if(cmp->data > cmp->next->data)
			{
				DataType tmp = cmp->data;
				cmp->data = cmp->next->data;
				cmp->next->data = tmp;
				node = cmp;
				flag = 1;
			}
			cmp = cmp->next;
		}
		if(flag == 0)
		{
			return;
		}
		cur = cur->next;
	}
}


 

3.Test.c

#include "LinkList.h"

void Test1()
{
	LinkList list;
	InitLinkList(&list);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	PrintLinkList(&list);
	PopBack(&list);
	PrintLinkList(&list);
	PopBack(&list);
	PopBack(&list);
	PopBack(&list);
	PopBack(&list);
	PopBack(&list);

	PrintLinkList(&list);
	DestoryLinkList(&list);
}
void Test2()
{
	LinkList list;
	InitLinkList(&list);
	PushFront(&list, 1);
	PushFront(&list, 2);
	PushFront(&list, 3);
	PushFront(&list, 4);
	PushFront(&list, 5);
	PrintLinkList(&list);

	PopFront(&list);
	PrintLinkList(&list);
	PopFront(&list);
	PrintLinkList(&list);
	PopFront(&list);
	PrintLinkList(&list);
	PopFront(&list);
	PrintLinkList(&list);
	PopFront(&list);
	PrintLinkList(&list);
	PopFront(&list);
	PrintLinkList(&list);

	DestoryLinkList(&list);
}

void Test3()
{
	LinkList list;
	InitLinkList(&list);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	PrintLinkList(&list);
//	Insert(&list, Find(&list, 4), 3);
	Insert(&list, Find(&list, 1), 3);
	Insert(&list, Find(&list, 5), 3);

	PrintLinkList(&list);
	DestoryLinkList(&list);

}

void Test4()
{
	LinkList list;
	InitLinkList(&list);
	PushBack(&list, 4);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	PushBack(&list, 4);
	PrintLinkList(&list);
//	Remove(&list, 1);
//	Remove(&list, 5);
//	Remove(&list, 3);
	RemoveAll(&list, 4);
	PrintLinkList(&list);
	DestoryLinkList(&list);
}

void Test5()
{
	LinkList list;
	InitLinkList(&list);
	PushBack(&list, 4);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	PushBack(&list, 4);
	PrintLinkList(&list);
	Erase(&list,Find(&list,3));
	PrintLinkList(&list);
	BubbleSort(&list);
	PrintLinkList(&list);

	DestoryLinkList(&list);
}
int main()
{
//	Test1();
//	Test2();
//	Test3();
//	Test4();
	Test5();

	system("pause");
	return 0;
}


 

XHfight
关注
专栏目录
单链表的实现（C语言）
qq_45731531的博客
11-05 279
什么是单链表 由n个只含有一个指针域的结点（node）构成的线性表称为单链表 单链表的实现 .h文件 #include <stdio.h> #include <stdlib.h> #define _NODE_H_ typedef struct list{//定义一个结构体类型作为结点 int date; struct list *next; }Node;//typede...
C语言实现单链表
坏蛋小猴
12-31 872
定义：n个结点链结成一个链表，即为线性表（a1,a2,...,an）的链式存储结构，因为链表的每个结点中只包含一个指针域，所以叫做单链表。 头指针：链表中第一个结点的存储位置叫做头指针。 头结点：单链表的第一个结点前附设一个结点，称为头结点。‘   可用C语言中的结构指针来描述单链表的存储结构，如下：
c语言实现链表的（创建、插入、删除、查改.....)
sing_Hwang的博客
09-23 1747
#pragma once #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #include&lt;assert.h&gt; //struct node { // int date; // struct node *next; //}; typedef int DateType; typedef struct ListNode { DateTyp...
C语言单链表实现
最新发布
Sxy_wspsby的博客
11-05 431
前言 链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 一、链表的分类 1.单向或双向 2.带头或者不带头 3.循环或者非循环 最常用的两种链表结构： 1.无头单向非循环链表：结构简单，一般不会单独用来存数据，实际中更多的是作为其他数据结构的子结构，如哈希桶，图的邻接表等等，另外这种结构在笔试面试中出现很多 2.带头双向循环链表：结构最复杂，一般用来单独存储数据，实际中使用的链表数据结构，都是带头双向循环链表，另外这个
c语言单链表实现19个功能完全详解,c语言-单链表（二）
weixin_42509803的博客
05-22 295
继续复习链表知识点，本章包含单链表的增加，删除，判断是否为空，和链表长度，以及链表的排序 几个知识点1.链表的判断是否为空//1.判断链表是否为空bool isempty_list(PNODE pHead) {return pHead->pNext == NULL;}2. 计算链表的长度//2.链表长度int length_list(PNODE pHead) {PNODE pFirst = ...
C语言单链表实现多项式相加
08-29
C语言单链表实现多项式相加 多项式是数学中的一种重要概念，表示为一个变量的幂的和。多项式相加是指将两个或多个多项式进行加法运算，结果仍然是一个多项式。在计算机科学中，实现多项式相加需要使用数据结构和...
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
本文将详细解析如何使用C语言来实现单链表，并涵盖了19种不同的操作功能，帮助你深入理解这一核心概念。 单链表由一系列节点组成，每个节点包含两部分：数据域（用于存储数据）和指针域（指向下一个节点）。链表的...
C语言单链表实现方法详解
08-27
C语言单链表实现方法详解 单链表是一种基本的数据结构，在C语言中实现单链表可以提高程序的效率和灵活性。本文将详细介绍C语言单链表的实现方法，包括单链表的定义、创建、添加、删除、排序、打印等操作技巧，并...
C语言小项目--贪吃蛇游戏
热门推荐
XHfight的博客
06-15 1万+
一、贪吃蛇小游戏简介：         用上下左右控制蛇的方向，寻找吃的东西，每吃一口就能得到一定的积分，而且蛇的身子会越吃越长，身子越长玩的难度就越大，不能碰墙，也不能咬到自己的身体，等到了一定的分数，就能过关。   二、函数框架 三、数据结构 typedef struct Snake { size_t x; //行 size_t y; //列 struct Snake*
位运算（二）：8bit数据指定位置0或置1操作
XHfight的博客
05-30 1万+
一、要求：        功能： 实现对一个8bit数据（unsigned char类型）的指定位（例如第n位）的置0或者置1操作，并保持其他位不变。       函数原型：void RightLoopMove(unsigned char *p_data, unsigned char position, int flag)       函数参数说明：p_data是指定的原数据，positio
整型数组里只出现一次的数字--[c语言笔试题]
XHfight的博客
06-19 4606
找出数组内只出现一次的数字，是一系列的笔试题，来考察大家对位运算的掌握，下面我们从最简单的开始来看看吧！ 一、题目：一个整型数组里只有一个数字出现了一次，其余数字都出现了两次，请写程序找出出现了一次的数字。   如：{1，2，1，2，3}，找出1 看到这个题目时，我们容易想到异或运算的性质。异或运算相同为0，相异为1，则： a^a = 0; (1) 0^a = a; (2) a^b^a
静态顺序表实现简单的通讯录
XHfight的博客
06-02 4474
一、通讯录实现要求： 实现一个通讯录； 通讯录可以用来存储1000个人的信息，每个人的信息包括： 姓名、性别、年龄、电话、住址 提供方法： 1. 添加联系人信息 2. 删除指定联系人信息 3. 查找指定联系人信息 4. 修改指定联系人信息 5. 显示所有联系人信息 6. 清空所有联系人 7. 以名字排序所有联系人   二、基本思路：       根据题目的要求，我选
C/C++函数名称修饰规则及extern "C"的作用
XHfight的博客
06-26 4465
一、函数名称修饰规则 由于c语言不支持函数重载，而c++语言支持函数重载，所以c和c++的函数名称修饰规则是不相同的。   以下面这个Add函数为例，来探讨一下c和c++语言的函数名称修饰规则。 int Add(int x, int y) { return x+y; } c语言的函数名称修饰规则：  [window系统下vs2010]：(在映射文件.map中可以查看，需要右击当前
好玩的c语言程序！
XHfight的博客
06-01 3574
执行程序后1分钟之后关机，只有在一分钟内输入“我是猪”便可取消关机。#include #include #include int main() {  char input[10];  system("shutdown -s -t 60"); A: printf("please input \"我是猪\",otherwise your computer will shut down after on
链表面试题：判断链表是否相交（c语言）
XHfight的博客
06-13 3404
一、问题描述： 判断两个链表是否相交，若相交返回交点，否则返回空。 由上图我们可以得出链表相交的两个结论： 1.两链表相交，第一个相同的结点为链表的交点； 2.两链表相交，从交点向后的所有结点都相同（合二为一）。 二、解决思路 方法一：直观法 思路：依次判断第一个链表中的每个结点是否在第二个链表中出现。 时间复杂度：O(Length(List1)*Length(List2))
位运算（一）：二进制中1的个数
XHfight的博客
05-29 2596
一、题目：求二进制中1的个数        请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。        例如：10 二进制表示为：1010 ，该函数输出二 二、最初思路：        先检查二进制位最右边一位是否为1，将二进制位右移一位，这时最右边一位 变为原来的倒数第二位，再右移一位，依次循环运算，直到此数变为0。        怎样检查二进制位最右边一位是否为1呢
编写C语言程序求两个数的最大公约数
XHfight的博客
06-01 2579
//求两个数的最大公约数 #include  int main() {  int num1,num2;  int temp;  scanf("%d%d",&num1,&num2);  //核心算法  while(num1 % num2 != 0)  {   temp = num2;   num2 = num1%num2;   num1 = temp;  }  printf("最大公约数为：%d\n
C语言错误：missing ';' before 'type'
XHfight的博客
06-01 2320
C语言程序必须只能在开头定义变量，C++在哪都能定义变量。      所以把变量定义放在开头就好了！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值