单链表的实现

最新推荐文章于 2023-12-03 01:29:39 发布
最新推荐文章于 2023-12-03 01:29:39 发布
阅读量76 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leesunl/article/details/113098447
版权

一、Sysutil.h//系统头文件

#ifndef _SYSUTIL_H_
#define _SYSUTIL_H_

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<stdbool.h>
#include<windows.h>
#pragma warning (disable:4996)

#include<vld.h>  //内存泄漏工具的头文件

#endif

二、List.h//函数功能实现头文件

#include"Sysutil.h"

#define ElemType int
//无头单链表
typedef struct SListNode{
	ElemType data;//数据域
	struct SListNode *next;//指针域
}SListNode;

typedef struct SList{
	SListNode * head;
}SList;

void SListInit(SList *plist);
void SListInit(SList *plist);
void SListPushBack(SList *plist, ElemType x);
void SListPushFront(SList *plist, ElemType x);
void SListPopBack(SList *plist);
void SListPopFront(SList *plist);
void SListShow(SList *plist);

int SListLength(SList *plist);
SListNode *SeqListFind(SList *plist, ElemType x);
void SListClear(SList *plist);
void SListDestroy(SList *plist);

void SListDeleteByVal(SList *plist, ElemType x);
void SListInsertByVal(SList *plist, ElemType x);
void SListReverse(SList *plist);
void SListSort(SList *plist);
void SListRemoveAll(SList *plist,ElemType x);
SListNode* FindKthToTail(SList *plist, ElemType key);
SListNode* deleteDuplication(SList *plist);
SListNode* middleNode(SList *plist);

SListNode* _BuyNnode(){
	SListNode *s = malloc(sizeof(SListNode));
	assert(s != NULL);
	s->data = 0;
	s->next = NULL;
	return s;
}

void SListInit(SList *plist)
{
	plist->head = NULL;
}
void SListPushBack(SList *plist, ElemType x){
	assert(plist);
	SListNode* s = _BuyNnode();
	s->data = x;

	SListNode *p = plist->head;//查找到链表的尾部；

	if (p ==NULL){
		plist->head = s;
	}
	else{
		while (p ->next!= NULL){
			p = p->next;
		}
		p->next = s;
	}
}
void SListPushFront(SList *plist, ElemType x){
	assert(plist);

	SListNode *s = _BuyNnode();
	s->data = x;
	s->next = plist->head;

	plist->head = s;
}
void SListPopBack(SList *plist){
	assert(plist);

	SListNode *p = plist->head;
	

	if (p != NULL){
		if (p->next == NULL){
			plist->head= NULL;
		}
		else{
			SListNode *pre = NULL;
			while (p ->next!= NULL){
				pre = p;
				p = p->next;
			}
			pre->next = NULL;
		}
		free(p);
	}
}
void SListPopFront(SList *plist){
	assert(plist);
	SListNode *p = plist->head;
	if (p != NULL){
		plist->head = p->next;
		free(p);
	}
}
void SListShow(SList *plist){
	assert(plist);
	SListNode * p = plist->head;
	while (p != NULL){
		printf("%d->", p->data);
		p = p->next;
	}
	printf("Over.\n");
}
int SListLength(SList *plist){
	assert(plist);
	SListNode *p = plist->head;
	int Len=0;

	while (p != NULL){
		Len++;
		p = p->next;
	}
	return Len;
}
SListNode *SeqListFind(SList *plist, ElemType x){
	assert(plist);
	SListNode * p = plist->head;

	//找到返回节点地址，找不到返回NULL

	while (p != NULL&&p->data != x){
		p = p->next;
	}
	return p;
}
void SListClear(SList *plist){
	assert(plist);
	SListNode * p = plist->head;

	while (p != NULL){
		plist->head = p->next;
		free(p);
		p = plist->head;
	}
}
void SListDestroy(SList *plist)
{
	SListClear(plist);
}
void SListDeleteByVal(SList *plist, ElemType x){
	assert(plist);
	SListNode *p = plist->head;
	SListNode *pre = NULL;

	while (p != NULL&&p->data != x){
		pre = p;
		p = p->next;
	}

	if (p != NULL){
		if (pre == NULL){
			plist->head = p->next;//如果删除的是头节点的值的话，pre就是NULL
		}
		else{
			pre->next = p->next;
		}
		free(p);
	}
}
void SListInsertByVal(SList *plist, ElemType x){
	assert(plist);
	SListNode *s =_BuyNnode();
	s->data = x;

	if (plist->head == NULL){
		plist->head = s;
	}
	else{
		SListNode *p = plist->head;
		SListNode *pre = NULL;

		while (p!=NULL&&x > p->data){
			pre = p;
			p = p->next;
		}
		
		if (pre == NULL)//在链表的头部插入
		{
			s->next = p;
			plist->head = s;
		}
		else{
			s->next = pre->next;
			pre->next = s;
		}
	}
}
void SListReverse(SList *plist){
	assert(plist);
	SListNode *p, *q;

	if (plist->head == NULL)//没有节点，不需要转置
	{
		return;
	}
	else if (plist->head->next == NULL)//只有一个节点，不需要转置
	{
		return;
	}

	//1.切割链表
	p = plist->head->next;
	plist->head->next = NULL;

	//2.将剩余链表的节点进行一一头插
	q = p;
	while (q != NULL){
		q = q->next;
		p->next = plist->head;
		plist->head = p;
		p = q;
	}

}
void SListSort(SList *plist){
	assert(plist);

	SListNode *p, *q;
	if (plist->head == NULL || plist->head->next == NULL)//一个节点都没有或者只有一个节点，不需要排序
		return;

	//断开链表
	p = plist->head->next;
	plist->head->next = NULL;
	
	//循环按值插入
	q = p;
	while (q != NULL){
		q = q->next;
		SListNode *t = plist->head;
		SListNode *pre = NULL;

		while (t != NULL&&p->data > t->data)//寻找插入位置
		{
			pre = t;
			t = t->next;
		}
		if (pre == NULL) //在头部插入
		{
			p->next = plist->head;
			plist->head = p;
		}
		else//这里是找到了插入位置，进行插入
		{
			p->next = pre->next;//让p的next指向空
			pre->next = p;//让pre指向p
		}
		p = q;//再开始寻找
	}
	
}
void SListRemoveAll(SList *plist, ElemType key){
	assert(plist);

	SListNode *p, *pre = NULL;

	if (plist->head == NULL)
		return;

	p = plist->head;

	while (p != NULL)
	{
		if (p->data == key)
		{
			if (pre == NULL)
				plist->head = p->next;
			else
				pre->next = p->next;

			free(p);
		}
		else
			pre = p;

		if (pre == NULL)
			p = plist->head;
		else
			p = pre->next;
	}
}
SListNode* FindKthToTail(SList *plist, ElemType key)
{
	if (plist == NULL)
		return NULL;
	SListNode *fast, *slow;
	fast = slow = plist->head;
	while (key-- > 0)
	{
		if (fast == NULL)//用于判断是否超出节点的个数
			return NULL;
		fast = fast->next;
	}

	while (fast != NULL)
	{
		fast = fast->next;
		slow = slow->next;
	}
	return slow;
}
SListNode* deleteDuplication(SList *plist)
{
	if (plist ->head->next== NULL || plist->head == NULL)
		return plist->head;
	SListNode *pre = NULL;
	SListNode *cur = plist->head;
	SListNode *next_node = plist->head->next;

	while (next_node != NULL)
	{
		if (cur->data != next_node->data) // 重复值出现
		{
			pre = cur;
			cur = next_node;
			next_node = next_node->next;
		}
		else
		{
			while (next_node && next_node->data == cur->data)
				next_node = next_node->next;

			if (pre == NULL)
				plist->head = next_node;
			else
				pre->next = next_node;

			//删除重复节点
			while (cur != next_node)
			{
				SListNode *p = cur;
				cur = cur->next;
				free(p);
			}
			if (next_node != NULL)
				next_node = next_node->next;
		}
	}
	return plist->head;
}
SListNode* middleNode(SList *plist)
{
	SListNode *fast, *slow;
	fast = slow = plist->head;
	while (fast && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	}
	return slow;
}

三、TestMain.c源文件

#include"List.h"


int main(){
	SList mylist;
	SListInit(&mylist);

	ElemType item, key;
	int pos;

	SListNode *p;

	int select = 1;
	while (select)
	{
		printf("********************************************\n");
		printf("* [1] push_back        [2] push_front      *\n");
		printf("* [3] show_list        [0] quit_system     *\n");
		printf("* [4] pop_back         [5] pop_front       *\n");
		printf("* [6] length           [7] middleNode      *\n");
		printf("* [8] insert_val       [*9] insert_pos     *\n");
		printf("* [10] delete_val      [11] deleteDuplicat *\n");
		printf("* [12] find            [13] sort           *\n");
		printf("* [14] reverse         [15] remove_all     *\n");
		printf("* [16] clear           [*17] destroy       *\n");
		printf("* [18] FindKthTo_Tail                         *\n");
		printf("********************************************\n");
		printf("请选择:>");
		scanf("%d", &select);
		switch (select)
		{
		case 1:
			printf("请输入要插入的数据(以-1结束):>");
			while (scanf("%d", &item), item != -1)  //逗号表达式
				SListPushBack(&mylist, item);
			break;
		case 2:
			printf("请输入要插入的数据(以-1结束):>");
			while (scanf("%d", &item), item != -1)  //逗号表达式
				SListPushFront(&mylist, item);
			break;
		case 3:
			SListShow(&mylist);
			break;
		case 4:
			SListPopBack(&mylist);
			break;
		case 5:
			SListPopFront(&mylist);
			break;
		case 6:
			printf("表长为:>%d\n", SListLength(&mylist));
			break;
		case 7:
			p = middleNode(&mylist);
			printf("中间节点是%d\n", p->data);
			break;
		case 8:
			printf("请输入要插入的值:>");
			scanf("%d", &item);
			SListInsertByVal(&mylist, item);
			break;
		case 9:
			printf("请输入要插入的位置:>");
			scanf("%d", &pos);
			printf("请输入要插入的值:>");
			scanf("%d", &item);
			//SeqListInsertByPos(&mylist, pos, item);
			break;
		case 10:
			printf("请输入要删除的值:>");
			scanf("%d", &key);
			SListDeleteByVal(&mylist, key);
			break;
		case 11:
			deleteDuplication(&mylist);
			break;
		case 12:
			printf("请输入要查找的值:>");
			scanf("%d", &key);
			p = SeqListFind(&mylist, key);
			if (p == NULL)
				printf("要查找的值%d不存在.\n", key);
			else
				printf("要查找的值%d存在.\n", key);
			break;
		case 13:
			SListSort(&mylist);
			break;
		case 14:
			SListReverse(&mylist);
			break;
		case 15:
			printf("请输入要删除的值:>");
			scanf("%d", &key);
			SListRemoveAll(&mylist, key);
			break;
		case 16:
			SListClear(&mylist);
			break;
		case 18:
			printf("请输入要查找的值:>");
			scanf("%d", &key);
			p=FindKthToTail(&mylist, key);
			if (p == NULL)
				printf("%d不存在.\n", key);
			else
				printf("倒数第%d值%d存在.\n", key,p->data);
			break;
		}
		system("pause");
		system("cls");
	}

	SListDestroy(&mylist);

	system("pause");
	return 0;
}
sum_er
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现List实现(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-01 2302
实现Linked List实现statkList结构体实现以下8个接口完整的list.h头文件源码完整的list.c源文件源码实现List实现的完整源码（main函数测试） List结构体 struct L { void *val; L next; }; 实现以下8个接口 extern L List_init(void); extern L List_push(L list, void *val); extern int List_length(L list); extern void
线性表（List）的C实现
weixin_54534636的博客
06-14 653
线性表
c语言实现任何数据类型的list(双向循环链表)
Xin_Yue_Gu的博客
04-29 4968
模仿C++ STL的中的list函数命名 大部分名字都相同，快速上手
c语言模拟实现list链表的各种功能
S5242的博客
01-20 192
c语言模拟实现list链表的增删改查等功能模拟实现
list链表实现C语言,C++ list，STL list（双向链表）详解
weixin_33487490的博客
05-21 521
list 是顺序容器的一种。list 是一个双向链表。使用 list 需要包含头文件 list。双向链表的每个元素中都有一个指针指向后一个元素，也有一个指针指向前一个元素，如图1所示。在 list 容器中，在已经定位到要增删元素的位置的情况下，增删元素能在常数时间内完成。如图2所示，在 ai 和 ai+1 之间插入一个元素，只需要修改 ai 和 ai+1 中的指针即可。图1 ：双向链表图2：在双向...
单链表实现约瑟夫环
09-29
单链表解决约瑟夫环问题
利用带头结点的单链表实现两个集合的并、交、差运算.docx
04-19
利用带头结点的单链表实现两个集合的并、交、差运算 本文档的主要内容是使用带头结点的单链表实现两个集合的并、交、差运算。该文档共分为八个部分，分别是题目重述、题目功能描述、概要设计图、程序源代码及注释、...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
单链表实现的多项式运算.cpp
03-25
利用单链表的数据结构，在读取数据时就按指数次方排序好，再加法的运算中可以直接按指数的大小进行运算，相比随机的读入数据，这个方法优化了程序。乘法则是在加法的基础上把每一项的系数进行相乘并最后求和。注意...
c语言单链表实现通讯录，支持保存数据到文件加载数据到文件
04-05
以上是C语言单链表实现通讯录的主要知识点，这些概念和操作对于理解和实现任何动态数据结构都是至关重要的。通过这个项目，我们可以学习到如何有效地管理内存，以及如何在程序中持久化数据。同时，它也提供了一个...
C语言实现的链表list
06-09
用c语言写的链表 可以实现 创建链表 删除 清空 增删改查 追加元素 还可以扩展数据类型
C语言实现LinkedList
03-21
C语言实现LinkedList
单链表实现的通讯录 （文件）
fwq_qwert的博客
12-08 544
通讯录说明文档（一） 语言：c语言 格式： 编号       姓 名        住址          电话       201701       ***         xxxx        183****5668 要求：使用结构体形式对数据存储 功能：使用链表实现增加（在增加人员的过程中有一个自动排序功能，比如按姓名排序）、删除、修改、查找（比如：工号查
单链表实现文件版本通讯录
Hlun的博客
07-21 712
单链表的增删查找和排序还有如何写入文件，如何把文件的信息加载到链表中...
数据结构单链表的实现
wj903829182的专栏
04-10 1500
数据结构，链表
C语言：链表（List）与顺序表(SeqList)
最新发布
MaoRuofeng的博客
12-03 1536
在单链表中，如果要删除指定位置的节点，需要知道指定位置之前的节点，以便修改前一个节点的next指针来跳过当前节点，从而实现删除操作。由于单链表的节点只能通过next指针找到下一个节点，无法直接找到前一个节点，因此删除指定位置的节点比较麻烦，需要遍历链表找到指定位置之前的节点。这是因为在单链表中，如果要在指定位置之前插入节点，需要知道指定位置之前的节点，而单链表的节点只能通过next指针找到下一个节点，无法直接找到前一个节点。1、静态顺序表是在程序运行前就确定了大小的数组，数组的大小是固定的，不能动态改变。
C语言SList链表的多功能的实现
anyway33的博客
05-03 890
//SList.h #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> // slist.h typedef int SLTDateType; typedef struct SListNode { SLTDateType data; struct SListNode* next; }SListNode; // 动态申请一个节点 SListNode* BuySListNode.
链表实现文件C语言
让阳光照进心里
12-25 1731
<br />/* linked_list.c -- 链表实现文件 */ #include <stdio.h> #include <stdlib.h> #include "linked_list.h" /* 局部函数声明 */ static Linked_List_Node * Make_Node (const Linked_List_Item li1, const Linked_List_Item li2) ; /* 接口函数定义 */ int Initialize_L (Li
单链表实现与操作详解
在实现单链表时，通常会引入一个头结点，即使得链表的头部有一个特殊的节点，它的主要作用是在链表头部进行插入和删除操作时提供便利。头结点的数据域通常不存储实际数据，而其指针域指向链表的第一个数据节点。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值