单向链表操作

已于 2022-09-03 20:13:37 修改
阅读量205 收藏
点赞数
分类专栏： 嵌入式 文章标签： 链表 数据结构
于 2022-09-03 20:10:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qrsxtkf/article/details/126681668
版权

单向链表操作总共分为4个文件：

node.h

node.c

test.c

Makefile

现在将代码贴在下面仅供参考，直接可以运行：

node.h

#ifndef _NODE_H__
#define _NODE_H_

enum e_pos
{
	TAIL = -1,
	HEAD,
};
enum e_result
{
	ERROR = -1,
	OK,
	FALSE = 0,
	TRUE,
};

typedef int data_t ;
typedef struct node 
{
	data_t data;
	struct node * ptNext;
}NODE;

NODE * createLinkTableHead();
void destroyLinkTable(NODE *pHead);
int insertNodeToLinkTable(NODE *pHead, int offset, data_t newData);
int deleteNodeFromLinkTable (NODE *pHead, int offset, data_t *pData);
int updateDataToNode(NODE *pHead, data_t newData, data_t oldData);
int searchDataFromNode(NODE *pHead, data_t oldData);
void displayNodeData(NODE *pHead);
int isEmpty(const NODE *pHead);

#endif

node.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "node.h"
#define DEBUG

/* 创建链表头*/
NODE * createLinkTableHead()
{
	NODE *pHead = (NODE *)malloc(sizeof(NODE));
	if (NULL != pHead){
		pHead->data = 0;
		pHead->ptNext = NULL;
	}	
	return pHead;
}

/* 销毁整个链表(释放完全) */
void destroyLinkTable(NODE * pHead)
{
	/* pDel指向头节点 */
	NODE *pDel = pHead;	
	
	/* firstNode指向首节点 */
	NODE *pFirst = pDel->ptNext;    
	
	while (NULL != pFirst){
		/* 释放头节点 */
		free(pDel);	
		
		/* 移动 */
		pDel = pFirst;

		/* 移动 */
		pFirst = pFirst->ptNext;	
	}
	/* 释放最后一个节点 */
	free(pDel); 
	return;
}

/* 链表插入节点 */
int insertNodeToLinkTable(NODE * pHead, int offset, data_t newData)
{
	if (NULL == pHead){
		return ERROR;
	}
	
	/* 创建新结点pNew，并且初始化 */
	NODE *pNew = (NODE *)malloc(sizeof (NODE));
	if (NULL == pNew){
		return ERROR;
	}
	pNew->data = newData;
	pNew->ptNext = NULL;
	
	/* 头插（插到头节点后面） */
	if (HEAD == offset){
		/* 首节点连接到pNew后面 */
		pNew->ptNext = pHead->ptNext;
		
		/* 将pNew连接到头结点之后 */
		pHead->ptNext = pNew;
	}
	
	/* 尾插（找到尾节点，插到后面） */
	else if (TAIL == offset){
		NODE * pTail = pHead;
		
		/* 遍历，找到尾结点 */
		while (NULL != pTail->ptNext){
			pTail = pTail->ptNext;
		}
		
		/* 把新结点连接到尾结点之后，作为新的尾结点; */
		pTail->ptNext = pNew;
		pNew->ptNext = NULL;
	}
	
	/* 中间插入(在offset后面插入新的节点pNew) */
	else{
		NODE *q = pHead; /* 让q从头节点开始遍历 */

		/* i表示节点的位置从头节点开始 */
		int i=0;     
		while(i < offset && NULL != q){
			/* q往后移动 遍历找到offset的位置 */
			q = q->ptNext; 
			i++;		
		}

		/* 没有找到合适位置 */
		if(NULL == q){
			free(pNew);
			return ERROR;
		}
		/* 保护q后面的所有节点 */
		pNew->ptNext = q->ptNext;
		/* 把pNew连接到q后面 */
		q->ptNext = pNew; 
	}
	return 0;
}

/* displayNODE */
void displayNodeData(NODE * pHead)
{
	NODE * q = NULL;
	if (NULL == pHead){
		return ;
	}

	/* q指向首节点 */
	q = pHead->ptNext;
	while(NULL != q){
		printf("%d -> " , q->data);

		/* q移动 */
		q = q->ptNext;
	}
	printf("^\r\n");
}

/* 从链表删除某一个节点 */
int deleteNodeFromLinkTable (NODE * pHead, int offset, data_t * pData)
{
#ifdef DEBUG
	printf("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);
#endif

	NODE * pDel = NULL;
	if (NULL == pHead ||   NULL == pHead->ptNext){
		return ERROR;
	}

	/* 头删(删除首节点)*/
	if (HEAD == offset){
		/* pDel指向被删除的首结点 */
		pDel = pHead->ptNext;
		
		/* 保护pDel后的所有结点 */
		pHead->ptNext = pDel->ptNext;
		
		/* 保存pDel的数据域的值 */
		if (NULL != pData){
			*pData = pDel->data;
		}
		
		/* 释放pDel */
		free(pDel);
		pDel = NULL;
		
		return OK;
	}

	/* 尾删(删除尾结点) */
	else if (TAIL == offset)
	{
		
		 /* 定义q来保存被删除节点的前一个节点 */
		 NODE *q = pHead;

		 /* 找尾节点 */
		 pDel = pHead->ptNext;
		 while(NULL != pDel->ptNext){
			pDel = pDel->ptNext;
		 	q = q->ptNext; /* q保存前一个节点 */ 
		 }

		 /* 给尾节点前一节点的指针域赋值NULL */
		 q->ptNext = NULL;

		 /* 保存数据域的值 */
		 if(NULL != pData){
			 *pData = pDel->data;
		 }
		 /* 释放掉被删除的节点 */
		 free(pDel);
		 pDel = NULL;
		return OK;
	}

	/* 从中间删除某一个节点 */
	else 
	{
		/* 定义指针pDel指向被删除的节点，定义q指向pDel前一节点 */
		int i = 0;

		NODE *q = pHead; /* 定义q指向头节点 */

		pDel = q->ptNext;/* pDel指向首节点 */
	
		/* 找offset位置 */
		while(i<offset && NULL !=pDel){
			pDel = pDel->ptNext; /* 移动pDel */
			q = q -> ptNext;     /* 移动q */
			i++;
		}
		/* 保护被删除节点后面的节点 */
		q->ptNext = pDel->ptNext;

		/* 保存被删除节点的数据 */
		if(NULL != pData){
			*pData = pDel->data; /* 把被删除节点的数据拷贝出来 */
		}
		free(pDel); /* 被删除节点释放 */
		pDel = NULL;
		return OK;
	}	
	return OK;
}

/* 判断是否为空 */
int isEmpty(const NODE *pHead)
{
	if(NULL == pHead){
		return ERROR;
	}
	if(NULL == pHead->ptNext){
		return TRUE;
	}
	if(NULL != pHead->ptNext){
		return FALSE;
	}
	return ERROR;
}

/* 查找节点的数据 */
int searchDataFromNode(NODE * pHead, data_t oldData)
{
	/* 查找节点从首节点往后遍历 */
	NODE *pSerch = pHead->ptNext;
	int offset = 0;

	/* 从首节点开始往后找 */
	while(NULL != pSerch){
		/* 判断，如果数据相等，返回位置，否则输出找不到 */
		if(oldData == pSerch->data){
			return offset;
		}
		/* 往后移动查找链表 */
		pSerch = pSerch->ptNext;

		/* 移动一次，位置加1 */
		offset ++;
	}
	printf("找不到此数据\n");
	return ERROR;
}

/* 更新节点数据 */
int updateDataToNode(NODE * pHead, data_t newData, data_t oldData)
{
	NODE *pUpd = pHead;
	while(NULL != pUpd){
		if(oldData == pUpd->data){
			pUpd->data = newData;
			return OK;
		}
		pUpd = pUpd->ptNext;
	}
	return ERROR;
}

test.c

#include <stdio.h>
#include "node.h"

int main()
{
	NODE * pHead = NULL;
	data_t data ;
	
	/* 创建链表头结点 */
	pHead = createLinkTableHead();
	
	/* 插入数据 */
	insertNodeToLinkTable(pHead, HEAD, 1);
	insertNodeToLinkTable(pHead, HEAD, 2);
	insertNodeToLinkTable(pHead, TAIL, 3);
	insertNodeToLinkTable(pHead, TAIL, 4);
	insertNodeToLinkTable(pHead, HEAD, 5); /* 52134 */
	insertNodeToLinkTable(pHead, 3, 9);

	printf("insert value is:\n");
	displayNodeData(pHead);
	
	/* 删除首结点元素 */
	if ( OK == deleteNodeFromLinkTable ( pHead, HEAD, &data )){
		printf("删除头结点元素，被删除的元素是%d\n", data);
	}
	displayNodeData(pHead);

	/* 删除位置为3的元素 */
	if(OK == deleteNodeFromLinkTable ( pHead, 3, &data )){
		printf("删除位置为3的元素，被删除的元素是%d\n", data);
	}
	displayNodeData(pHead);


	/* 删除尾元素 */
	if(OK == deleteNodeFromLinkTable ( pHead, TAIL, &data )){
		printf("删除尾部元素，被删除的元素是%d\n", data);

	}
	displayNodeData(pHead);


	/* 判断是否为空 */
	if(1 == isEmpty(pHead)){
		printf("链表为空\n");
	}
	if(0 == isEmpty(pHead)){
		printf("链表不为空\n");
	}
	

	/* 查找数据 */
	int ret_serach = searchDataFromNode(pHead,9);
	if (ret_serach >=0){
		printf("查找到的元素的位置为%d\n",ret_serach);
	}

	/* 跟新值 */
	if (OK == updateDataToNode(pHead , 6 , 9)){
		printf("update success,将9更改成6\n");
	}
	displayNodeData(pHead);

	/* 销毁线性表 */
	destroyLinkTable(pHead);
	pHead = NULL;
	
	return 0;
}

 Makefile:

test:test.o node.o
	gcc test.o node.o -o test
test.o:test.c node.h
	gcc -c  -Wall -g -Werror test.c -o test.o
node.o:node.c node.h
	gcc -c  -Wall -g -Werror node.c  -o node.o
.PHONY:clean
clean:
	rm -rf test *.o

潘良荣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
单向链表操作类模板实现代码
09-19
单向链表操作类模板实现代码，代码内包含结点类、链表操作类的实现以及主测试函数等；其中链表操作包含结点插入、删除、获取等；
单链表基本操作
Sti1lWater的博客
12-24 1万+
单链表的基本操作
单链表的基本操作
m0_63783532的博客
10-04 2001
typedef struct Lnode//定义单链表的结点类型{//每个结点存放一个数据元素//指针指向下一个结点Lnode* L;//声明一个指向单链表第一个结点的指针LinkList L;//声明一个指向单链表第一个结点的指针注意:强调这是一个单链表，使用LinkList强调这是一个结点，使用Lnode*
数据结构-单向链表的操作（详细思路和实例）
m0_65835264的博客
07-30 962
对单向链表的一系列操作的集合（增删改查等16个函数），用详细的思路、图解、实例、验证，使学习单向链表更加通俗易懂。
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
python单向链表的基本操作细节（小白入门）
12-21
今天是人生第一次写博客，记录自己学习的每一步，有些写...且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 什么意思呢，我们在使用python列表的时候，如果我们需要删除列表
单向链表的操作____
05-17
单向链表的创建、打印、某个元素的查找和删除（可查找和删除重复数据）、整个链表的删除等
单链表的操作（超详细），保证你看完不后悔
热门推荐
princekin
04-22 3万+
编程实现单链表的以下基本操作：建立顺序表，修改顺序表，插入顺序表，删除顺序表。
单链表的基本操作（详细）
qq_43346784的博客
07-06 8670
单链表的基本操作（详细）
单向链表的基本操作
weixin_52358343的博客
09-29 750
链表通常是单向链表，它包含多个结点，每个结点有一个指向后继元素的next（下一个）指针。表中最后一个结点的next指针为NULL，表示该链表结束。 链表的类型声明： public class ListNode { private int data; private ListNode next; public ListNode(int data) { this.data = data; } public in...
链表1：单向链表的基本操作
纵横千里 捭阖四方 的专栏
07-24 560
从这一节开始第三个专题：链表。链表也属于线性表，应用也非常广泛。我们大约用15篇文章来梳理相关的问题。 链表有单向，双向，循环等多种类型，其中单向是考察最多的。而双向和循环链表在实际应用中更多，双向链表+Hash可以实现LRU，这也是一个重要的考察点。leetcode中也有大量的算法都以其为基础。 链表的基本操作也都是创建+增删改查，不过每种根据其结构的不同，实现也有差异，我们重点看单向链表。 对于链表，插入和删除到底怎么操作一定要清清楚楚，画图也好，测试也罢，不然链表的面试题一定搞不定。 ..
单向链表操作详解（一）
rerli的专栏
12-07 2万+
/*===============================================作者：rerli时间：2003-12-05目的：学习单向链表的创建、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序说明：编译没有任何错误，能生成EXE文件。  这个程序TC2.0中编译生成的EXE文件，  在运行输入节点时出现以下错误(TC2.01中没有任何错误)：  sc
单向链表的操作
晨晨渝奇的博客
02-23 299
单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体的数据。 链接域next用来存放下一个节点的位置（python中的标识） 创建节点类 # 创建节点类 class Node(object): def __init__(self, elem): self.elem = elem self.next = No.
单向链表操作的实现（验证性实验）
最新发布
05-09
好的，下面是单向链表的基本操作的实现（代码使用C语言）： ```c #include #include // 定义链表节点结构体 typedef struct Node { int data; // 数据 struct Node *next; // 指向下一个节点的指针 } Node; /...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

潘良荣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值