数据结构||单链表功能的实现

最新推荐文章于 2022-10-02 12:38:09 发布
最新推荐文章于 2022-10-02 12:38:09 发布
阅读量202 收藏
点赞数
分类专栏： 数据结构的学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HuiDiExAg/article/details/102507158
版权

单链表的一些基本功能实现
1.写头文件的文档

#ifndef _COMMON_

 #define _COMMON_      
      
                
                
 #include<stdio.h>
      
      
        
        #include<stdlib.h>
      
      
        
        #include<stdbool.h>
      
      
        
        #include<assert.h>
      
      
        
        #define DataType int
      
      
        
        

      
      
        
        typedef struct SListNode
      
      
        
        {
      
      
        
        	DataType data;//单链表的数据域
      
      
        
        	struct SListNode* next;//单链表的指针域
      
      
        
        }SListNode;
      
      
        
        

      
      
        
        typedef struct SList
      
      
        
        {
      
      
        
        	SListNode *First;
      
      
        
        	SListNode *Last;
      
      
        
        	size_t size;
      
      
        
        }SList;//链表中的头和尾指针 都要用结构体定义类型.
      
      
        
        SListNode* _Buynode(DataType x);
      
      
        
        void InitList(SList* plist);
      
      
        
        bool SListpushback(SList* plist,DataType x);
      
      
        
        void SListshowlist(SList* plist);
      
      
        
        bool SListpushfront(SList* plist,DataType x);
      
      
        
        bool SListPopBack(SList* plist, DataType x);
      
      
        
        SListNode* SListFindByVal(SList* plist, DataType x);
      
      
        
        bool SListDeleByVal(SList* plist, DataType x);
      
      
        
        bool SListPopFront(SList* plist, DataType x);
      
      
        
        SListNode* ReservrList(SList* plist);
      
      
        
        int SListLength(SList* plist);
      
      
        
        void SListClear(SList* plist);
      
      
        
        void DestorySList(SList* plist);
      
      
        
        void InsertByVal(SList* plist,DataType x);
      
      
        
        #endif

2.主函数的测试

#include"common.h"
      
      
        
        int main()
      
      
        
        {
      
      
        
        	SList mylist;
      
      
        
        	InitList(&mylist);
      
      
        
        	DataType select = 1;
      
      
        
        	DataType input = 0;
      
      
        
        	DataType ret = 0;
      
      
        
        	while (select)
      
      
        
        	{
      
      
        
        		printf("*****************************************\n");
      
      
        
        		printf("*****1.push_back  2.push_front***********\n");
      
      
        
        		printf("*****3.show_list  0.   exit   ***********\n");
      
      
        
        		printf("*****5.pop_back   6.pop_front ***********\n");
      
      
        
        		printf("*****7.FindByVal  8. reserve    *********\n");
      
      
        
        		printf("*****9.DeleByVal  10.Length**************\n");
      
      
        
        		printf("*****11.Clear     12.InsertByVal*********\n");
      
      
        
        		printf("*****13.Destory            **************\n");
      
      
        
        		printf("*****************************************\n");
      
      
        
        		printf("请选择>");
      
      
        
        		scanf_s("%d", &select);


      
        		if (select == 0)

      
      
        
        		{
      
      
        
        			break;
      
      
        
        		}
      
      
        
        		switch (select)
      
      
        
        		{
      
      
        
        		case 1:
      
      
        
        			printf("请输入你要插入的数据>");
      
      
        
        			while (scanf_s("%d",&input),input!=-1)
      
      
        
        			{
      
      
        
        				SListpushback(&mylist,input);
      
      
        
        			}
      
      
        
        			break;
      
      
        
        		case 2:
      
      
        
        			printf("请输入你要插入的数据>");
      
      
        
        			while (scanf_s("%d", &input), input != -1)
      
      
        
        			{
      
      
        
        				SListpushfront(&mylist, input);
      
      
        
        			}
      
      
        
        			break;
      
      
        
        		case 3:
      
      
        
        			SListshowlist(&mylist);
      
      
        
        			break;
      
      
        
        		case 5:
      
      
        
        			printf("请输入你要删除的数据>");


        			SListPopBack(&mylist, input);
      
      
        
        			break;
      
      
        
        		case 6:
      
      
        
        			printf("请输入你要删除的数据>");
      
      
        
        			SListPopFront(&mylist, input);
      
      
        
        			break;
      
      
        
        		case 7:
        		printf("请输入你要查找的数字>");
      
      
        
        			SListFindByVal(&mylist, input);
      
      
        
        			break;
      
      
        
        		case 8:
      
      
        
        			ReservrList(&mylist);
      
      
        
        			break;
      
      
        
        		case 9:
      
      
        
        			printf("请输入你要删除数据>");
      
      
        
        			SListDeleByVal(&mylist,input);
      
      
        
        			break;
      
      
        
        		case 10:
      
      
        
        		    ret = SListLength(&mylist);
      
      
        
        			printf("%d\n", ret);
      
      
        
        			break;
      
      
        
        		case 11:
      
      
        
        			SListClear(&mylist);
      
      
        
        			break;
      
      
        
        		case 12:
      
      
        
        			printf("请输入你要插入的数据>");
      
      
        
        			scanf_s("%d", &input);
      
      
        
        			InsertByVal(&mylist, input);
      
      
        
        			break;
      
      
        
        		case 13:
      
      
        
        			DestorySList(&mylist);
      
      
        
        			break;
      
      
        
        		default :
      
      
        
        			printf("输入不合法>");
      
      
        
        			break;
      
      
        
        		}
      
      
        
        	}
      
      
        
        	return 0;
      
      
        
        }

3.函数的实现

#include"common.h"
      
      
        
        SListNode* _Buynode(DataType x)
      
      
        
        {
      
      
        
        	SListNode* S = (SListNode*)malloc(sizeof(SListNode));
      
      
        
        	assert(S != NULL);
      
      
        
        	if (S == NULL)
      
      
        
        		return NULL;
      
      
        
        	S->next = NULL;
      
      
        
        	S->data = x;
      
      
        
        	return S;
      
      
        
        }
      
      
        
        void InitList(SList* plist)
      
      
        
        {
      
      
        
        	SListNode *S = _Buynode(0);
      
      
        
        	plist->First = plist->Last = S;
      
      
        
        	plist->size = 0;
      
      
        
        }
      
      
        
        bool SListpushback(SList* plist,DataType x)
      
      
        
        {
      
      
        
        	SListNode* S = _Buynode(x);
      
      
        
        	if (S == NULL)
      
      
        
        		return false;
      
      
        
        	plist->Last->next = S;
      
      
        
        	plist->Last = S;
      
      
        
        	plist->size++;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        bool SListpushfront(SList* plist,DataType x)
      
      
        
        {
      
      
        
        	assert(plist != NULL);
      
      
        
        	
      
      
        
        	SListNode* p = _Buynode(x);
      
      
        
        	if (p == NULL)
      
      
        
        		return false;
      
      
        
        	p->next = plist->First->next;
      
      
        
        	plist->First->next = p;
      
      
        
        	if (plist->size == 0)
      
      
        
        		plist->Last = p;
      
      
        
        	plist->size++;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        void SListshowlist(SList* plist)
        {
      
      
        
        	SListNode* p = plist->First->next;
      
      
        
        	while (p != NULL)
      
      
        
        	{
      
      
        
        		printf("%d-->", p->data);
      
      
        
        		p = p->next;
      
      
        
        	}
      
      
        
        	printf("over.\n");
      
      
        
        }
      
      
        
        bool SListPopBack(SList* plist, DataType x)
      
      
        
        {
      
      
        
        	SListNode* p = plist->First;
      
      
        
        	assert(plist != NULL);
      
      
        
        	if (plist->size == 0)
      
      
        
        	{
      
      
        
        		return false;
      
      
        
        	}
      
      
        
        	while (p->next!=plist->Last)
      
      
        
        	{
      
      
        
        		p = p->next;
      
      
        
        	}
      
      
        
        	p->next = NULL;
      
      
        
        	free(plist->Last);
      
      
        
        	plist->Last = p;
      
      
        
        	plist->size--;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        bool SListPopFront(SList* plist, DataType x)
      
      
        
        {
      
      
        
        	SListNode* p = plist->First->next;
      
      
        
        	if (plist->size == 0)
      
      
        
        		return false;
      
      
        
        	plist->First->next = p->next;
      
      
        
        	free(p);
      
      
        
        	plist->size--;
      
      
        
        	if (plist->size == 0)
      
      
        
        		plist->Last = plist->First;
      
      
        
        		return true;
      
      
        
        }
      
      
        
        SListNode* SListFindByVal(SList* plist, DataType x)
        {
        SListNode* p = plist->First->next;
      
      
        
        	/*while (p != NULL && p->data != x)
      
      
        
        		p = p->next;
      
      
        
        	return p;*/
      
      
        
        	while (p != NULL)
      
      
        
        	{
      
      
        
        		if (p->data == x)
      
      
        
        		{
      
      
        
        			return p;
      
      
        
        		}
      
      
        
        		p = p->next;
      
      
        
        	}
      
      
        
        	return NULL;
      
      
        
        }
      
      
        
        SListNode* ReservrList(SList* plist)
      
      
        
        {
      
      
        
        	SListNode* q;
      
      
        
        	SListNode* p;
      
      
        
        	if (plist->First->next&&plist->First->next->next)
      
      
        
        	{
      
      
        
        		p = plist->First->next;
      
      
        
        		q = p->next;
      
      
        
        		p->next = NULL;
      
      
        
        		while (q)
      
      
        
        		{
      
      
        
        			p = q;
      
      
        
        			q = q->next;
      
      
        
        			p->next = plist->First->next;
      
      
        
        			plist->First->next = p;
      
      
        
        		}
      
      
        
        		return plist->First;
      
      
        
        	}
      
      
        
        	return plist->First;
      
      
        
        }
      
      
        
        int SListLength(SList* plist)
      
      
        
        {
        	return plist->size;
      
      
        
        }
      
      
        
        void SListClear(SList* plist)
      
      
        
        {
      
      
        
        	SListNode* p = plist->First->next;
      
      
        
        	while (p != NULL)
      
      
        
        	{
      
      
        
        		plist->First->next = p->next;
      
      
        
        		free(p);
      
      
        
        		p = plist->First->next;
      
      
        
        	}
      
      
        
        	plist->First = plist->Last = NULL;
      
      
        
        	plist->size = 0;
      
      
        
        

      
      
        
        }
      
      
        
        void DestorySList(SList* plist)
      
      
        
        {
      
      
        
        	SListClear(plist);
      
      
        
        	free(plist->First);
      
      
        
        	plist->First = plist->Last = NULL;//防止在内存中成为野指针
      
      
        
        }
      
      
        
        void InsertByVal(SList* plist, DataType x)
      
      
        
        {
      
      
        
        	SListNode* p = plist->First;
      
      
        
        	while (p->next != NULL&&x > p->next->data)
      
      
        
        	{
      
      
        
        		p = p->next;
      
      
        
        	}
      
      
        
        	SListNode* s = _Buynode(x);
      
      
        
        	if (p->next == NULL)
      
      
        
        	{
      
      
        
        		p->next = s;
      
      
        
        		plist->Last = s;
      
      
        
        	}
      
      
        
        	else
      
      
        
        	{
      
      
        
        		s->next = p->next;
      
      
        
        		p->next = s;
      
      
        
        	}
      
      
        
        	plist->size++;
        	}
      
      
        
        bool SListDeleByVal(SList* plist, DataType x)
      
      
        
        {
      
      
        
        	SListNode* q;
      
      
        
        	SListNode* p = plist->First;
      
      
        
        

      
      
        
        	while (p != NULL && p->next->data != x)
      
      
        
        		p = p->next;
      
      
        
        	if (p == NULL)
      
      
        
        		return false;
      
      
        
        	q = p->next;
      
      
        
        	if (p->next == plist->Last)
      
      
        
        		plist->Last = p;
      
      
        
        	p->next = q->next;
      
      
        
        	free(q);
      
      
        
        	return true;
      
      
        
        }
半夏丶ExAg3r
关注
专栏目录
C指针实现单链表，主函数调用
Blog
02-02 1448
C指针实现单链表，主函数调用 使用数组或者指针简单实现的表都有其不同的优缺点，例如数组的比较方便查询，不方便修改，指针的比较方便修改但不方便查询，同时需要额外空间存放指针……之后会有一种 间接寻址方法实现表 结合了以上两种方式的优点。 #include <stdio.h> #include <stdlib.h> typedef int ListItem; // 表元素类型 typedef ListItem *addr; // 表元素指针类型 #define eq(A,
数据结构||Java实现单链表的增添，删除，插入，修改，查询
JockLiu的博客
08-16 3463
单链表概述 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 单链表的实现原理 在单链表中，我们定义一个节点Node 包括两个部分：元数据和下一个节点的地址。节点和节点之间 通过next(即下一个节...
单链表的基本功能实现
dianquanhe2322的博客
04-22 156
#include<stdio.h>#include<assert.h>#include<malloc.h> #define ElemType int typedef struct Node{ ElemType data; struct Node *next;}Note,*PNode; typedef struct List{ PNode fir...
单链表基本操作在主函数中的实现
weixin_46803686的博客
11-05 5849
#include <iostream> #define OK 1 #define ERROR 0 #define VOERFLOE -2 using namespace std; typedef int Status; typedef struct LNode { int date; struct LNode *next; } LNode,*LinkList; //构造一个空的顺序表L Status InitList(LinkList &L) { L=new
单链表函数功能实现
航航雷的博客
06-30 628
#pragma once #include<assert.h> #include<stdio.h> #include<malloc.h> typedef int SDataType; typedef struct SlistNode { SDataType data; struct SlistNode* pNext; }Node; typedef str...
＜数据结构＞单链表基本功能实现
weixin_46364330的博客
10-29 584
文章目录前言一、单链表实验二、使用步骤1.链表基本功能2.代码功能实现总结 前言 提示：本篇主要是本小白大学期间对数据结构实验的一些基本代码功能实现，希望对一同数据结构的伙伴有所帮助。 提示：以下是本篇文章正文内容，下面案例可供参考 一、单链表实验 【实验目的】 掌握单链表的存储结构形式及其描述 掌握单链表的建立、查找、插入和删除操作 【实验内容】 编写函数，实现随机产生或键盘输入一组元素，建立一个带头结点的单链表（无序）。 编写函数，实现遍历单链表。 编写函数，在非递减有序单链表中插入一个元素使链.
数据结构-C语言实现单链表-数据结构学习
最新发布
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
数据结构单链表的基本操作实现(包含源代码)上机报告
07-13
数据结构中的单链表是一种常见的线性数据结构，它的每个节点包含两部分：一部分是数据域，用于存储数据；另一部分是指针域，用于指向下一个节点。本实验报告旨在通过C++实现单链表的基本操作，包括初始化、销毁、...
单链表作业，包括链表的声明及主函数的实现
10-03
单链表的作业，包括了链表的声明和主函数的实现。编译测试都成功了，这是我的作业，传上来与大家分享。我体会大家的难处.....
C语言---12单链表---01基本功能实现
一位正在苦苦追求毕业的研究僧
10-02 871
关于单链表的创建、增删查改、销毁的基本功能实现
链表的概念和结构及基本功能函数的实现（单链表的实现）
weixin_47792933的博客
08-19 1543
????✏️引言????✏️链表的概念及结构????✏️单链表的实现及图示分析????????单链表之创建单链表????????单链表之计算单链表的长度????????单链表之打印单链表????????单链表之单链表的增删查改????????头插法插入元素????????尾插法插入元素????????把一个节点插入到链表的任意位置????????查找链表中是否含有某个元素????????删除链表中第一次出现value值的节点????????删除链表中出现value值得所有节点????????清空单链表 ??
单链表的方法函数实现-（严蔚敏版）
天与云与山与水
04-11 847
这学期我们学数据结构课程，这些代码是平时的练习代码。 这个是室友大神写的，写的真好看！ 我感觉重点是 1 链表的逆置，不用开辟新的空间，很好用。 2 用pair类型接受两个返回值，起到确保的作用。 主要有 逆置，删偶数，输出，输入，合并非递减链表。等等#include <bits/stdc++.h> using namespace std; typedef int ElemType; typ
单链表的各种功能实现(C语言)
lhh_qrsly的博客
10-18 275
链表的分类及存储方式 单链表 双链表 双向循环链表 创建一个单链表 //不是链表的结构体 //链表中一个节点的结构体 typedef struct SListNode { DataType data; // 值 struct SListNode *Next; // 指向下一个结点 } SListNode; 链表要实现的功能 // 初始化 ,构造一条空的链表 void SListInit(SListNode **ppFirst); //打印链表 void SListInit(SLis
单链表基本功能的实现（C语言）
Enthusiastic_boy的博客
11-27 1078
不带头节点的单链表的增、删、改、查，涉及到二级指针。
单链表的实现
Clytze_L的专栏
10-20 632
头文件的源代码：
c语言之单链表的创建与应用
m0_59998867的博客
08-26 545
1.定义结构体 #include //定义结构体 struct node{ int data; struct node* next; }; 2.创建链表 struct node* creatlist() { struct node* headnode = (struct node*)malloc(sizeof(struct node)); //headnode 成为了结构体变量 //变量使用前必须被初始化 //headnode->dat..
【C++】不使用结构体实现单链表
SuperSources的博客
06-04 469
题目 利用《数据结构》知识，定义一元素为整数的单链表类，并在主函数中调用各个功能： 数据成员：指向头结点的指针、链表中当前元素的个数； 成员函数：初始化、在尾部增加一元素、查询指定数据的元素、在指定元素前插入一新元素、删除指定元素、遍历链表中的元素、输出所有链表中的元素、将一个单链表逆序（选作）。 原理 类的成员可以是其他类的对象，称为类的组合。不能以类自身的对象作为本类的成员。但是可以是本身的指针或者引用。 #include<iostream> using namespace std; cla
珠海理工学院数据结构课程设计：单链表多项式相加实现
本报告是北京理工大学珠海学院计算机科学技术学院学生关于《数据结构》课程设计的一部分，主题为使用单链表实现一元多项式的求和。在数据结构中，链表是一种重要的非顺序存储方式，其中每个节点包含一个数据元素和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值