单链表

最新推荐文章于 2023-05-06 22:43:40 发布
最新推荐文章于 2023-05-06 22:43:40 发布
阅读量505 收藏 1
点赞数 1
分类专栏： 算法 C语言基础 百味人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangxt211/article/details/33725041
版权

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存放到下一个节点的指针(Pointer)。使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

链表有很多种不同的类型：单向链表，双向链表以及循环链表。

本章主要讲解单向链表

1、插入

其实现的过程考虑边界情况：
1）当L为空；
2）在链表的头部插入；
3）在链表的中间插入（包括在链表尾部插入的情况）。

2、删除

删除和插入是一个相反的过程，一般需要先找到删除结点的前驱（prev）。
1）当L为空；
2）删除链表的首结点；
3）删除链表的中间结点（包括删除链表尾结点的情况）。 

链表形态

操作过程

 

// sll.h
#ifndef _MY_SSL_H
#define _MY_SSL_H

/* singly linked list */
typedef struct singly_linked_list_node {
	struct singly_linked_list_node *next;
} SSL_NODE;

typedef struct singly_linked_list {
	SSL_NODE *first;
	SSL_NODE *last;
} SSL_LIST;

void list_init(SSL_LIST *list);

void list_insert_head(SSL_LIST *list, SSL_NODE *node);

void list_insert_tail(SSL_LIST *list, SSL_NODE *node);

void list_insert_after(SSL_LIST *list, SSL_NODE *pos, SSL_NODE *node);

void list_delete_head(SSL_LIST *list);

void list_delete(SSL_LIST *list, SSL_NODE *node);

int list_get_num(SSL_LIST *list);

#endif

// sll.c
#include <stdlib.h>
#include "sll.h"

void list_init(SSL_LIST *list)
{
	list->first = NULL;
	list->last = NULL;
}

void list_insert_head(SSL_LIST *list, SSL_NODE *node)
{
	if (node == NULL) {
		return;
	}

	node->next = list->first;
	list->first = node;

	if (list->last == NULL) {
		list->last = node;
	}
}

void list_insert_tail(SSL_LIST *list, SSL_NODE *node)
{
	if (node == NULL) {
		return;
	}

	if (list->last != NULL) {
		list->last->next = node;
	} else {
		list->first = node;
	}

	list->last = node;
}

void list_insert_after(SSL_LIST *list, SSL_NODE *prev, SSL_NODE *node)
{
	if (prev == NULL || node == NULL) {
		return;
	}

	node->next = prev->next;
	prev->next = node;

	if (list->last == prev) {
		list->last = node;
	}
}

void list_delete_head(SSL_LIST *list)
{
	SSL_NODE *head = list->first;

	if (list->first != NULL) {
		list->first = head->next;
		head->next = NULL;

		if (list->first == NULL) {
			list->last = NULL;
		}
	}
}

SSL_NODE *list_find_prev(SSL_LIST *list, SSL_NODE *node)
{
	SSL_NODE *iter = NULL;

	/* 前驱不存在 */
	if ((list->first == NULL) || (list->first == node)) {
		return NULL;
	}

	iter = list->first; /* iter不为NULL */
	while (iter->next != NULL) {
		if (iter->next == node) {
			break;
		}

		iter = iter->next;
	}

	return iter;
}

void list_delete(SSL_LIST *list, SSL_NODE *node)
{
	SSL_NODE *prev = NULL;

	if (node == NULL) {
		return NULL;
	}

	prev = list_find_prev(list, node);
	if (prev == NULL) { 
		if (list->first == node) { /* first node */
			list->first = node->next;
			node->next = NULL;
		}
	} else {
		prev->next = node->next;
		node->next = NULL;
	}

	if (list->last == node) { /* last node */
		list->last = prev;
	}
}

void list_delete2(SSL_LIST *list, SSL_NODE *node)
{
	SSL_NODE *prev = NULL;

	if ((list->first == NULL) || (node == NULL)) {
		return NULL;
	}

	if (list->first == node) {	/* first node */
		list->first = node->next;
		node->next = NULL;

		if (list->last == node) { /* last node */
			list->last = NULL;
		}
	} else {
		prev = list->first;
		while (prev->next != NULL) {
			if (prev->next == node) {
				prev->next = node->next;
				node->next = NULL;

				if (list->last == node) {
					list->last = prev;
				}

				break;
			}

			prev = prev->next;
		}
	}
}

int list_get_num(SSL_LIST *list)
{
	int num = 0;
	SSL_NODE *iter = list->first;

	while (iter != NULL) {
		num++;
		iter = iter->next;
	}

	return num;
}


#pragma once

#ifndef _MY_SSL2_H
#define _MY_SSL2_H

/* singly linked list */
typedef struct sll_node {
	struct sll_node *next;
} SLL_NODE;

#define SLL_LIST SLL_NODE

void list_init(SLL_LIST *list);

void list_insert_head(SLL_LIST *list, SLL_NODE *node);

void list_insert_after(SLL_LIST *list, SLL_NODE *prev, SLL_NODE *node);

void list_delete_head(SLL_LIST *list);

void list_delete(SLL_LIST *list, SLL_NODE *node);

void list_delete2(SLL_LIST *list, SLL_NODE *node);

int list_get_num(SLL_LIST *list);

#endif

#if 1

#include <stdlib.h>
#include "sll4.h"

#if 0
/* singly linked list */
typedef struct sll_node {
	struct sll_node *next;
} SLL_LIST;

#define SLL_LIST SLL_NODE
#endif

/*
参数：SLL_LIST *list
返回值：void
作用：初始化链表
*/
void list_init(SLL_LIST *list)
{
	if (list == NULL) {
		return;  
	}

	list->next = NULL;
}

/*
参数：SLL_LIST *list, SLL_NODE *node
返回值：SLL_NODE *
作用：找到node节点的前驱
*/
SLL_NODE *list_find_prev(SLL_LIST *list, SLL_NODE *node)
{
	SLL_NODE *prev = NULL;

	if ((list == NULL) || (node == NULL)) {
		return NULL;
	}

	prev = list;
	while (prev->next != NULL) {
		if (prev->next == node) {
			break;
		}

		prev = prev->next;
	}

	return prev;
}

/*
参数：SLL_LIST *list, SLL_NODE *node
返回值：void
作用：在链表头部插入node节点
*/
void list_insert_head(SLL_LIST *list, SLL_NODE *node)
{
	if ((list == NULL) || (node == NULL)) {
		return;
	}

	node->next = list->next;
	list->next = node;
}

/*
参数：SLL_LIST *list, SLL_NODE *pos, SLL_NODE *node
返回值：void
作用：在pos节点后面插入node节点
*/
void list_insert_after(SLL_LIST *list, SLL_NODE *prev, SLL_NODE *node)
{
	if ((pos == NULL) || (node == NULL)) {
		return;
	}

	node->next = prev->next;
	prev->next = node;
}

/*
参数：SLL_LIST *list
返回值：void
作用：删除链表头节点
*/
void list_delete_head(SLL_LIST *list)
{
	SLL_NODE *head = NULL;

	if (list == NULL) {
		return;
	}

	head = list->next;
	if (head != NULL) {
		list->next = head->next;
		head->next = NULL;
	}
}

/*
参数：SLL_LIST *list, SLL_NODE *node
返回值：void
作用：删除node节点
*/
void list_delete(SLL_LIST *list, SLL_NODE *node) 
{
	SLL_NODE *prev = NULL;

	if ((list == NULL) || (node == NULL)) {
		return ;
	}

	prev = list;
	while (prev->next != NULL) {
		if (prev->next == node) {
			prev->next = node->next;
			node->next = NULL;
			break;
		}

		prev = prev->next;
	}
}

/*
参数：SLL_LIST *list, SLL_NODE *node
返回值：void
作用：删除node节点
*/
void list_delete2(SLL_LIST *list, SLL_NODE *node)
{
	SLL_NODE *prev = NULL;

	if ((list == NULL) || (node == NULL)) {
		return ;
	}

	prev = list_find_prev(list, node);
	if (prev != NULL) {
		prev->next = node->next;
		node->next = NULL;
	}
}

/*
参数：SLL_LIST *list
返回值：void
作用：初始化链表
*/
int list_get_num(SLL_LIST *list)
{
	int num = 0;
	SLL_NODE *iter = NULL;

	if (list == NULL) {
		return 0;
	}

	iter = list->next;
	while (iter != NULL) {
		num++;
		iter = iter->next;
	}

	return num;
}

#endif
#if 1

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

#include "sll4.h"

typedef struct life {
	SLL_NODE node;
	int work;
	int study;
	int play;
} LIFE;

typedef struct all_life {
	SLL_LIST list;
} ALL_LIFE;


void slist_print(ALL_LIFE *all_life)
{
	SLL_NODE *iter = all_life->list.next;
	LIFE *pLIFE = NULL;
	int index = 0;

	while (iter != NULL) {
		pLIFE = (LIFE *)iter;
		printf("%2d: work: %d, study: %d, play: %d\n",
			++index, pLIFE->work, pLIFE->study, pLIFE->play);

		iter = iter->next;
	}

	printf("\n");
}


int main()
{
	int i = 0;
	int arr[] = { 123, 4, 3, 34, 35, 7, 8, 9, 5, 4, 2, 1 };
	int len = sizeof(arr) / sizeof(arr[0]);
	struct all_life real_life = { 0 };
	struct life *my_life = NULL;

	for (i = 0; i < len; i++) {
		my_life = (struct life *)malloc(sizeof(struct life));
		if (my_life == NULL) {
			printf("malloc error!\n");
			return 1;
		}

		my_life->node.next = NULL;
		my_life->work = arr[i];
		my_life->study = arr[i] + 1;
		my_life->play = arr[i] + 2;

		list_insert_head(&(real_life.list), &(my_life->node));
	}

	slist_print(&real_life);

	for (i = 0; i < len; i++) {
		my_life = (LIFE *)GET_LIST_HEAD(real_life.list);
		list_delete2(&(real_life.list), &(my_life->node));
		free(my_life);
		my_life = NULL;
		slist_print(&real_life);
	}

	getchar();

	return 0;
}

#endif

使用二级指针进行链表的删除操作，将各种情况归一化，可以简化代码，但理解起来有难度。（保存next的地址）


#ifndef _MY_LIST3_H
#define _MY_LIST3_H

typedef struct notify_node {
	struct notify_node *next;
	int key;
} NOTIFY_NODE;

typedef struct notify_list {
	struct notify_node *head;
} NOTIFY_LIST;

void ListInsert(NOTIFY_LIST *list, NOTIFY_NODE *node);

void ListDelete(NOTIFY_LIST *list, NOTIFY_NODE *node);

NOTIFY_NODE *ListFindNode(NOTIFY_LIST *list, int key);

void ListMerge(NOTIFY_LIST *list1, NOTIFY_LIST *list2, NOTIFY_LIST *list);

#endif 

#include <stdlib.h>
#include "sll3.h"


/*
参数：NOTIFY_LIST *list, NOTIFY_NODE *node
返回值：void
作用：插入node节点
*/
void ListInsert(NOTIFY_LIST *list, NOTIFY_NODE *node)
{
	NOTIFY_NODE **iter = NULL;

	if (list == NULL || node == NULL) {
		return;
	}

	iter = &(list->head);
	while ((*iter) != NULL) {
		if ((*iter)->key > node->key) {
			break;
		}

		iter = &((*iter)->next);
	}

	node->next = (*iter);
	(*iter) = node;
}

/*
参数：NOTIFY_LIST *list, NOTIFY_NODE *node
返回值：void
作用：删除node节点
*/
void ListDelete(NOTIFY_LIST *list, NOTIFY_NODE *node)
{
	NOTIFY_NODE **iter = NULL;

	if (list == NULL || node == NULL) {
		return;
	}

	iter = &(list->head);
	while ((*iter) != NULL) {
		if ((*iter) == node) {
			(*iter) = node->next;
			node->next = NULL;
			break;
		}

		iter = &((*iter)->next);
	}
}

/*
参数：NOTIFY_LIST *list, int key
返回值：NOTIFY_NODE *
作用：通过key查找节点
*/
NOTIFY_NODE *ListFindNode(NOTIFY_LIST *list, int key)
{
	NOTIFY_NODE *iter = list->head;

	while (iter != NULL) {
		if (iter->key == key) {
			break;
		}

		iter = iter->next;
	}

	return iter;
}

/*
参数：NOTIFY_LIST *list1, NOTIFY_LIST *list2, NOTIFY_LIST *list
返回值：void
作用：合并链表
*/
void ListMerge(NOTIFY_LIST *list1, NOTIFY_LIST *list2, NOTIFY_LIST *list)
{
	NOTIFY_NODE **iter = &(list->head);
	NOTIFY_NODE *iter1 = list1->head;
	NOTIFY_NODE *iter2 = list2->head;

	while (iter1 != NULL && iter2 != NULL) {
		if (iter1->key < iter2->key) {
			(*iter) = iter1;
			iter1 = iter1->next;
		} else {
			(*iter) = iter2;
			iter2 = iter2->next;
		}
		iter = &((*iter)->next);
	}

	if (iter1 != NULL) {
		(*iter) = iter1;
	}

	if (iter2 != NULL) {
		(*iter) = iter2;
	}
}


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

#include "sll3.h"


typedef struct life {
	NOTIFY_NODE node;
	int work;
	int study;
	int play;
} LIFT;

typedef struct all_life {
	NOTIFY_LIST list;
} ALL_LIFT;


void slist_print(ALL_LIFT *list)
{
	NOTIFY_NODE *iter = list->list.head;
	LIFT *plift = NULL;
	int index = 0;

	while (iter != NULL) {
		plift = (LIFT *)iter;
		printf("%2d: work: %d, study: %d, play: %d\n",
			++index, plift->work, plift->study, plift->play);

		iter = iter->next;
	}

	printf("\n");
}

LIFT *slist_find(ALL_LIFT *list, int key)
{
	NOTIFY_NODE *iter = NULL;

	iter = ListFindNode(&(list->list), key);

	return (LIFT *)iter;
}


int main()
{
	int i = 0;
	int arr[] = { 123, 4, 3, 34, 35, 7, 8, 9, 5, 4, 2, 1 };
	int len = sizeof(arr) / sizeof(arr[0]);
	struct all_life real_life = { 0 };
	struct life *my_life = NULL;

	for (i = 0; i < len; i++) {
		my_life = (struct life *)malloc(sizeof(struct life));
		if (my_life == NULL) {
			printf("malloc error!\n");
			return 1;
		}

		my_life->node.key = arr[i];
		my_life->node.next = NULL;
		my_life->work = arr[i];
		my_life->study = arr[i] + 1;
		my_life->play = arr[i] + 2;

		ListInsert(&(real_life.list), &(my_life->node));
	}

	slist_print(&real_life);

	for (i = 0; i < len; i++) {
		my_life = slist_find(&real_life, arr[i]);
		ListDelete(&(real_life.list), &(my_life->node));
		free(my_life);
		my_life = NULL;
		slist_print(&real_life);
	}

	getchar();

	return 0;
}

 

 

 

 

 

 

 

 



jiangxt211
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表插入
兔子王
09-23 853
【问题描述】 设有头结点单链表，实现单链表插入算法。 【输入形式】 第一行输入一个N（N大于等于1，小于1000）； 第二行输入N个整数，以空格作为分隔，创建长度为N的单链表； 第三行输入pos和e，以空格分隔，分别表示插入位置和插入元素的值。 【输出形式】 若插入成功，输出插入元素后的单链表；若插入不成功，输出error。
【1】4. 单链表的两种查找方式
JJL的博客
07-27 3485
只探讨：带头结点的情况 查找分为 按位查找 =>GetElem(L,i) 获取表中第i个位置元素的值。 按值查找 =>LocateElem(L,e) 在表中查找具有给定关键值的元素。 按位查找 思路： 明确函数返回值类型，代码实质在于定位到第i个结点，而定位操作在单链表按位序增加或者删除都已经实践过! 分析（边界情况）： 当 i=0 时，这里将头结点视为了第0个结点。此时执行会跳过while循环，直接执行return p，即返回头结点。 ...
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
建立单链表
Dream_begin_的博客
01-11 4868
链表是动态地进行存储分配的一种结构，链表中的数据在内存中不必连续存放，数据之间通过指针链接起来，相比于数组结构，链表的插入和删除操作比较方便。单链表的建立链表：通过自引用结构的指针域，将各结点相互连接。关于链表的基本概念： (1)链表的第一个结点称头指针或头结点，它指向链表在内存中的首地址， (2)其后的结点是通过结点中的链节指针成员访问的。 (3)链表的最后一个结点称为尾节点。尾节点的指针域通常被设置成NULL。 (4)链表中的每一个结点是在需要的时候建立的。 (5)各结点在内存中的存储地址不一
C语言单链表
最新发布
knighthood2001
05-06 1514
int data;} Node;这里我们使用typedef将struct Node命名为Node。当然很多书以及代码中会使用到如下的int data;这里它还定义了一个指向这个结点的指针，当然对于初学者（笔者也是初学者）来说。使用*LinkList后，不太好理解，这里笔者就使用上述Node的版本。
单链表简单实现
南猿北者博客
10-31 2154
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
C++单链表逆序
m0_51380378的博客
07-12 976
牛客网真题：单链表的逆序 C++的单链表逆序： 创建3个指针，分别指向当前头节点位置，空空。 先将一个指针指向头节点的下一个节点，下一个节点为当前节点的下一个节点，当前节点的下一个节点为前一个节点，前一个结点为当前节点，当前节点为下一个节点。 struct ListNode* ReverseList(struct ListNode* pHead ) { // write code here struct ListNode *pre = NULL; struct Li
关于单链表
CSDN_YJX的博客
04-07 118
基础知识：什么是单链表，链式存储结构详解 单链表 基础操作：单链表的基本操作（C语言版） 最后附加一篇大佬的文章 【C语言】链表及单链表基本操作
C++单链表
weixin_62313265的博客
12-13 5107
链表是一种常见的数据结构。它主要是利用动态内存分配、结合结构体并配合指针来实现的，能根据需要开辟和释放内存单元。
单链表代码
02-01
单链表是一种基础的数据结构，它在计算机科学和编程中有着广泛的应用。在这个"单链表代码"压缩包中，我们可以找到用C语言实现的单链表操作的示例代码，这些代码通常会涵盖单链表的基本操作，如创建、插入、删除节点...
单链表逆序
03-04
单链表逆序是数据结构领域中的一个常见操作，它涉及到对链表节点顺序的反转。在本场景中，我们将详细探讨如何实现这个过程，包括单链表的基本概念、逆序算法的步骤以及如何在实际编程中应用这些概念。 首先，我们...
单链表的实现
04-21
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色。单链表由一系列节点组成，每个节点包含两部分：数据元素和一个指向下一个节点的指针。这种数据结构允许快速的插入和删除操作，但随机访问的效率较低...
硬连接（hard link）和软连接（symbolic link）
jiangxt211的专栏
02-25 8518
stat - display file or file system status struct stat { mode_t       st_mode;    /* file type & mode (permissions) */ ino_t       st_ino;     /* i-node number (serial number) */ dev_t
c语言string源码
jiangxt211的专栏
04-12 1261
#ifndef _LINUX_STRING_H_ #define _LINUX_STRING_H_ /* We don't want strings.h stuff being used by user stuff by accident */ #ifndef __KERNEL__ #include #else #include /* for inline */ #include /*
servr
jiangxt211的专栏
09-22 1251
/* * tiny.c - A simple, iterative HTTP/1.0 Web server that uses the * GET method to serve static and dynamic content. */ #include "csapp.h" void doit(int fd); void read_requesthdrs(rio_t *rp); int
字序与位序
jiangxt211的专栏
07-10 1227
1、字序对于跨越多字节的程序对象，我们需要建立两个规则：1）这个对象的地址是什么；2）在内存中如何排列这些字节。在几乎所有的机器中，多字节对象都被存储为连续的字节序列，对象的地址为所用字节中最小的地址。排列对象的中字节有两个通用规则：小端法（little endian）和大端法（big endian）。小端法即最低有效字节在最前面（低地址）；大端法正好相反。That is, in a big en...
不相交集合
jiangxt211的专栏
08-10 1048
不相交集合（disjoint-set） 一些应用涉及将n个不同的元素分成一组不相交的集合，常需要确定某元素所属集合及合并两集合。（例如，确定无向图的连通分量） 1、不相交集合数据结构 不相交集合数据结构（disjoint-setdatastructure）维护着一组不相交的动态集合S={S1,S2,S3,...,Sk}。我们用一个代表（representative）来标识每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值