（含有头指针以及尾指针）单链表各类功能的实现

最新推荐文章于 2024-08-10 20:22:56 发布
最新推荐文章于 2024-08-10 20:22:56 发布
阅读量7.7k 收藏 27
点赞数 6
分类专栏： 数据结构 文章标签： 单链表 头结点 尾结点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZongYinHu/article/details/45379057
版权

对单链表实现如下功能：

void InitList(List *list);             //初始化单链表
bool push_back(List *list,ElemType x); //尾插法
void show_seqlist(List *list);         //显示链表内容
bool push_front(List *list,ElemType x);//头插法
bool pop_back(List *list);             //尾删法
bool pop_front(List *list);            //头删法
Node *find(List *list,ElemType x);     //查找函数，找到返回指向该元素的指针
bool modify(List *list,ElemType x);    //修改某一元素的值
void delete_val(List *list,ElemType x);//按值删除
void clear(List *list);                //清空链表
void destroy(List *list);              //销毁链表
int  length(List *list);               //求链表长度
void resver(List *list);               //逆至链表
void prio(List *list,ElemType x);      //求某个值的前驱
void next(List *list,ElemType x);      //求某个值的后继


List.h: 

#ifndef __LIST_H__
#define __LIST_H__

#include<assert.h>
#include<iostream>
using namespace std;
typedef int ElemType;

typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node;

typedef struct List
{
	Node *first;
	Node *last;
	int size;
}List;

void InitList(List *list);             //初始化单链表
bool push_back(List *list,ElemType x); //尾插法
void show_seqlist(List *list);         //显示链表内容
bool push_front(List *list,ElemType x);//头插法
bool pop_back(List *list);             //尾删法
bool pop_front(List *list);            //头删法
Node *find(List *list,ElemType x);     //查找函数，找到返回指向该元素的指针
bool modify(List *list,ElemType x);    //修改某一元素的值
void delete_val(List *list,ElemType x);//按值删除
void clear(List *list);                //清空链表
void destroy(List *list);              //销毁链表
int  length(List *list);               //求链表长度
void resver(List *list);               //逆至链表
void prio(List *list,ElemType x);      //求某个值的前驱
void next(List *list,ElemType x);      //求某个值的后继
#endif

List.cpp: 

#include"List.h"
//初始化单链表
void InitList(List *list)
{
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	s->next = NULL;
	list->first = list->last = s;
	list->size = 0;
}
//尾插法：开辟并初始化--->>连接---->>指针后移
bool push_back(List *list,ElemType x)
{
	Node *s = (Node *)malloc(sizeof(Node));//开辟一个结点
	if(s == NULL)
	{
		return false;
	}
	s->next = NULL;//对节点的初始化
	s->data = x;
	
	list->last->next = s;//连接
	list->last = s;      //后移（尾指针后移）
	list->size++;
	return true;
}
//打印链表的内容
void show_seqlist(List *list)
{
	Node *p = list->first->next;
	while(p != NULL)
	{
		cout<<p->data<<"--->";
		p = p->next;
	}
	cout<<"NULL"<<endl;
}
//头插法：开辟并初始化--->>连接---->>指针后移  ！！注意特殊情况！！
bool push_front(List *list,ElemType x)
{
	Node *s = (Node *)malloc(sizeof(Node));
	if(s == NULL)
	{
		return false;
	}
	s->data = x;
	s->next = list->first->next;
	list->first->next = s;
//注意：如果是第一个结点，则尾指针需要改变指向即指向第一个结点
//（不再指向头）如果不是第一个结点，尾指针指向无需改变 
	if(list->size == 0)
	{
		list->last = s;
	}
	list->size++;
	return true;
}
//尾删法：找到最后一个节点的前驱（指向赋空）---->尾指针指向它--->size - 1
bool pop_back(List *list)
{
	if(list->size == 0)
	{
		cout<<"链表已空"<<endl;
		return false;
	}
	Node *pre = list->first;
	while(pre->next != list->last)//找到要删除节点（最后一个结点）的前驱
	{
		pre = pre->next;
	}
	pre->next = NULL;//因为该前驱要作为尾结点，所以其指针域得赋空
	free(list->last);//释放要删除的结点
	list->last = pre;//尾指针指向改变
	
/*	pre->next = NULL;
	list->last = pre;

	free(pre);
	pre = NULL;
//	free(list->last);*/
	
	list->size--;
	return true;
}
//free(p)作用是：释放p所指向的空间，而非释放指针p！！！！！
//动态开辟的空间才需要手工释放，其他的空间系统自动回收

//头删法：释放第一个节点->size-1(如果只有一个节点，释放它之后尾指针得指向头结点)，其他情况尾指针不变
bool pop_front(List *list)
{
	if(list->size == 0)
	{
		cout<<"链表已空"<<endl;
		return false;
	}
	Node *p = list->first->next;//p指向要释放的第一个节点
	list->first->next = p->next;//头指针指向下一个节点
	free(p);                    //释放第一个节点
	if(list->size == 1)         
	{
		list->last = list->first;//如果只有一个节点，释放它之后尾指针得指向头结点)，其他情况尾指针不变
	}
	list->size--;
	return true;
}
//查找函数

/*Node *find(List *list,ElemType x)
{
	Node *p = list->first->next;//p指向第一个节点
	while(p != NULL)
	{
		if(x == p->data)
			return p;
		else
			p = p->next;
	}
	return NULL;
}*/
Node *find(List *list,ElemType x)
{
	Node *p = list->first->next;//p指向第一个节点
	while(p!=NULL && p->data!= x)
	{
		p = p->next;
	}
	return p;//while循环退出条件：没找到则-->p=NULL,找到p为指向所寻找节点的指针
}
//修改函数
bool modify(List *list,ElemType x)
{
	ElemType item;
	Node *p = find(list,x);
	if(p != NULL)
	{
		cout<<"Please input the new value:"<<endl;
		cin>>item;
		p->data = item;
		cout<<"it is modified"<<endl;
		return true;
	}
	else
		cout<<"it's not exist!"<<endl;
}
//按值删除结点
void delete_val(List *list,ElemType x)
{
	Node *p = find(list,x);      //找到要删除的结点
	if(p != NULL)
	{
		if(p == list->first->next)//如果是第一个结点（头删法）
		{
			pop_front(list);
		}
		else if(p == list->last)  //如果是最后一个结点（尾删法）
		{
			pop_back(list);
		}
		else //既不是第一个结点，也不是最后一个节点
		{
			p->data = p->next->data;//将要删除的结点的data赋值为下一个节点的data
			p->next = p->next->next;//连接
			free(p->next);          //将要删除的结点的下一个结点释放
		}
		/*else //既不是第一个结点，也不是最后一个节点
		{
			Node *pre = list->first;
			while(pre->next != p)//找到要删除节点的前驱
			{
				pre = pre->next;
			}
			pre->next = p->next;//连接
			free(p);            //释放要删除的结点
		}*/
		list->size--;
		cout<<"it is deleted!"<<endl;
	}
	else
	{
		cout<<"it is not exist!"<<endl;
	}

}
//清空单链表
/*void clear(List *list,ElemType x)
{
	for(int i=0;i<list->size;++i)
	{
		pop_back(list);//或者pop_front(list)
	}
}*/
void clear(List *list)
{
	Node *p = list->first->next;//p指向第一个节点
	while(p != NULL)
	{
		list->first->next = p->next;//分离出第一个结点
		free(p);//将第一个节点释放
		p = list->first->next;//又指向第一个节点(连续删除第一个结点)
	}
	list->last = list->first; //尾指针以及头指针都指向头结点
	list->size = 0;
}
//销毁链表
void destroy(List *list)
{
	clear(list);//清空链表
	free(list->first);//头结点释放
	list->first = list->last = NULL;//头（尾）指针赋空，防止成为野指针
}
//求链表长度
int length(List *list)
{
	return list->size;
}
//链表逆至
/*改变指针的指向*/
void resver(List *list)
{
	Node *pre = list->first->next;//pre指向第一个节点
	Node *p = pre->next;          //  p指向第二个结点
	pre->next = NULL;             //逆序之后第一个节点成为最后一个节点，所以next=NULL
	while(p != NULL)
	{
		Node *pre1 = pre;//将当前的指向保存下来
		Node *p1 = p;

		pre = p; //为下一次（第n-1次）交换做准备（必须在指向改变之后进行！！！！！）
		p = p->next;

		p1->next = pre1;//交换当前两个(第n次)后一个指向前一个
	}
	list->first->next = pre;    //退出循环，p=NULL,pre指向原来的最后一个结点（逆序后成为第一个）
	
}
/*交换值*/
/*void resver(List *list)
{
	Node *left = list->first->next;
	Node *right = list->last;
	Node *p = list->first;
	while(left != right)
	{
		left->data  = left->data + right->data;//对称的两个数交换
		right->data = left->data - right->data;
		left->data  = left->data - right->data;

		while(p->next != right)//找到倒数第二个结点
		{
			p = p->next;
		}

		right = p;//为下一次交换做准备
		left = left->next;	
	}
}*/
//求某个值的前驱
void prio(List *list,ElemType x)
{
	Node *p = find(list,x);
	if(p == NULL)
	{
		cout<<"it is not exist!\n"<<endl;
	}
	if(p == list->first->next)
	{
		cout<<"it does not have next"<<endl;
	}
	else
	{
		Node *pre = list->first;
		while(pre->next != p)
		{
			pre = pre->next;
		}
		cout<<"it's prio is found"<<endl;
		cout<<"it is"<<pre->data<<endl;;
	}
}
//求某个值的后继
void next(List *list,ElemType x)
{
	Node *p = find(list,x);
	if(p == NULL)
	{
		cout<<"it is not exist!\n"<<endl;
	}
	if(p == list->last)
	{
		cout<<"it does not have next"<<endl;
	}
	else
	{
		cout<<"it's next is found"<<endl;
		cout<<"it is"<<p->next->data<<endl;
	}
}
main.cpp: 

#include"List.h"
void main()
{
	List mylist;
	InitList(&mylist);

	int select = 1;
	ElemType item;
	Node *p = NULL;

	while(select)
	{
		cout<<"**********************************"<<endl;
		cout<<"* [1] push_back   [2] push_front *"<<endl;
		cout<<"* [3] show_seqlist[0] quit_system*"<<endl;
		cout<<"* [4] pop_back    [5] pop_front  *"<<endl;
		cout<<"* [6] find                       *"<<endl;
		cout<<"* [7] modify      [8] clear      *"<<endl;
		cout<<"* [9] destroy     [10]delete_val *"<<endl;
		cout<<"* [11] resver     [12]length     *"<<endl;
		cout<<"* [13] prio       [14]next       *"<<endl;
		cout<<"**********************************"<<endl;
		cout<<"请选择:>";
		cin>>select;
		switch(select)
		{
		case 1:
			cout<<"请输入要插入的数据(-1结束):>";
			while(cin>>item,item!=-1)
			{
				push_back(&mylist,item);
			}
			break;
		case 2:
			cout<<"请输入要插入的数据(-1结束):>";
			while(cin>>item,item!=-1)
			{
				push_front(&mylist,item);
			}
			break;
		case 3:
			show_seqlist(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);	
			break;
		case 6:
			cout<<"输入你要查找的值：";
			cin>>item;
			p =find(&mylist,item);
			if(p != NULL)
				cout<<"it is found!"<<endl;
			else
				cout<<"it is not exit!"<<endl;
			break;
		case 7:
			cout<<"请输入要修改的值：";
			cin>>item;
			modify(&mylist,item);
			break;
		case 8:
			clear(&mylist);
			break;
		case 9:
			destroy(&mylist);
			break;
		case 10:
			cout<<"请输入要删除的值：";
			cin>>item;
			delete_val(&mylist,item);
			break;
		case 11:
			resver(&mylist);
			break;
		case 12:
			{
				int n = length(&mylist);
				cout<<"the length of the list is:"<<n<<endl;
			}
			break;
		case 13:
			cout<<"输入你要查找前驱的值：";
			cin>>item;
			prio(&mylist,item);
			break;
		case 14:
			cout<<"输入你要查找后继的值：";
			cin>>item;
			next(&mylist,item);
			break;
		default:
			break;
		}
	}
	destroy(&mylist);//函数调用完之后，自动销毁链表
}





zyh_helen
关注
专栏目录
有头链表尾部插入以及删除
weixin_43621608的博客
05-27 535
链表尾部插入数据 尾部与头部插入的写法区别在于，头部插入链表，只需要将链表头部的next指针，赋给新插入的节点，再回身，将链表头的next指针指向，新插入的链表节点即可！ 如下： newNode->next = headNode->next;//头节点next指针，赋给新插入的节点next指针 headNode->next = newNode; //再将头链表next指针，指向新插入的节点，即完成连接 而再尾部插入数据，需要找到最后一个链表节点，并将其next指针，指向新插入的
在链表中使用头结点与尾指针
TITANIC上的小景
05-17 3万+
1 头结点 首先，不要被以下三个词组弄混了： 链表头：数据内容为第一个元素的结点。 头指针：指向头结点元素的指针。 头结点：数据内容无效，其指针是头指针。 一句话描述为：头指针是指向头结点的指针，头结点是指向链表头的结点。 对于一个链表来说，头指针和是一定存在的，是访问链表的入口，如果没有头指针则无法对其进行访问；链表头对于非空表来说是一定存在的，非空表则不存在。 注意到，如
链式队列（带头节点，头指针，尾指针的单链表）
qq_45421602的博客
07-28 1446
链式队列（带头节点，头指针，尾指针的单链表）
线性表【单循环链表的实现】（带头结点,带头尾指针）
最新发布
2401_82676816的博客
08-10 1098
图解如下：单循环链表为空表时：其头结点的next域指向它自己，即头结点next等于头指针与单链表的结构定义完全一致int01//1.单循环链表的结构定义不变//数据域//指针域//LNode *用来定义结点指针；//LinkHead 用来定义头指针；//LinkTail 用来定义尾指针；
单链表的头指针、头节点与尾节点
weixin_44380303的博客
04-29 4662
单链表的头指针、头节点与尾节点 头指针为NULL时，则该单链表为空链表；等于在内存中没有分配节点内存。 链表从头节点开始存储数据。尾节点同样有数据，但指向下一节点的地址为空。 下面从头到尾打印单链表的值的代码： struct ListNode { int val; struct ListNode *next; ListNode(int x): val(x)...
单链表头尾指针
忽然七日
12-06 401
Java中的单链表 单链表具有头指针、尾指针、链表大小属性 实现了头插入、尾插入、头删除、尾删除等操作
C语言——查找（折半、分块、二叉排序、哈希法）
qq_51308373的博客
06-20 4439
前言 本篇主要介绍查找概念及各类查找方法。 看完本篇，你将了解到： 1.查找问题概述（查找表可进行的操作、时间开销、一些计算方法） 2.顺序表的查找（存储方式、算法时间性能） 3.折半查找（可递归可迭代） 4.分块查找 5.二叉排序树（查找、插入、创建、删除） 6.平衡二叉排序树（平衡化方法：四种类型） 7.哈希查找（哈希表、哈希函数、解决冲突的方法） 一、查找问题概述 1.查找问题 （1）定义： ①“查找”是基于数据逻辑结构(D,R)定义的一种十分常见的运算。 ②D：数据元素的一个集合 R：数据元素关系的
【数据结构】Java实现常用数据结构
Java
09-15 939
【数据结构】Java算法基础 一、前言 KMP算法 汉诺塔 八皇后（分治算法） 马踏棋盘算法（骑士周游问题）图的深度优先算法+贪心算法优化 第一章、稀疏数组和队列 1.1 稀疏数组 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个有效值 把具有不同值的有效元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 package zy.code.sparsearray; /** * 稀
面向地学数据的数据挖掘研究与实现
晓风残月xj
12-19 4582
数据挖掘又称知识发现，是指从海量数据中发掘知识，有着广阔的应用前景。然而，当面对地学数据时，即使是现有的相对成熟的模型，也存在着性能与效果方面的缺陷。究其原因，主要是因为地学数据的固有特点：高维、非结构化、多关联性等，在数据模型、索引结构、存储方式、挖掘知识表达等方面，远比传统数据复杂。 通常意义的地学数据有栅格、矢量等，本文注重处理栅格数据。Tobler地理学第一定理告诉我们：一切事物都与其他事物相关，但是距离近的比远的相关性更强。本文针对地学数据的空间相关性特点，通过R树建立空间索引，以空间同位模式挖掘
C++面试宝典2023版
热门推荐
志在千里
09-19 7万+
1.new、delete、malloc、free关系 delete会调用对象的析构函数,和new对应free只会释放内存，new调用构造函数。malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部
二叉树的基本运算实验报告C语言,实验三 二叉树基本操作与应用实验
weixin_31690531的博客
05-18 4829
实验三二叉树基本操作与应用实验第三次实验主要包括两部分内容：1.二叉树基本操作实验；2.二叉树应用—赫夫曼树与赫夫曼编码实验。基本操作包括存储结构建立和遍历算法，本文只给出部分参考程序，请大家尽量完成多数基本操作。第一部分 基本操作实验[问题描述] 二叉树采用二叉链表作存储结构，试编程实现二叉树的如下基本操作1．按先序序列构造一棵二叉链表表示的二叉树T；2．对这棵二叉树进行遍历：先序、中序、后序以...
一个简单的带头尾指针单向链表（C实现）
09-20 1193
        用C写了一个带头尾指针的单向链表，仅在尾部进行插入操作，在任意位置进行删除操作。因为只用到这么些功能，又因为懒，所以没有扩展。因为插入是固定在尾部进行，带一个尾指针的好处是显而易见的。当然删除时要付出一些开销。list.h－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－/* list.h** Copyright 2004 Coon
215. 数组中的第K个最大元素(C++)---基于快排的方法 / 基于堆排序的方法(包含优先队列的使用总结)
努力学习的DS
06-30 523
在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。 示例 1:输入: [3,2,1,5,6,4] 和 k = 2输出: 5 示例 2: 输入: [3,2,3,1,2,4,5,5,6] 和 k = 4 输出: 4 说明: 你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。 ——题目难度:中等 -基于快排的方法的解题代码 class Solution { public: int findKthLarg.
Python 实现带头尾指针的单向链表
计算机视觉
01-22 822
#!/usr/bin/python # -*- coding: utf-8 -*- ''' Created on 2015-1-22 @author: beyondzhou @name: test_tailsinglelinkedlist.py ''' def test_tailsinglelinkedlist(): # import linkedlist from
链表基础知识（一、单链表、头插、尾插、头删、尾删、查找、删除、插入、求表长，合并链表）
走在努力路上的自己的博客
12-13 3241
顺序表的问题及思考问题：1.中间/头部的插入删除，时间复杂度为O(N)2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面给出了链表的结构来看看。
数据结构：（c实现）单向链表，单链表的头增，尾增，头删，尾删，任意位置的删除与插入。
qq_51004011的博客
05-13 1261
一：什么是单链表 （1）单链表节点数据结构 （2）单链表结构物理图解 二：单链表的几种接口函数的实现 （1）单链表的尾插函数（顺序插入） (2)单链 链表一般分成两块：一部分存储数据，另一部分存储下一个节点的指针。 链表与顺序表不同，链表的存储形式不是一块物理地址连续的空间。而是在内存中随机存储。需要存入一个新的数据时，就malloc开辟一个新的节点。并将新开辟的空间的地址放置到上一个节点的指针中。 再将该节点的指针赋NULL。 ...
Java实现的带头、尾指针的循环单链表
m0_63733501的博客
12-29 582
循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。 循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。本文带你快速了解循环链表。
【数据结构】链表
高高冷的博客
12-04 9060
引言 单链表 静态链表 循环链表和双向链表 链表的应用
数据结构快速入门——（链式）存储结构、头/尾指针和存储空间
长臂人猿的博客
01-11 946
前言 数据结构总的来说就是存储结构 + 不同的结构特性的使用方法；比如说同样的存储结构，根据其不同的结构特性有链表、栈、队，他们不同在于入出的方法或者说是顺序不同，本质上都是线性存储结构。由于顺序表，实质上就是数组，这里不再累赘。 存储结构 存储结构是决定数据结构的基本单元，以链表为例，首先看一下链式存储的存储结构： typedef struct Node { int data;...
有头指针和尾指针的单链表的基本操作代码
10-14
有头指针和尾指针的单链表基本操作代码如下： ```c++ #include <iostream> using namespace std; struct Node { int data; Node* next; }; class LinkedList { private: Node* head; Node* tail; public: LinkedList() { head = new Node(); tail = head; } void insert(int val) { Node* newNode = new Node(); newNode->data = val; tail->next = newNode; tail = newNode; } void remove(int val) { Node* cur = head->next; Node* pre = head; while (cur != nullptr) { if (cur->data == val) { pre->next = cur->next; if (cur == tail) { tail = pre; } delete cur; return; } pre = cur; cur = cur->next; } } void print() { Node* cur = head->next; while (cur != nullptr) { cout << cur->data << " "; cur = cur->next; } cout << endl; } }; int main() { LinkedList list; list.insert(1); list.insert(2); list.insert(3); list.print(); list.remove(2); list.print(); return 0; } ```
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值