【数据结构】不带头节点的单链表

原创 已于 2023-03-05 10:19:14 修改 · 147 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #单链表

于 2022-09-11 17:05:23 首次发布
本文介绍了单链表的实现，包括头插法、尾插法、插入指定位置、删除节点等功能。代码示例展示了如何在C语言中创建和管理单链表，以及对链表进行各种操作，如获取链表长度、打印链表信息等。此外，还提供了测试用例来验证链表操作的正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本篇实现的单链表，在结构体 single_list_t 中存储的数据域是一个 list_node_t 类型的指针，可根据实际情况对 list_node_t 中的内容增删。

1. single_list.h

#ifndef __SINGLE_LIST_H__
#define __SINGLE_LIST_H__

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct list_node_s {
	char *data;
	int data_count;
} list_node_t;

typedef struct single_list_s {
	struct single_list_s *next;
	list_node_t *node;
} single_list_t;

int is_list_empty(const single_list_t *head);
int get_list_size(const single_list_t *head);
void print_list_info(const single_list_t *head);
void push_front(single_list_t **head, const char *data);
void push_back(single_list_t **head, const char *data);
void insert(single_list_t **head, single_list_t *pos, const char *data);
void pop_front(single_list_t **head);
void pop_back(single_list_t **head);
void erase(single_list_t **head, single_list_t *pos);
void remove_list_by_data(single_list_t **head, const char *data);
void remove_list_by_all_data(single_list_t **head, const char *data);
void clear_list(single_list_t **head);
void destroy_list(single_list_t **head);

#ifdef __cplusplus
}
#endif

#endif // __SINGLE_LIST_H__

2. single_list.c

#include "single_list.h"

static int s_list_size = 0;

int is_list_empty(const single_list_t *head)
{
	return NULL == head;
}

int get_list_size(const single_list_t *head)
{
	int list_size = 0;

	if (!is_list_empty(head)) {
		if (head->node) {
			list_size = head->node->data_count;
		}
	}

	return list_size;
}

void print_list_info(const single_list_t *head)
{
	const single_list_t *cur = head;
	for (; NULL != cur; cur = cur->next) {
		if (cur->node) {
			printf("%-s -> ", cur->node->data);
		}
	}

	printf("NULL\n");
}

static single_list_t *create_list_node(const char *data)
{
	single_list_t *new_list = NULL;

	do {
		new_list = (single_list_t *)calloc(1, sizeof(single_list_t));
		if (NULL == new_list) {
			perror("calloc new_list fail");
			break;
		}

		list_node_t *new_node = NULL;
		new_node = (list_node_t *)calloc(1, sizeof(list_node_t));
		if (NULL == new_node) {
			perror("calloc new_node fail");
			if (new_list) {
				free(new_list);
				new_list = NULL;
			}

			break;
		}

		new_node->data = (char *)calloc(1, strlen(data) + 1);
		if (NULL == new_node->data) {
			perror("calloc new_node->data fail");
			if (new_node) {
				free(new_node);
				new_node = NULL;
			}
			if (new_list) {
				free(new_list);
				new_list = NULL;
			}

			break;
		}

		new_node->data_count = ++s_list_size;
		strcpy(new_node->data, data);
		new_list->node = new_node;
		new_list->next = NULL;
	} while (0);

	return new_list;
}

void push_front(single_list_t **head, const char *data)
{
	single_list_t *new_list = create_list_node(data);
	if (NULL == new_list) {
		return;
	}

	new_list->next = *head;
	*head = new_list;
}

void push_back(single_list_t **head, const char *data)
{
	single_list_t *new_list = create_list_node(data);
	if (NULL == new_list) {
		return;
	}

	// 之前如果没有节点，那么不能遍历查找尾节点
	if (NULL == *head) {
		*head = new_list;
	} else {
		// 遍历查找尾节点
		single_list_t *cur = *head;
		while (NULL != cur->next) {
			cur = cur->next;
		}

		new_list->next = cur->next;
		cur->next = new_list;
	}
}

// 在 pos 前插入节点
void insert(single_list_t **head, single_list_t *pos, const char *data)
{
	if (pos == *head) {
		push_front(head, data);
		return;
	}

	single_list_t *cur = *head;
	single_list_t *new_list = create_list_node(data);
	if (NULL == new_list || NULL == pos) {
		return;
	}

	while (pos != cur->next) {
		cur = cur->next;
	}

	new_list->next = pos;
	cur->next = new_list;
}

static void free_list_node(single_list_t *pos)
{
	if (NULL == pos) {
		return;
	}

	if (pos->node && pos->node->data) {
		pos->node->data_count -= 1;
		free(pos->node->data);
		pos->node->data = NULL;
		free(pos->node);
		pos->node = NULL;
	}

	free(pos);
	pos = NULL;
}

void pop_front(single_list_t **head)
{
	if (is_list_empty(*head)) {
		return;
	}

	single_list_t *cur = *head;
	single_list_t *next_list = cur->next;
	free_list_node(cur);
	*head = next_list;
}

void pop_back(single_list_t **head)
{
	if (is_list_empty(*head)) {
		return;
	}

	single_list_t *cur = *head;

	// 可能只有一个节点
	if (NULL == cur->next) {
		*head = cur->next;
		free_list_node(cur);
		return;
	}

	// 找到 倒数第二个节点
	while (NULL != cur->next->next) {
		cur = cur->next;
	}

	// 最后一个节点
	single_list_t *next_list = cur->next;
	cur->next = next_list->next;
	free_list_node(next_list);
}

void erase(single_list_t **head, single_list_t *pos)
{
	if (is_list_empty(*head) || NULL == pos) {
		return;
	}

	if (pos == *head) {
		pop_front(head);
		return;
	}

	single_list_t *cur = *head;
	while (pos != cur->next) {
		cur = cur->next;
	}

	single_list_t *next_list = pos->next;
	cur->next = next_list;
	free_list_node(pos);
}

static single_list_t *find_list_by_data(single_list_t *head, const char *data)
{
	if (is_list_empty(head) || NULL == data) {
		return NULL;
	}

	single_list_t *cur = head;
	for (; NULL != cur; cur = cur->next) {
		if (cur->node) {
			if (0 == strcmp(cur->node->data, data)) {
				return cur;
			}
		}
	}

	return NULL;
}

void remove_list_by_data(single_list_t **head, const char *data)
{
	single_list_t *pos = find_list_by_data(*head, data);
	erase(head, pos);
}

void remove_list_by_all_data(single_list_t **head, const char *data)
{
	single_list_t *cur = *head;
	single_list_t *next_list = NULL;

	// 先 跳过第一个节点
	// 假如先删除了第一个节点，那么后续的节点就无法删除
	while (NULL != cur->next) {
		if (cur->next->node && 0 == strcmp(cur->next->node->data, data)) {
			next_list = cur->next;
			cur->next = next_list->next;
			free_list_node(next_list);
		} else {
			cur = cur->next;
		}
	}

	// 注意最后删除第一个节点
	if ((*head)->node && 0 == strcmp((*head)->node->data, data)) {
		pop_front(head);
	}
}

void clear_list(single_list_t **head)
{
	single_list_t *cur = *head;
	single_list_t *next_list = NULL;

	if (is_list_empty(cur)) {
		return;
	}

	// 先释放第一个节点后面的节点
	for (; NULL != cur->next; cur = next_list) {
		next_list = cur->next;
		free_list_node(cur);
	}

	// 释放第一个节点
	free_list_node(cur);

	*head = NULL;
}

void destroy_list(single_list_t **head)
{
	clear_list(head);
}

3. test_single_list.c

#include "single_list.h"

void test()
{
	single_list_t *list_head = NULL;

	printf("list size : %d\n", get_list_size(list_head));
	printf("\nlist info :\n");
	print_list_info(list_head);

	printf("\npush_front hello\n");
	push_front(&list_head, "hello");
	printf("\nlist info :\n");
	print_list_info(list_head);
	printf("\npush_back world\n");
	push_back(&list_head, "world");
	printf("\nlist info :\n");
	print_list_info(list_head);

	printf("\ninsert list_head hi\n");
	insert(&list_head, list_head, "hi");
	printf("\nlist info :\n");
	print_list_info(list_head);
	printf("\ninsert list_head->next->next emo\n");
	insert(&list_head, list_head->next->next, "emo");
	printf("\nlist info :\n");
	print_list_info(list_head);
	printf("\ninsert list_head->next orz\n");
	insert(&list_head, list_head->next, "orz");
	printf("\nlist info :\n");
	print_list_info(list_head);

	printf("\npush_front emo\n");
	push_front(&list_head, "emo");
	printf("\nlist info :\n");
	print_list_info(list_head);
	printf("\npush_front emo\n");
	push_front(&list_head, "emo");
	printf("\nlist info :\n");
	print_list_info(list_head);

	if (is_list_empty(list_head)) {
		printf("\nlist is empty\n");
	} else {
		printf("\nlist is not empty\n");
	}

	printf("list size : %d\n", get_list_size(list_head));

	printf("\nremove_list_by_data emo\n");
	remove_list_by_data(&list_head, "emo");
	printf("\nlist info :\n");
	print_list_info(list_head);

	printf("\nremove_list_by_all_data emo\n");
	remove_list_by_all_data(&list_head, "emo");
	printf("\nlist info :\n");
	print_list_info(list_head);

	printf("\npop_front\n");
	pop_front(&list_head);
	printf("\nlist info :\n");
	print_list_info(list_head);
	printf("\npop_back\n");
	pop_back(&list_head);
	printf("\nlist info :\n");
	print_list_info(list_head);

	if (!is_list_empty(list_head)) {
		printf("\nerase list_head->next\n");
		erase(&list_head, list_head->next);
		printf("\nlist info :\n");
		print_list_info(list_head);
	} else {
		printf("\nerase list_head\n");
		erase(&list_head, list_head);
		printf("\nlist info :\n");
		print_list_info(list_head);
	}

	printf("\nclear list\n");
	clear_list(&list_head);
	printf("list size : %d\n", get_list_size(list_head));
	printf("\nlist info :\n");
	print_list_info(list_head);

	printf("\ndestroy list\n");
	destroy_list(&list_head);
	printf("list size : %d\n", get_list_size(list_head));
	printf("\nlist info :\n");
	print_list_info(list_head);

	if (is_list_empty(list_head)) {
		printf("\nlist is empty\n");
	} else {
		printf("\nlist is not empty\n");
	}
}

int main(void)
{
	test();

	return 0;
}

4. Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG

SOURCE = $(wildcard ./*.c)
BIN = $(patsubst %.c, %, $(notdir $(SOURCE)))

$(BIN): $(SOURCE)
	$(CC) $(CFLAGS) $(SOURCE) -o $@

clean:
	rm -rf $(BIN)
单链表（不带头结点）
s_ai_yan的博客
03-06 904
定义了一个结点的结构体，包含整型数据域 `data` 和指向下一个结点的指针 `next`。通过输入一系列整数，创建链表，采用头插法，即新结点插在链表头部，导致链表元素顺序是逆序的。初始化链表，将头指针 `pHead` 置为 `NULL`。7. **按值获取结点和位序：**9. **打印链表所有值：**4. **获取链表长度：**1. **结构体定义：**2. **链表初始化：**6. **按位序插入：**8. **按位序删除：**3. **链表判空：**5. **创建链表：**10. **主函数：**
数据结构：C语言实现----不带头结点单链表总结
kimEHEH的博客
08-11 717
不带头结点的单链表结构体声明 typedef struct Node { int data; struct Node *next; }Node, *LinkList; （1）初始化 void InitLinkList(LinkList *plist) //plist为二级指针，主函数传递第一个结点指针的地址 { assert(plist!=NULL); if(plist == NULL) return; *plist = NULL; } （2）求链表长度 int Lis.
【不带头节点的单链表】
98同学吖的博客
04-23 2883
不带头节点的单链表
【数据结构】链式存储——不带头结点的单链表
维欣~fighting✔
04-14 2431
不带头结点的单链表一、简介1、回顾单链表2、分析不带头结点二、代码与实现1、结构定义2、初始化三、插入操作1、生成新结点2、头插3、尾插四、删除操作1、判空操作2、头删3、尾删五、查询操作六、销毁 一、简介 1、回顾单链表 单链表的结构（带头结点的） 2、分析不带头结点 因为我们都知道头结点无实际意义，所以如果我们不想带头结点，只想要数据结点，该怎么做？ 不带头结点的单链表也需要唯一的起始，唯一...
带头结点单链表 和 不带头结点单链表的区别
热门推荐
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-12 1万+
文章目录不带头结点的操作代码①代码②代码③代码④带头结点的操作代码⑤ 下面的代码中，传递链表时，传的是头指针。如果是带头结点的链表，传递链表时，可以传头结点，具体可以看看 C语言实现-线性表的链式存储(单链表) 带头结点单链表 和 不带头结点单链表的区别： 带头结点单链表，在进行插入、删除操作时，不需要改变链表头指针。 不带头结点的单链表，在进行插入、删除操作时，可能会涉及到链表头指针的修改（所以链表作为参数传递时，传递的是头指针的引用，具体可看代码④中head_insert方法中的指针变量带了
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，...
数据结构三：线性表之单链表(带头结点单链表设计)的设计
最新发布
weixin_47040031的博客
01-23 1778
线性表的链式存储结构正是所谓的单链表，何谓单链表？通过地址将每一个数据元素串起来，进行使用，这可以弥补顺序表在进行任意位置的插入和删除需要进行大量的数据元素移动的缺点，只需要修改指针的指向即可；单链表的种类又可划分为很多种，本篇博客详细介绍带头结点单链表的设计与实现，掌握单链表的关键是要进行画图分析；单链表同时也是笔试和面试的必考点，因此，掌握好该章节非常重要！
数据结构————倒置带头结点单链表操作讲解
m0_64985004的博客
04-03 2821
我们先来实现带头单链表的基本操作： 头文件： #include<stdio.h> #include<assert.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode*next; }LT,*link; void InitList(Link phead);//初始化 void InsertListfront(Link p
数据结构 &不带头结点的单链表
csdn_edition的博客
01-21 2066
不带头结点的单链表是线性表的一种链式存储形式，首先来设计它的结构： typedef int ElemType; typedef struct Node { ElemType data; struct Node* next; }LNode,*pLinkList; 首先对于单链表进行判空操作： static void DeterPointNull(pLinkList* list) { assert(list != NULL); if (list == NULL) { printf("list i
不带头结点的单链表
Red Rapefruit
02-23 351
不带头结点的单链表 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define null NULL typedef int Elemtype; typedef struct LNode{ Elemtype data; struct LNode* next; }; typedef struct LNode Lnode; typedef struct LNode *LinkList;
数据结构：不带头结点的单链表
yy_0733的博客
08-06 1661
不带头结点的单链表： 1.不带头结点的单链表操作中，除了初始化，头插，尾插，删除，操作与带头结点的单链表有差别外，其它的操作基本上一样。 2.链表指针直接指向了首元节点，因此在首元节点前插入数据元素或者删除首元节点元素都会改变头指针的值。所以这里要引入二级指针。 3、存储结构： 4、实现： （1）list.h: #pragma once //链表指针直接指向了首元节点，因此在首...
1.不带头结点的单链表
qq_38769551的博客
11-04 333
linkedlist.c #include "linkedlist.h" #include <stdio.h> #include <stdlib.h> /* Create_linkedlist: 创建一个链表 void：无参数 返回值： 第一个节点的指针 Node * */ Node * Create_linkedlist(void) { Node * p = NULL; //指向要插入的那个结点 Node * h = NULL; //指向链表的第一个结点 No.
数据结构——单链表(带头指针版本+使用哨兵位头节点版本)
Jambo!的博客
04-01 3522
单链表
数据结构之单链表（不带头结点）
zk_lar的博客
07-02 363
C语言实现单链表的基础接口
不带头结点单链表的C++实现方法与功能
标题“数据结构 不带头结点的单链表代码”指的是一种单链表的实现方式，其中不包含头结点。通常，链表的首节点前会设置一个虚拟的头结点（dummy head node），用以简化插入和删除操作的边界条件处理，而在某些实现中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值