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

已于 2023-05-06 14:03:27 修改
阅读量2.3k 收藏 31
点赞数 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;
}
数据结构链表的操作
TY113322的博客
03-16 1445
一.链表 1.单链表逆置 解题思路： 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。 同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转 当递归函数全部出栈后，链表反转完成。 递归实现版: 非递归实现版本解题思路： 定义两个指针： pre 和 cur ；pre 在前 cur 在后。 每次让 pre 的 next 指向 cur ，实现一次局部反转 局部反转
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3296
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
「C语言」单链表/双向链表的建立/遍历/插入/删除
weixin_30724853的博客
06-17 395
最近临近期末的C语言课程设计比平时练习作业一下难了不止一个档次，第一次接触到了C语言的框架开发，了解了View（界面层）、Service（业务逻辑层）、Persistence（持久化层）的分离和耦合，一种面向过程的MVC的感觉。 而这一切的基础就在于对链表的创建、删除、输出、写入文件、从文件读出...... 本篇文章在于巩固链表的基础知识（整理自《C语言程序设计教程--...
【基础算法总结】链表篇
最新发布
2301_77900444的博客
10-04 2438
有关链表的算法题也是一类常见并且经典的题型，这些题要使用数据结构中我们手搓的链表结构，也要使用STL中的 list 容器。下面是几点常用操作的总结(1)善于画图。(2)引入虚拟头结点。方便处理边界情况，就是当没节点第一次头插或尾插的时候的那个判断，引入虚拟头结点就可以避免这个判断(写成 ptail = newHead)。(3) 不要吝啬空间，大胆定义变量。(4)快慢双指针的使用。主要应用是判环，找链表中环的入口，找链表中倒数第 n 个节点。(5)
一步一步写算法（之单向链表）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
10-07 12万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一
数据结构 链表操作
爱学习的小强
01-01 159
【数据结构-链表】链表的基本操作
Mount256的博客
10-26 2581
【数据结构-链表】链表的基本操作
JavaScript数据结构之单链表和循环链表
10-18
我们可以看到一些关于单链表的基本方法实现，如append()方法用于向链表尾部添加新的节点，insert()方法用于在链表的指定位置插入新节点，removeAt()方法用于删除指定位置的节点，以及indexOf()用于查找节点的位置等...
JavaScript数据结构之双向链表和双向循环链表的实现
01-19
双向链表：单向链表只能向着一个方向遍历链表节点，而在节点指针域中增加了前向指针的双向链表，则可以向着两个方向遍历节点。这使得双向链表也可以在任何一个节点遍历整个链表。 function DoublyLinkedList() { ...
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8589
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
orm 通过外链表查找数据_码哥聊Python数据结构--链表
weixin_39889487的博客
11-23 126
前几天我们开了个数据结构的坑，说了栈，留言里有同学提到链表，那今天码哥就来讲讲链表。链表是什么链表、列表，说起来有点相似，作用也有点类似，但可别傻傻分不清楚。我们一般说的列表，是一个连续的序列，用来存储一组数据。而链表，虽然也是有序的存储结构，但它不限定要“连续”的。打个比方：列表就好像火车，每一节车厢连在一起，如果你知道车头在哪里，大致就也能知道第8节车厢在哪。而链表，就像是去往同个目的地的车队...
单向链表
Zllvincent的博客
05-21 413
一.简介 计算机对数据存储有顺序存储、链式存储。数组是一种顺序存储的体现，链表是链式存储的体现，很多高级数据结构都是基于链表实现。 单向链表：数据元素通过一个指针指向下一个数据元素 二.实现 package com.vincent; public class Main { public static void main(String[] args) throws Exception{ LinkedList<Integer> list = new LinkedList
Python数据结构与算法系列三：链表
weixin_46964639的博客
10-19 688
链表的定义1. 链表定义1.1 链表的优点2. 单向链表2.1 节点实现2.2 单链表的操作2.3 单链表的实现2.3.1 头部添加元素2.3.2 尾部添加元素2.3.3 指定位置添加元素2.3.4 删除节点2.3.5 查找节点是否存在2.3.6 测试2.4 单向链表和顺序表的比较 1. 链表定义 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 1.1 链表的优点 顺序表的构
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Yengi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值