数据结构之链表操作（单链表，单向循环链表，双向循环链表）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等操作

已于 2023-05-06 14:03:27 修改
阅读量1.9k 收藏 24
点赞数 5
分类专栏： 数据结构与算法 Linux-c 文章标签： 数据结构 链表 算法
于 2022-05-16 20:15:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45698138/article/details/124807099
版权

文章目录

链表和数组的优缺点

数组：
优点，支持随机访问，内存消耗较小
缺点，大小固定，插入和删除操作效率低
链表：
优点，动态比较灵活开辟空间，插入和删除操作效率高
缺点，不支持随机访问，内存消耗较大，需要额外的指针

一、线性表

线性表结构的数据是依次排列（一对一）

（1）顺序结构：数组，顺序栈，顺序队列（顺序表）

（2）链式存储：链表，链式栈，链式队列（线性表）

二、链表
2.1、链表

​ 链表是一种具体的数据结构

​ 1、逻辑上：一对一的排列

​ 2、存储上：非连续的

​ 3、相关操作：查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等

​ 4、链表分类

​ 单向链表，双向链表，单向循环链表，双向循环链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CZZ9uKEz-1652703194449)(file:///C:/Users/yyh/AppData/Local/Temp/msohtmlclip1/01/clip_image002.jpg)]

​ 5、链式存储特点

​ 不需要一块连续内存

​ 插入和删除效率极高

2.2、单向链表

链式存储结构：数据元素是随机存储的，通过指针表示数据之间的逻辑关系

（1）单向链表的节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YSlVm5li-1652703194450)(file:///C:/Users/yyh/AppData/Local/Temp/msohtmlclip1/01/clip_image004.jpg)]

单向链表节点模板声明

typedef [节点数据域类型] Datatype;

//单向链表节点
struct Node
{
	Datatype data;		//数据域
	struct Node *next;	    //指针域	
};

经常给节点结构体和节点结构体指针取别名，方便以后的使用

//单向链表节点
typedef struct Node
{
	Datatype data;		//数据域
	struct Node *next;	//指针域	
}ListNode;

单链表初始化

一般定义一个不带数据的节点（头结点），用来表示整个链表的头部

//初始化链表（新建一个不带数据的头结点）
ListNode * InitNode()	//不带数据的头节点
{
	ListNode * head=(ListNode *)malloc(sizeof(ListNode));
	if(head != NULL){
		head->next = NULL;
	}else{
		return NULL;
	}
	return head;
}

//调用空链表初始化
	ListNode *head = init();
	if (head == NULL)
	{
		return -1;
	}
（2）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表

新建节点

//新建节点
ListNode * CreateNode(Datatype data)
{
	ListNode * new=(ListNode *)malloc(sizeof(ListNode));
	if (new!=NULL){
		new->next = NULL;
	}else{
		return NULL;
	}
	new->data = data;
	return new;
}

插入节点

尾插法

//插入节点，尾插法
void InsertNodeTail(ListNode *head,ListNode * new)
{
	ListNode *p=head;//定义一个临时中间变量p，用来遍历链表，找到最后的节点，防止头结点地址发生改变
	while(p->next != NULL)
	{
		//一个一个往后找
		p = p->next;
	}
	//找到最后一个节点之后，将最后一个节点的next设置为new(新节点的地址)
	p->next = new;
}

头插法

//头插法
void InsertNodeHead(ListNode *head,ListNode *new)
{
	new->next = head->next;
	head->next=new;
}

遍历链表

//遍历链表
void Display(ListNode *head)
{
  ListNode *p=head->next;
  while(p!=NULL)
  {
  	printf("%d  ",p->data);
  	p=p->next;
  }
  printf("\n");
}

查找节点

//查找节点
ListNode *FindNode(ListNode *head,Datatype data)
{
	ListNode *p=head->next;
	while(p!=NULL)
	{
		if(p->data == data)
		{
			return p;
		}
		p=p->next;
	}
	return NULL;
}

删除节点

//删除节点，以数据来删除
Node_p dele_node(Node_p head, Datatype dele_data)
{
	Node_p p = head;
	while(p->next != NULL)
	{	
		if (p->next->data == dele_data)
		{
			Node_p dele = p->next;
			p->next = dele->next;//防止链表的链式关系断开
			free(dele);
			dele = NULL;
			return p;
		}
		p = p->next;
	}
	return NULL;
}
//删除节点，以节点来删除
ListNode * DeleteNode(ListNode *head,ListNode *delNode)
{
	ListNode *p=head;
	while(p->next!=NULL)
	{
		if(p->next == delNode)
		{
			ListNode *tmp = p->next;
			p->next = tmp->next;
			free(tmp);
			tmp=NULL;
			return p->next;
		}
		p=p->next;
	}
	return NULL;
}

//删除所有数据为dele_data的节点
ListNode *DeleteNodeByDate(ListNode *head,Datatype data)
{
	ListNode *p=head;
	while(p->next!=NULL)
	{
		if(p->next->data == data)
		{
			ListNode *tmp=p->next;
			p->next=p->next->next;//防止链表的链式关系断开
			free(tmp);
			tmp=NULL;
			continue;
		}
		p=p->next;
	}
	return NULL;
}

更改节点

//更改节点
void UpdateNode(ListNode *head,DateType old_data,Datatype new_data)
{
	ListNode *p = FindNode(head, old_data);
	if (p != NULL)
	{
		p->data = new_data;
	}
	else
	{
		printf("没有找到要修改的节点\n");
	}
}

判断空链表

//判断空链表
bool IsEmpty(ListNode * head)
{
   return (head->next == NULL);
}

清空链表

//清空链表
void ClearLinkNode(ListNode* head)
{
	if(head == NULL || IsEmpty(head))
	{
		return ;
	}
	while(head->next != NULL)
	{
		ListNode* dele = head->next;
		head->next = dele->next;
		free(dele);		
		dele->next = NULL;
		dele = NULL;
	}
}

取出节点

//取出节点，节点不删除
ListNode* GetNode(ListNode* head, Datatype data)
{
   if(head == NULL || is_empty(head))
   {
   	return NULL;
   }
   ListNode* p = head;
   while(p->next != NULL)
   {
   	if (p->next->data == data)
   	{
   		ListNode* node = p->next;
   		p->next = node->next;
   		return node;
   	}
   	p = p->next;
   }
   return NULL;
}

指定位置插入节点

void InsertNode_node(ListNode* node1,ListNode* node2)
{
    //将node1插入到node2后面
  if (node1 == NULL || node2 == NULL)
	{
		return;
	}
	//相当于头插法，node2为头结点，node1为新节点
	//node1->next = node2->next;
	//node2->next = node1;
  InsertNodeHead(node2, node1);
}

移动节点

//移动节点
void move_node(ListNode* head, Datatype data1, Datatype data2)
{
	//取出移动的节点data1
	ListNode* node1 = GetNode(head, data1);
	//找到data2的节点
	ListNode* node2 = FindNode(head, data2);
	//将data1插入到data2后面
	if (node1 == NULL || node2 == NULL)
	{
		return;
	}
	node1->next = node2->next;
	node2->next = node1;
}
（3）单向链表 完整代码
#include <stdio.h>
#include <stdlib.h>

typedef int Datatype;
typedef struct Node
{	
	Datatype data;
	struct Node *next;	
}ListNode;


ListNode * InitNode()	//不带数据的头节点
{
	ListNode * head=(ListNode *)malloc(sizeof(ListNode));
	if(head != NULL){
		head->next = NULL;
	}else{
		return NULL;
	}
	return head;
}

//创建
ListNode * CreateNode(Datatype data)
{
	ListNode * new=(ListNode *)malloc(sizeof(ListNode));
	if (new!=NULL){
		new->next = NULL;
	}else{
		return NULL;
	}
	new->data = data;
	return new;
}
//尾插
void InsertNodeTail(ListNode *head,ListNode * new)
{
	ListNode *p=head;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	p->next = new;
}
//头插
void InsertNodeHead(ListNode *head,ListNode *new)
{
	new->next = head->next;
	head->next=new;
}

void Display(ListNode *head)
{
	ListNode *p=head->next;
	while(p!=NULL)
	{
		printf("%d  ",p->data);
		p=p->next;
	}
	printf("\n");
}

ListNode * DeleteNode(ListNode *head,ListNode *delNode)
{
	ListNode *p=head;
	while(p->next!=NULL)
	{
		if(p->next == delNode)
		{
			ListNode *tmp = p->next;
			p->next = tmp->next;
			free(tmp);
			tmp=NULL;
			return p->next;
		}
		p=p->next;
	}
	return NULL;
}

//删除
ListNode *DeleteNodeByDate(ListNode *head,Datatype data)
{
	ListNode *p=head;
	while(p->next!=NULL)
	{
		if(p->next->data == data)
		{
			ListNode *tmp=p->next;
			p->next=p->next->next;
			free(tmp);
			tmp=NULL;
			continue;
		}
		p=p->next;
	}
	return NULL;
}

//查找
ListNode *FindNode(ListNode *head,Datatype data)
{
	ListNode *p=head->next;
	while(p!=NULL)
	{
		if(p->data == data)
		{
			return p;
		}
		p=p->next;
	}
	return NULL;
}

//更改数据
ListNode *UpdateNode(ListNode *head,DateType old_data,Datatype new_data)
{
	ListNode *p=head->next;
	while(p!=NULL)
	{
		if(p->data == old_data)
		{
			p->data = new_data;
			// return p;
		}
		p=p->next;
	}
	return NULL;
}

//删除所有数据为data的节点
ListNode *DeleteNodeAllSame(ListNode *head,Datatype data)
{
	ListNode *p=head;
	while(p->next!=NULL)
	{
		if (p->next->data == data)
		{
			ListNode *tmp=p->next;
			p->next=tmp->next;
			free(tmp);
			tmp=NULL;
			continue;
		}
		p=p->next;
	}
	return NULL;
}


//判断空链表
bool IsEmpty(ListNode * head)
{
	return (head->next == NULL);
}

//清空链表
void ClearLinkNode(ListNode* head)
{
	if(head == NULL || IsEmpty(head))
	{
		return ;
	}
	while(head->next != NULL)
	{
		ListNode* dele = head->next;
		head->next = dele->next;
		free(dele);		
		dele->next = NULL;
		dele = NULL;
	}
}

//取出节点
ListNode* GetNode(ListNode* head, Datatype data)
{
	if(head == NULL || is_empty(head))
	{
		return NULL;
	}
	ListNode* p = head;
	while(p->next != NULL)
	{
		if (p->next->data == data)
		{
			ListNode* node = p->next;
			p->next = node->next;
			return node;
		}
		p = p->next;
	}
	return NULL;
}

//移动节点
void move_node(ListNode* head, Datatype data1, Datatype data2)
{
	//取出移动的节点data1
	ListNode* node1 = GetNode(head, data1);
	//找到data2的节点
	ListNode* node2 = FindNode(head, data2);
	//将data1插入到data2后面
	if (node1 == NULL || node2 == NULL)
	{
		return;
	}
	node1->next = node2->next;
	node2->next = node1;
}

void InsertNode_node(ListNode* node1,ListNode* node2)
{
	  //将node1插入到node2后面
	if (node1 == NULL || node2 == NULL)
  	{
  		return;
  	}
  	//相当于头插法，node2为头结点，node1为新节点
  	//node1->next = node2->next;
  	//node2->next = node1;
    InsertNodeHead(node2, node1);
}


int main(int argc, char const *argv[])
{
	int i,n=10;
	ListNode * head = InitNode();
	
	for(i=0;i<n;i++)
	{
		ListNode *new=NULL;
		if(i<=3||i>5)
				new = CreateNode(i);
		else
			new = CreateNode(4);
		// InsertNodeTail(head,new);	//尾插
		InsertNodeHead(head,new);		//头插
	}
	Display(head);

	int old_num,new_num,num;
	printf("search num :\n");
	scanf("%d",&num);
	ListNode *tmp = FindNode(head,num);
	if(tmp!=NULL)
	{
		printf("找到 %d\n",tmp->data);
	}
	else
	{
		printf("未找到!\n");
	}
	printf("delete num : ");
	scanf("%d",&num);
	if(DeleteNodeByDate(head,num));
	{
		printf("delete successfully\n");
	}
	DeleteNodeAllSame(head,num);
	Display(head);

	printf("update old_num : ");
	scanf("%d",&old_num);
	printf("update new_num : ");
	scanf("%d",&new_num);
	UpdateNode(head,old_num,new_num);
	Display(head);

	return 0;
}

list.h

#ifndef LIST_H_
#define LIST_H_

#include <stdlib.h>
#include <assert.h>


//链表必须为单向链表，链表结点必须包含next指针域
/*list 为链表头指针*/
#define List_Init(list, list_node_t) {					\
		list=(list_node_t*)malloc(sizeof(list_node_t)); \
		(list)->next=NULL;					\
	}

//list 为链表头指针，tmpPtr为链表结点临时指针变量
#define List_Free(list, list_node_t) {			\
		assert(NULL!=list);						\
		list_node_t *tmpPtr;					\
		while(NULL!=(tmpPtr=(list)->next)){ 	\
			(list)->next=tmpPtr->next;			\
			free(tmpPtr);						\
		}										\
	}

//list 为链表头指针，tmpPtr为链表结点临时指针变量
#define List_Destroy(list, list_node_t) {		\
		assert(NULL!=list);						\
		List_Free(list, list_node_t)			\
		free(list);								\
		(list)=NULL;							\
	}



//遍历链表
#define List_ForEach(list, curPos) 		\
	 for (   curPos = (list)->next;  	\
		  	  	  curPos != NULL;       \
		  	  	  curPos=curPos->next	\
	    )
	    
	    
	    
//链表头插法，list为头指针，new为新节点
#define List_AddHead(list, newNode) {			\
		(newNode)->next=(list)->next;		 	\
		(list)->next=newNode;				 	\
	}



//链表尾插法，list为头指针，curPos为循环变量 new为新节点
#define List_AddTail(list, curPos ,newNode) {			\
		for(curPos = (list); ;curPos=curPos->next){		\
			if((curPos)->next == NULL){					\
				(curPos)->next = (newNode);				\
				break;									\
			}											\
		}												\
	}

//将新节点newNode加入到node之前
#define List_InsertBefore(node, newNode) {		\
		(newNode)->prev=(node)->prev; 		 	\
		(node)->prev->next=newNode;			 	\
		(node)->prev=newNode;			 		\
		(newNode)->next=node;			 		\
	}

//将新节点newNode加入到node之后
#define List_InsertAfter(node, newNode) {		\
		(newNode)->next=node->next;			 	\
		(node)->next=newNode;				 	\
	}

//判断链表是否为空，list为头指针
#define List_IsEmpty(list)  (((list) != NULL)


//删除并释放链表结点node，
#define List_FreeNode(head ,node,list_node_t) {             		\
			assert(NULL!=node);								\
			if(node -> next != NULL){				        \
				list_node_t *temp = node->next;          	\
				memcpy(node,temp,sizeof(list_node_t)); 		\
				free(temp); 								\
			}else{                                          \
                list_node_t *temp = head;                   \
                while(temp -> next != node)                 \
                    temp = temp -> next;                    \
                temp -> next = NULL;                        \
				free(node);		                            \
                node = NULL;                                \
			}												\
	}

#endif
2.3单向循环链表

单向循环链表：

单向循环链表和普通的单向链表的操作逻辑几乎一样，唯一就是初始化和结尾判断有区别。

单向链表里面每一个节点的next都要有一个指向，单向循环，最后一个节点的next指向head节点

（1）初始化

//初始化链表（新建一个不带数据的头结点）
ListNode *init(void)
{
	ListNode *head = malloc(sizeof(ListNode));
	if (head != NULL)
	{
		head->next = head;
	}
	else
	{
		return NULL;
	}
	return head;
}

( 2 )、尾插法

//插入节点，尾插法
void insert_tail(ListNode *head, ListNode *new)
{
	if (head == NULL || new == NULL)
	{
		return ;
	}
	ListNode *p = head;//定义一个临时中间变量p，用来遍历链表，找到最后的节点，防止头结点地址发生改变
	while(p->next != head)
	{
		//一个一个往后找
		p = p->next;
	}
	//找到最后一个节点之后，将最后一个节点的next设置为new(新节点的地址)
	p->next = new;
	//将新的尾部节点 new的next指向 头结点
	new->next = head;
}
单向循环链表的应用 约瑟夫环问题

N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。

#include <stdio.h>
#include <stdlib.h>

typedef int Datatype;
typedef struct Node
{	
	Datatype data;
	struct Node *next;	
}ListNode;



ListNode * InitNode(Datatype data)	//带数据的头节点
{
	ListNode * head=(ListNode *)malloc(sizeof(ListNode));
	if(head != NULL){
		head->data = data;
		head->next = head;
	}else{
		return NULL;
	}
	return head;
}


//创建
ListNode * CreateNode(Datatype data)
{
	ListNode * new=(ListNode *)malloc(sizeof(ListNode));
	if (new!=NULL){
		new->next = NULL;
	}else{
		return NULL;
	}
	new->data = data;
	return new;
}


//尾插
void InsertNodeTail(ListNode *head,ListNode * new)
{
	ListNode *p=head;
	while(p->next!=head)
	{
		p=p->next;
	}
	p->next = new;
	new->next=head;
}


//头插
void InsertNodeHead(ListNode *head,ListNode *new)
{
	new->next = head->next;
	head->next=new;
}


void Display(ListNode *head)
{
	ListNode *p=head;
	printf("%d ",head->data);
	while(p->next!=head)
	{
		printf("%d  ",p->next->data);
		p=p->next;
	}
	printf("\n");
}

ListNode * DeleteNode(ListNode *head,ListNode *delNode)
{
	ListNode *p=head;
	while(p->next!=head)
	{
		if(p->next == delNode)
		{
			ListNode *tmp = p->next;
			p->next = tmp->next;
			free(tmp);
			tmp=NULL;
			return p->next;
		}
		p=p->next;
	}
	return NULL;
}



void ClearNode(ListNode *head)		//清空全部节点
{
	ListNode *p=head;
	if(head == NULL ||head->next ==NULL)
		return;

	while(p->next!=head)
	{
		ListNode *tmp = p->next;
		p->next = tmp->next;
		free(tmp);
		tmp->next=NULL;
		tmp=NULL;
	}
	free(head);
	head->next=NULL;
	head=NULL;
}

void GetSurvival(ListNode *head,int num,int pos)
{
	if(num == 0)
		return;
	if(num<pos)
	{
		Display(head);
		ClearNode(head);	//清空全部节点
		return;
	}
	ListNode *p=head;
	int flag=1;
	while(1)
	{
		ListNode *tmp=p;
		for(int i=1;i<pos-1;i++)	//移动节点
		{
			tmp=tmp->next;
		}
		//删除节点
		ListNode *delnode = tmp->next;
		printf("kill %d\n",delnode->data);
		tmp->next = delnode->next;
		free(delnode);
		delnode=NULL;
		// DeleteNode(p,tmp);
		p=tmp->next;
		--num;

		if(num == pos)
		{	
			for(int i=1;i<pos;i++)
			{
				if (flag)
				{
					printf("存活的人为：");
					flag=0;
				}
				printf("%d ",p->data);
				p=p->next;
			}
			printf("\n");
			ClearNode(p);	//清空全部节点
			return;
		}

	}

}

int main(int argc, char const *argv[])
{
	int num=11,pos;
	ListNode *head=NULL;

	while(1)
	{
		head = InitNode(1);
		printf("输入总人数:");
		scanf("%d",&num);
		printf("输入杀死第几个人：");
		scanf("%d",&pos);
		for(int i=2;i<=num;i++)
		{
			InsertNodeTail(head,CreateNode(i)); 
		}
		Display(head);
		GetSurvival(head,num,pos);
		if(num ==0)
			break;
		head=NULL;
	}

	return 0;
}
2.4双向循环链表

双向循环链表节点

在这里插入图片描述

节点结构体声明

typedef int Datatype;
//双向循环链表节点
typedef struct Node
{
	Datatype data;//数据域
	struct Node *prev;//前驱指针		//指针域
	struct Node *next;//后继指针
}LinkNode;

初始化

//初始化空链表
LinkNode * Init()
{
	LinkNode * head = (LinkNode *)malloc(sizeof(LinkNode));
	if(head!=NULL)
	{
		head->prev=head;
		head->next=head;
	}
	return head;
}

新建节点

//新建节点
LinkNode * CreateNode(Datatype data)
{
	LinkNode * tmp = (LinkNode *)malloc(sizeof(LinkNode));
	if(tmp == NULL)
		return NULL;
	tmp->data = data;
	tmp->prev=NULL;
	tmp->next=NULL;
	return tmp;
}

插入节点

尾插法

插入是放在尾部节点的后面，那么就相当于等于插入到头结点的前面

在这里插入图片描述

//插入节点，尾插法
void InsertNodeTail(LinkNode *head,LinkNode *newNode)
{
	LinkNode *tail = head->prev;

	newNode->prev = tail;
	newNode->next=head;
	head->prev=newNode;
	tail->next=newNode;
	return head;
}

头插法

//头插法
 void InsertNodeHead(LinkNode *head,LinkNode *newNode)
{
	LinkNode *first = head->next;

	newNode->prev=head;	//防止链表的链式关系断开
	newNode->next=first;
	first->prev=newNode;
	head->next=newNode;
	return head;
}

遍历链表

//遍历从前往后
void DisplayNegative(LinkNode *head)
{
	LinkNode *p=head;
	while(p->prev!=head)
	{
		p=p->prev;
		printf("%d ",p->data);
	}
	printf("\n");
}

//遍历从后往前
void DisplayPositive(LinkNode *head)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		p=p->next;
		printf("%d ",p->data);
	}
	printf("\n");
}

查找节点

LinkNode *FindNode(LinkNode *head,Datatype data)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		p=p->next;
		if(p->next==data)
		{
			return p;
		}
	}
	return NULL;
}

更新节点

//更新节点
void UpdateNode(LinkNode *head,Datatype old_data,Datatype new_data)
{
	LinkNode *p=FindNode(head,old_data);
	if(p!=NULL)
	{
		p->data=new_data;
		printf("修改成功\n");
	}
	else
	{
		printf("没有这个节点");
	}
}

删除节点

//删除节点
int DeleteNode(LinkNode *head,Datatype data)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		if(p->next->data==data)
		{
			LinkNode *tmp=p->next;
			p->next=tmp->next;
			tmp->next->prev=p;
			free(tmp);
			tmp->next=NULL;
			tmp->prev=NULL;
			tmp=NULL;
			return 1;
		}
		p=p->next;
	}
	return 0;
}

//判断空链表

//判断空链表
bool IsEmpty(LinkNode* head)
{
	return (head->next == head && head->prev == head);
}

//清空链表

//清空链表
void ClearLinkNode(LinkNode* head)
{
	if(head == NULL || IsEmpty(head))
	{
		return ;
	}
	while(head->next != head)
	{
		LinkNode tmp = head->next;
		head->next = tmp->next;
		tmp->next->prev = head;
		free(tmp);
		tmp->next = tmp->prev = NULL;
		tmp = NULL;
	}
}
双向循环链表 完整代码
#include <stdio.h>
#include <stdlib.h>

typedef int Datatype;

typedef struct Node
{
	Datatype data;
	struct Node *prev;
	struct Node *next;
}LinkNode;

//初始化
LinkNode * Init()
{
	LinkNode * head = (LinkNode *)malloc(sizeof(LinkNode));
	if(head!=NULL)
	{
		head->prev=head;
		head->next=head;
	}
	return head;
}

//创建节点
LinkNode * CreateNode(Datatype data)
{
	LinkNode * tmp = (LinkNode *)malloc(sizeof(LinkNode));
	tmp->data = data;
	tmp->prev=NULL;
	tmp->next=NULL;
	return tmp;
}

//尾插法
LinkNode * InsertNodeTail(LinkNode *head,LinkNode *newNode)
{
	LinkNode *tail = head->prev;

	newNode->prev = tail;
	newNode->next=head;
	head->prev=newNode;
	tail->next=newNode;
	return head;
}

//头插法
LinkNode *InsertNodeHead(LinkNode *head,LinkNode *newNode)
{
	LinkNode *first = head->next;

	newNode->prev=head;	//防止链表的链式关系断开
	newNode->next=first;
	first->prev=newNode;
	head->next=newNode;
	return head;
}

//逆序遍历
void DisplayNegative(LinkNode *head)
{
	LinkNode *p=head;
	while(p->prev!=head)
	{
		p=p->prev;
		printf("%d ",p->data);
	}
	printf("\n");
}

//正序遍历
void DisplayPositive(LinkNode *head)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		p=p->next;
		printf("%d ",p->data);
	}
	printf("\n");
}

//查找节点
LinkNode *FindNode(LinkNode *head,Datatype data)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		p=p->next;
		if(p->next==data)
		{
			return p;
		}
	}
	return NULL;
}

//更新节点
void UpdateNode(LinkNode *head,Datatype old_data,Datatype new_data)
{
	LinkNode *p=FindNode(head,old_data);
	if(p!=NULL)
	{
		p->data=new_data;
		printf("修改成功\n");
	}
	else
	{
		printf("没有这个节点");
	}
}


//删除节点
int DeleteNode(LinkNode *head,Datatype data)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		if(p->next->data==data)
		{
			LinkNode *tmp=p->next;
			p->next=tmp->next;
			tmp->next->prev=p;
			free(tmp);
			tmp->next=NULL;
			tmp->prev=NULL;
			tmp=NULL;
			return 1;
		}
		p=p->next;
	}
	return 0;
}

//判断空链表
bool IsEmpty(LinkNode* head)
{
	return (head->next == head && head->prev == head);
}

//清空链表
void ClearLinkNode(LinkNode* head)
{
	if(head == NULL || IsEmpty(head))
	{
		return ;
	}
	while(head->next != head)
	{
		LinkNode tmp = head->next;
		head->next = tmp->next;
		tmp->next->prev = head;
		free(tmp);
		tmp->next = tmp->prev = NULL;
		tmp = NULL;
	}
}
//从小到大插入
int InsertNodeOrder(LinkNode *head,LinkNode *newNode)
{
	LinkNode *p=head;
	while(p->next!=head)
	{
		if(p->next->data.price > newNode->data.price)
		{
			//头插
			InsertNodeHead(p,newNode);
			return 1;
		}
		p=p->next;
	}
	
	//尾插入
	return (InsertNodeTail(head,newNode));

}

int main(int argc, char const *argv[])
{
	int num=10;
	LinkNode *head = Init();
	for(int i=1;i<=num;i++)
	{
		// InsertNodeTail(head,CreateNode(i));
		InsertNodeHead(head,CreateNode(i));
	}	
	DisplayNegative(head);
	DisplayPositive(head);
	return 0;
}
Yengi
关注
  • 5
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaScript数据结构之双向链表和双向循环链表的实现
01-19
双向链表和普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个链向下一个元素，另一个链向前一个元素。 双向链表提供了两种迭代列表的方法：从头到尾，或者反过来。我们也可以访问一个特定节点的下一个或前一个元素。在单向链表中，如果迭代列表时错过了要找的元素，就需要回到列表起点，重新开始迭代。这是双向链表的一个优点。 双向链表：单向链表只能向着一个方向遍历链表节点，而在节点指针域中增加了前向指针的双向链表，则可以向着两个方向遍历节点。这使得双向链表也可以在任何一个节点遍历整个链表。 function DoublyLinkedList() { v
实现单链表的基本操作（c语言）
qq_63152286的博客
02-18 5161
链表介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 一、实现单链表的具体操作 定义链表元素 创建单链表：①头插法 ②尾插法 按位序插入结点 按位序删除结点 按位查找结点 销毁顺序表 打印链表
python判断单向链表是否包括环，若包含则计算环入口的节点实例分析
09-18
主要介绍了python判断单向链表是否包括环，若包含则计算环入口的节点,结合实例形式分析了Python针对单向链表的遍历、判断相关算法原理与使用技巧,需要的朋友可以参考下
python数据结构链表之单向链表(实例讲解)
01-21
单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体的数据。 链接域next用来存放下一个节点的位置（python中的标识） 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 节点实现 class Node(object): 单链表的结点 def __init__(self,item): # item存放数据元素 self.item = item # next是下一个节点的标识
双链表中插入节点（C语言实现）
zsx0728的博客
07-15 8338
文章目录1. 相关背景介绍1.1 双链表概念1.2 双链表的优势与劣势1.3 双链表插入节点的位置2. 不同位置插入数据2.1 在DLL的前端添加节点2.2 在给定节点之前添加节点2.3 在DLL的末尾添加节点2.4 在给定节点之后添加节点3. 综合示例参考文献 1. 相关背景介绍 1.1 双链表概念     相比SLL（singly linked list，单链表），DLL（Doubly Linked List，双链表）多了一个名为 previous pointer （Prev）的指针，该指针指向前一节点
数据结构—单向链表（详解）
热门推荐
梅山
03-16 1万+
基于C语言的链表基础，包括概念，链表的初始化，插入，删除，查找等操作。
数据结构与算法---单向链表
weixin_73602725的博客
03-01 1213
单向链表的详细讲解（附完整版）
单向链表SingleLinkedList
weixin_66598341的博客
09-09 973
本文案例仅仅使用Java语言实现单向链表的一些简单的增删改查，完成反转单向链表，以及借助栈逆序遍历单向链表等功能。
数据结构之单向链表
yjhqukq的博客
10-28 1770
单向链表中的每个结点都有一个数据域、一个指针域。数据域用来存储结点的数据，指针域用来存储下一个结点所在的内存空间地址。这里完成了单向链表的五个基本功能，初始化、头插法、尾插法、删除结点、遍历链表。
链表-----单向链表详解
weixin_51134816的博客
05-04 1056
玩单链表的时候一定要注意区分头指针和头结点，在链表的初阶学习时，老师可能会对第一个结点直接取地址传过去，在无头单链表中，头指针和第一个结点重名，这就导致了当时学链表的时候很疑惑为啥一会儿传第一个结点的地址，一会儿传第一个结点的地址的地址。菜就多练！
Python实现针对给定单链表删除指定节点的方法
09-20
主要介绍了Python实现针对给定单链表删除指定节点的方法,结合实例形式分析了Python单链表的定义、节点添加、删除、打印等相关操作技巧,需要的朋友可以参考下
C语言实现输出链表中倒数第k个节点
09-04
主要介绍了C语言实现输出链表中倒数第k个节点,主要涉及链表的遍历操作,是数据结构中链表的常见操作。需要的朋友可以参考下
单链表基本操作的实现--创建、插入、查找、删除
haikuotiankong7的博客
11-22 5045
单链表基本操作的实现--创建、插入、查找、删除 其中，查找和删除分为 按值查找删除和按序号查找删除； 附上代码（具体的代码实现见注释解析） linkedlist.h(链表的头文件) #pragma once #include class Node { public: int data; Node* next; }; class LinkedList { privat
单向链表的7种基本操作（创建、插入、查找、删除、排序(交换节点)、排序(交换数据)、销毁）代码实现（附详细注释）
weixin_A13253323604
09-06 530
代码实现如下： #include "list.h" #include <stdio.h> #include <stdlib.h> typedef struct _node /*定义一个节点，节点包含两部分，数据域和指针域*/ { int data; /*数据域*/ struct _node * next; /*指针域*/ /*next指向下一个节点的位置*/ }Node; /*创建链表*/ /*带有头结点的链表（带
链表入门：“单链表“的基本操作详解(C语言)
Mzyh的博客
10-15 2387
使用C语言编写代码，实现数据结构中单链表的各种操作，动画演示，详细分析代码。
找出链表中间结点的三种解法
xiaoyubuhuiqiche的博客
12-03 4064
该篇文章详细的介绍了如何用三种方法查找链表的中间结点
四、数据结构——单向链表的基本操作详解：创建、插入（头插法、尾插法、任意点插法）、删除（头删法、尾删法、任意位置删法）、查询（按值查下标、按下标查值）、遍历链表和清空链表
qq_57737603的博客
06-14 1829
单向链表是一种线性数据结构，由一系列节点组成。每个节点包含两个部分：数据和指向下一个节点的引用（也称为指针）。节点之间通过这个引用连接在一起，形成链表结构。最后一个节点的引用指向空值，表示链表的结束。
一文教会你单向链表
fq157856469的博客
07-30 1058
链表是是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。比较通俗易懂的说法就是，在计算机内存中开辟了一个个空间，然后通过地址的方式将它们链接在一起，并通过地址的方式进行访问。在手动创建链表之前，我们要先对链表进行定义，对链表的定义，接口函数的引用和头文件的引用最好放在一个头文件中这样在要使用创建的接口时便只需要引用一个头文件即可，而接口函数的实现你也可以放在一个.c文件中，最后在另一个.c文件中引用函数测试即可，如图：//链表博客版.h。
【Java--数据结构】模拟实现ArrayList
最新发布
2301_80898480的博客
04-23 626
/定义顺序表，实现IList 接口//定义要操作的数组//数组中存储的数据个数//表示数组长度是10。
链表中的数据结构基础，链表构成，链表的建立，清空，初始化，遍历，节点查找，插入，删除的应用
06-11
链表是一种常见的线性数据结构，由一系列节点组成。每个节点包含数据和指向下一个节点的指针。链表有单向链表、双向链表等多种类型。 链表的建立通常有两种方式，一种是头插法，另一种是尾插法。头插法是将新节点插入链表头部，尾插法是将新节点插入到链表尾部。链表的初始化和清空操作可以通过定义头节点来实现。 链表的遍历是指将链表中的所有元素依次访问一遍。遍历链表可以通过遍历指针，依次访问每个节点的数据来实现。 节点查找操作可以通过遍历链表，比较节点的数据是否符合要求来实现。插入操作可以在需要插入的位置处新建一个节点，并修改指针指向。删除操作可以将需要删除的节点的前一个节点的指针指向需要删除的节点的后一个节点，从而将需要删除的节点从链表中删除。 链表的应用非常广泛，常见的应用包括实现栈、队列等数据结构，以及实现各种算法和编程题目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yengi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值