数据结构之单链表

最新推荐文章于 2022-11-01 12:55:15 发布
最新推荐文章于 2022-11-01 12:55:15 发布
阅读量436 收藏
点赞数
分类专栏： Exercise 文章标签： 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SmartBrave/article/details/45621035
版权

单链表属于线性表的一种，不过与顺序表相比，线性单链表没有空间的限制，往往可以无限开辟空间并使用(除非内存不足)。但正是因为如此，在进行链表的插入、删除、等操作时，也比顺序结构的链表更为复杂，效率也不及顺序表，即时间复杂度高。

链表的节点结构如图:

链表结构:


以下是代码:

头文件List.h

#ifndef _LIST_H
#define _LIST_H

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

#define ElemType int

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

typedef struct List
{
	PNode first;
	PNode last;
	size_t size;
}List;

//
void InitList(List *list);
bool push_back(List *list, ElemType x);
bool push_front(List *list, ElemType x);
bool pop_back(List *list);
bool pop_front(List *list);
Node* Find(List *list, ElemType key);
bool delete_val(List *list, ElemType key);
void ShowList(List *list);
void clear(List *list);
void destroy(List *list);
bool resver(List *list);
bool insert_val(List *list,ElemType key);
ElemType getvalue(List *list,int x);
bool modify(List *list,ElemType item,ElemType nitem);
bool sort(List *list);
int length(List *list);
ElemType next(List *list,ElemType key);
ElemType prio(List *list,ElemType key);
#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->data = x;
	s->next = NULL;

	list->last->next = s;
	list->last = s;

	list->size++;
	return true;
}

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;
}

void ShowList(List *list)
{
	Node *p = list->first->next;
	while(p != NULL)
	{
		cout<<p->data<<"-->";
		p = p->next;
	}
	cout<<"Nul"<<endl;
}

bool pop_back(List *list)
{
	if(list->size == 0)
		return false;
	Node *pre = list->first;
	while(pre->next != list->last)
		pre = pre->next;

	pre->next = NULL;
	free(list->last);
	list->last = pre;
	list->size--;
	return true;
}

bool pop_front(List *list)
{
	if(list->size == 0)
		return false;
	Node *p = list->first->next;
	if(list->size == 1)
	{
		free(p);
		list->first->next = NULL;
		list->last = list->first;
	}
	else
	{
		list->first->next = p->next;
		free(p);
	}
	list->size--;
	return true;
}

Node* Find(List *list, ElemType key)//若找到，返回该节点前一节点的地址
{
	Node *p = list->first;
	while(p->next->next!=NULL && p->next->data!=key)
		p = p->next;
	if (p->next==list->last&&p->next->data!=key)
	{
		return NULL;
	}
	return p;
}

bool delete_val(List *list, ElemType key)
{
	Node *p = Find(list,key);
	if(p == NULL)
	{
		cout<<"该值不存在!"<<endl;
		return false;
	}
	Node *s=p->next;
	p->next=s->next;
	free(s);
	return true;


}

void clear(List *list)
{
	Node *p = list->first->next;
	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;
}

bool insert_val(List *list,ElemType key)
{
	Node *s=(Node *)malloc(sizeof(Node));
	if (s==NULL)
	{
		return false;
	}
	s->data=key;
	if (list->size==0)
	{
		list->first->next=s;
		list->last->next=s;
		s->next=NULL;
	}
	else
	{
		Node *p=list->first;
		while (p->next!=NULL&&p->next->data<key)
		{
			p=p->next;
		}
		s->next=p->next;
		p->next=s;
	
	}
	list->size++;
	return true;
}

ElemType getvalue(List *list,int x)
{
	if (list->size==0||x<1||x>list->size)
	{
		return -1;
	}
	Node *p=list->first;
	for (int i=0;i<x;i++)
	{
		p=p->next;
	}
	return p->data;
}


bool modify(List *list,ElemType item,ElemType nitem)			//如何精简？
{
	if (list->size==0)
	{
		return false;
	}
	Node *p=list->first;
	Node *s=(Node *)malloc(sizeof(Node));
	s->data=nitem;
	if (p->next->data==item)
	{
		s->next=p->next->next;
		free(p->next);
		p->next=s;
	}
	while (p->next->next!=NULL&&p->next->data!=item)
	{
		p=p->next;
	}
	if (p->next==list->last)
	{
		if (p->next->data==item)
		{
			s->next=NULL;
			free(p->next);
			p->next=s;
			list->last=s;
			return true;
		}
		return false;
	}
	s->next=p->next->next;
	free(p->next);
	p->next=s;
	return true;

/*
	if (list->size==0)	//应用改变指针的方法来修改
	{
		return false;
	}
	Node *p=list->first;
	while (p->next!=NULL&&p->data!=item)
	{
		p=p->next;
	}
	if (p==list->last)
	{
		if (p->data==item)
		{
			p->data=nitem;
		}
		return false;
	}
	p->data=nitem;
	return true;*/
}



bool sort(List *list)
{
	if (list->size==0||list->size==1)
	{
		return false;
	}
	Node *p=list->first;
	for (;p->next!=NULL;p=p->next)
	{
		for (Node *q=p->next;q->next!=NULL;)
		{
			if (p->next->data>q->next->data)
			{
				Node *ptmp=q->next;
				q->next=ptmp->next;
				ptmp->next=q;
				p->next=ptmp;
				
			/*
				ElemType tmp=p->next->data;
				p->next->data=p->next->next->data;
				p->next->next->data=tmp;*/
			}
		}
	}
	return true;
}




bool resver(List *list)
{
	if (list->size==0||list->size==1)
	{
		return false;
	}
	Node *fp=list->first->next;
	Node *p=fp->next;
	Node *lp=p->next;
	fp->next=	NULL;
	list->last->next=fp;
	if (lp!=NULL)
	{
		do 
		{
			p->next=fp;
			fp=p;
			p=lp;
			lp=lp->next;
		}while(p->next!=NULL);
		list->first->next=fp;
	}
	else
	{
		list->first->next=p;
		p->next=fp;
	}
	return true;
}



int length(List *list)
{
	return list->size;
}
ElemType next(List *list,ElemType key)
{
	if (list->size==0||list->size==1)
	{
		return -1;
	}
	Node *p=list->first;
	while (p->next!=NULL)
	{
		if (p->next->data==key&&p->next->next!=NULL)
		{
			p=p->next;
			return p->next->data;
		}
		p=p->next;
	}
	return -1;
}
ElemType prio(List *list,ElemType key)
{
	if (list->size==0||list->size==1)
	{
		return -1;
	}
	Node *p=list->first;
	if (p->next->data==key)
	{
		return -1;
	}
	while (p->next!=NULL)
	{
		if (p->next->data==key)
		{
			return p->data;
		}
		p=p->next;
	}
	return -1;
}
最后是主函数main.cpp: 

#include"List.h"
//#include<vld.h>

void main()
{
	List mylist;
	InitList(&mylist);
	
	int select = 1;
	ElemType item,nitem;
	Node *p = NULL;
	int pos;
	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] insert_pos  [7] insert_val *"<<endl;
		cout<<"* [8] delete_pos  [9] delete_val *"<<endl;
		cout<<"* [10] find       [11]getvalue   *"<<endl;
		cout<<"* [12] modify     [13]clear      *"<<endl;
		cout<<"* [14] destroy    [15]sort       *"<<endl;
		cout<<"* [16] resver     [17]length     *"<<endl;
		cout<<"* [18] next       [19]prio       *"<<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:
			ShowList(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			
			break;
		case 7:
			cout<<"请输入要插入的值:>";
			cin>>item;
			insert_val(&mylist,item);
			break;
		case 8:
			
			break;
		case 9:
			cout<<"请输入要删除的值:>";
			cin>>item;
			delete_val(&mylist,item);
			break;
		case 10:
			cout<<"请输入要查找的值:>";
			cin>>item;
			p = Find(&mylist,item);
			if (p!=NULL)
			{
				cout<<"该值是:"<<p->next->data<<endl;
			}
			else
			{
				cout<<"该值不存在!"<<endl;
			}
			break;
		case 11:
			cout<<"请输入要查找的值的序号:>";
			cin>>item;
			cout<<getvalue(&mylist,item)<<endl;
			break;
		case 12:///
			cout<<"请输入要修改的值:>";
			cin>>item;
			cout<<"请输入要新的值:>";
			cin>>nitem;
			modify(&mylist,item,nitem);
			break;
		case 13:
			clear(&mylist);
			break;
		case 14:
			destroy(&mylist);
			break;
		case 15:/ERROR!
			sort(&mylist);
			break;
		case 16:ERROR
			resver(&mylist);
			break;
		case 17:
			cout<<length(&mylist)<<endl;
			break;
		case 18:
			cout<<"请输入一个值:";
			cin>>item;
			cout<<next(&mylist,item)<<endl;
			break;
		case 19:
			cout<<"请输入一个值:";
			cin>>item;
			cout<<prio(&mylist,item)<<endl;
			break;
		default:
			break;
		}
	}
	destroy(&mylist);
}



SmartBrave
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之单链表实验
// 在校菜鸟大学生的日常学习博客
09-01 5857
单链表实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 掌握线性表的定义、特点、逻辑结构，理解线性表的抽象数据类型。 熟练掌握线性表的两种存储结构的结构类型定义、特点和基本操作的实现。 通过本次实验帮助学生加深对线性表的理解，并加以应用； 实验环境 CodeBlocks 实验要求 1.熟悉c语言的语法知识； 2.了解线性表的逻辑结构特性； 3.掌握线性表的链式存储结构—单链表的定义、创建、插入、删除、取值等基本操作； 实验内容 完成单链表的基本操作（定义、初始化、插入、删除、定位等）的汇总，
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 5281
数据结构深度学习之单链表非常详解解读~~~一万多字详解
数据结构之单链表（java版）
qq_42489613的博客
10-23 1410
数据结构就是用某种结构去储存数据
数据结构之单链表合并
编程小敬的博客
02-21 1388
分析 1.传递两个链表参数 2.创建辅助变量存储第一个链表，防止第一个链表的头节点发生变化 3.创建辅助变量存储第二个链表的下一个节点，防止在改变当前节点的指针时，导致后续节点失效 4.遍历第二个链表，在遍历过程中遍历第一个链表，判断节点的排序 代码实现 /** * 合并两个单链表，合并之后仍然有序 * @return */ public static HeroNode betweenLinkedList(HeroNode start,HeroNode end){
数据结构之单链表的实现（含全部代码）
qq_61635026的博客
04-12 3435
数据结构之单链表的实现（含全部代码）
数据结构之单链表的插入
six_teen的博客
01-24 1万+
什么是链表？ 如上图，链表和生活中的链条很相似，链表在逻辑结构上是以链条的形式连接而成的，但物理结构上链表的节点不是连续性存储的。 如图，每一个节点都分为两块区域，data区和next区，data区存储数据，next区存储下一个节点的地址。因为节点的这种特性，所以链表可以充分利用内存中零散的空间。 链表一般分为带头节点的链表和不带头节点的链表（头结点用head表示）后续演示都使用带头节点的链表（一般头结点data区为空，next区指向第一个节点）： 先定义一个节点类： no表示节点序号，name,.
图解Java数据结构之单链表
。。。
08-07 4846
本篇文章介绍数据结构中的单链表。 链表(Linked List)介绍 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 单链表 链表是有序的列表，它在内存中存储方式如下： 虽然链表是有序列表，但是其元素并不是连续存储的。我们从图中可以看出，a1的next域为110，而地址为110的元素为a2；a2的next域为180，而地址为180的元素为a3，以此类推。 综上所述...
数据结构之单链表（c语言附完整代码）
热门推荐
m0_62795460的博客
11-01 1万+
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。声明单链表//数据域 struct LNode * next;//指针域，指向后继结点 } LinkNode;//声明单链表结点类型注意：本文章讨论的单链表是带头结点的单链表。
数据结构之单链表销毁,求长度
m0_46645068的博客
03-30 1065
单链表的销毁 单链表要销毁，需要两个指针*pre，*p 使*pre指向单链表头结点 ，*p指向单链表的首结点。然后释放*pre指向的空间，是pre和p前进循环 void DestoryList(*L) { Linknode *pre,*p; pre=L;p=L->next; while(p!=NULL) { free(pre); pr...
数据结构之单链表操作合集.zip
最新发布
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
Python数据结构之单链表详解
09-21
### Python数据结构之单链表详解 #### 一、单链表基础概念 单链表是一种常见的线性数据结构，其特点是每个元素包含一个指向下一个元素的引用（指针），因此形成一个链接的数据序列。与数组相比，单链表的优势在于...
基于JAVA的数据结构之单链表操作合
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
求1-1/2+1/3-1/4+1/5……+1/99-1/100的值
Smart的专栏
12-27 6871
求1-1/2+1/3-1/4+1/5……+1/99-1/100的值
求1000-2000年间闰年的数量
Smart的专栏
12-27 1829
判断闰年
将一个数字字符串转换成该字符串对应的数字（包括正整数、负整数）
Smart的专栏
03-15 1809
将一个数字字符串转换成该字符串对应的数字（包括正整数、负整数）
将一个数字字符串转换成这个字符串对应的数字包括正浮点数、负浮点数）
Smart的专栏
03-15 1772
将一个数字字符串转换成这个字符串对应的数字
程序进度条的实现
Smart的专栏
05-17 1664
进度条
数据结构：单链表表示与实例解析
在本讲义中，我们深入探讨了数据结构的概念和应用，特别是通过实际案例来解析其重要性。首先，数据结构是指在计算机科学中，信息按照特定方式组织和存储，以便有效地进行处理和操作。例如，电话号码查询系统的例子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值