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

最新推荐文章于 2024-09-28 10:55:39 发布
最新推荐文章于 2024-09-28 10:55:39 发布
阅读量7.8k 收藏 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
关注
专栏目录
有头的单链表的基本操作
f_shell_x的博客
09-24 405
对于单链表的基本操作有 初始化，销毁，以及头部插入，尾部插入，头部删除，尾部删除以及计算单链表的长度。 我这里的初始化函数，因为有一个链表头，所以malloc的时候，是从第二个空间进行空间开辟的。并且在释放的时候，也是从第二个空间开始释放的。并且头部的插入和删除，也都是第二个位置的删除与插入，如果需要修改头的值，就需要调用另外一个函数。这个我会在别的博客里面写清楚。 具体实现并不难，咋们直接...
在链表中使用头结点与尾指针
TITANIC上的小景
05-17 3万+
1 头结点 首先，不要被以下三个词组弄混了： 链表头：数据内容为第一个元素的结点。 头指针：指向头结点元素的指针。 头结点：数据内容无效，其指针是头指针。 一句话描述为：头指针是指向头结点的指针，头结点是指向链表头的结点。 对于一个链表来说，头指针和是一定存在的，是访问链表的入口，如果没有头指针则无法对其进行访问；链表头对于非空表来说是一定存在的，非空表则不存在。 注意到，如
链式队列（带头节点，头指针，尾指针的单链表）
qq_45421602的博客
07-28 1506
链式队列（带头节点，头指针，尾指针的单链表）
单链表的实现
最新发布
2303_81060385的博客
09-28 818
单链表的概念，结构，分类及相关接口实现的详细讲解。
单链表的头指针、头节点与尾节点
weixin_44380303的博客
04-29 4736
单链表的头指针、头节点与尾节点 头指针为NULL时，则该单链表为空链表；等于在内存中没有分配节点内存。 链表从头节点开始存储数据。尾节点同样有数据，但指向下一节点的地址为空。 下面从头到尾打印单链表的值的代码： struct ListNode { int val; struct ListNode *next; ListNode(int x): val(x)...
单链表头尾指针
忽然七日
12-06 412
Java中的单链表 单链表具有头指针、尾指针、链表大小属性 实现了头插入、尾插入、头删除、尾删除等操作
C语言——查找（折半、分块、二叉排序、哈希法）
qq_51308373的博客
06-20 4489
前言 本篇主要介绍查找概念及各类查找方法。 看完本篇，你将了解到： 1.查找问题概述（查找表可进行的操作、时间开销、一些计算方法） 2.顺序表的查找（存储方式、算法时间性能） 3.折半查找（可递归可迭代） 4.分块查找 5.二叉排序树（查找、插入、创建、删除） 6.平衡二叉排序树（平衡化方法：四种类型） 7.哈希查找（哈希表、哈希函数、解决冲突的方法） 一、查找问题概述 1.查找问题 （1）定义： ①“查找”是基于数据逻辑结构(D,R)定义的一种十分常见的运算。 ②D：数据元素的一个集合 R：数据元素关系的
【数据结构】Java实现常用数据结构
Java
09-15 998
【数据结构】Java算法基础 一、前言 KMP算法 汉诺塔 八皇后（分治算法） 马踏棋盘算法（骑士周游问题）图的深度优先算法+贪心算法优化 第一章、稀疏数组和队列 1.1 稀疏数组 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个有效值 把具有不同值的有效元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 package zy.code.sparsearray; /** * 稀
面向地学数据的数据挖掘研究与实现
晓风残月xj
12-19 4638
数据挖掘又称知识发现，是指从海量数据中发掘知识，有着广阔的应用前景。然而，当面对地学数据时，即使是现有的相对成熟的模型，也存在着性能与效果方面的缺陷。究其原因，主要是因为地学数据的固有特点：高维、非结构化、多关联性等，在数据模型、索引结构、存储方式、挖掘知识表达等方面，远比传统数据复杂。 通常意义的地学数据有栅格、矢量等，本文注重处理栅格数据。Tobler地理学第一定理告诉我们：一切事物都与其他事物相关，但是距离近的比远的相关性更强。本文针对地学数据的空间相关性特点，通过R树建立空间索引，以空间同位模式挖掘
二叉树的基本运算实验报告C语言,实验三 二叉树基本操作与应用实验
weixin_31690531的博客
05-18 4911
实验三二叉树基本操作与应用实验第三次实验主要包括两部分内容：1.二叉树基本操作实验；2.二叉树应用—赫夫曼树与赫夫曼编码实验。基本操作包括存储结构建立和遍历算法，本文只给出部分参考程序，请大家尽量完成多数基本操作。第一部分 基本操作实验[问题描述] 二叉树采用二叉链表作存储结构，试编程实现二叉树的如下基本操作1．按先序序列构造一棵二叉链表表示的二叉树T；2．对这棵二叉树进行遍历：先序、中序、后序以...
C++面试宝典2023版
热门推荐
志在千里
09-19 7万+
1.new、delete、malloc、free关系 delete会调用对象的析构函数,和new对应free只会释放内存，new调用构造函数。malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部
一个简单的带头尾指针单向链表（C实现）
09-20 1202
        用C写了一个带头尾指针的单向链表，仅在尾部进行插入操作，在任意位置进行删除操作。因为只用到这么些功能，又因为懒，所以没有扩展。因为插入是固定在尾部进行，带一个尾指针的好处是显而易见的。当然删除时要付出一些开销。list.h－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－/* list.h** Copyright 2004 Coon
215. 数组中的第K个最大元素(C++)---基于快排的方法 / 基于堆排序的方法(包含优先队列的使用总结)
努力学习的DS
06-30 538
在未排序的数组中找到第 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.
链表之 头节点与尾指针 区别
weixin_30852367的博客
01-15 3016
单链表的必要条件：头节点的head，以及尾指针指向null； 1头结点 首先，不要被以下三个词组弄混了： 链表头：数据内容为第一个元素的结点。 头指针：指向头结点元素的指针。 头结点：数据内容无效，其指针是头指针。 一句话描述为：头指针是指向头结点的指针，头结点是指向链表头的结点。 对于一个链表来说，头指针是一定存在的，是访问链表的入口，如果没有头指针则无法对其进行访...
Python 实现带头尾指针的单向链表
计算机视觉
01-22 834
#!/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 3439
顺序表的问题及思考问题：1.中间/头部的插入删除，时间复杂度为O(N)2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面给出了链表的结构来看看。
数据结构：（c实现）单向链表，单链表的头增，尾增，头删，尾删，任意位置的删除与插入。
qq_51004011的博客
05-13 1292
一：什么是单链表 （1）单链表节点数据结构 （2）单链表结构物理图解 二：单链表的几种接口函数的实现 （1）单链表的尾插函数（顺序插入） (2)单链 链表一般分成两块：一部分存储数据，另一部分存储下一个节点的指针。 链表与顺序表不同，链表的存储形式不是一块物理地址连续的空间。而是在内存中随机存储。需要存入一个新的数据时，就malloc开辟一个新的节点。并将新开辟的空间的地址放置到上一个节点的指针中。 再将该节点的指针赋NULL。 ...
Java实现的带头、尾指针的循环单链表
m0_63733501的博客
12-29 633
循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。 循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。本文带你快速了解循环链表。
【数据结构】链表
高高冷的博客
12-04 9428
引言 单链表 静态链表 循环链表和双向链表 链表的应用
带头指针的循环单链表和带尾指针的循环单链表
06-24
带头指针的循环单链表和带尾指针的循环单链表都是用于表示链式数据结构，它们的主要区别在于链接节点的方式和操作上。 1. **带头指针循环链表（Head-Linked Cycle List）**: - 在这种结构中，链表有一个特殊的头...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值