线性链表常用接口的实现

最新推荐文章于 2022-01-11 00:09:19 发布
置顶 最新推荐文章于 2022-01-11 00:09:19 发布
阅读量751 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 线性链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33635623/article/details/91047470
版权

线性链表是数据结构中最常见，最常用的结构之一，其动态添加与删除优越性能在很多OS的任务调度中经常被使用到。通过最近的学习与归纳，有不小收获，整理一些常用的接口与实现如下：

1.link_list* create_list(void)

  创建链表，并包头结点，头结点内容为链表长度（或节点数）

2. STATUS head_insert( link_list* list,int index,int data)                                                                                                                        链表头插接口，index需从第二个节点开始，因为第一个节点是保留节点（存储链表长度信息）

3.STATUS tail_insert( link_list* list,int index,int data)                                                                                                                            链表尾插接口，index需从第一个节点开始

4. STATUS get_node( link_list* list, int index, int* node_data)                                                                                                               获取节点内容接口；

5.STATUS get_middle_node( link_list*list, int* node_data)                                                                                                                   获取中间节点内容接口，采用的是快慢指针的算法。具体实现，定义快慢两个指针，快指针步长为2，慢指针步长为1，当快指     针到达链尾时，慢指针指向的就是中间指针。                                                                                                                                   注：快慢指针的用法在链表里用的很多。

6.STATUS get_back_k_node( link_list*list,int k, int* node_data)                                                                                                             获取距离链尾第K个节点内容，采用的也是快慢指针的算法。具体实现，定义快慢两个指针，快指针先移至第K个节点，然后快慢指针同时移动，当快针到达链尾时，慢指针指向的就是距离链尾第K个节点。

7.STATUS delect_node( link_list* list,int index)                                                                                                                                          删除节点，这里有个地方要注意，被删除的节点一定要释放，否则就会造成内存泄漏

8.STATUS clear_list( link_list*list)                                                                                                                                                           清空链表，只保留头结点，也是要注意释放内存

9.STATUS show_list_content(link_list*list)                                                                                                                                              打印链表内容
 

详细代码，需要的可以直接CV。

#ifndef __LIST_H__
#define __LIST_H__

/**************** include ********************/
#include "stdint.h"

/**************** define ********************/

/**************** struct ********************/
typedef struct list_node_t
{
    int data;	
    list_node_t* p_next;
}link_list;


typedef enum
{
    FINE,
    LIST_SHORT,
    NODE_NO_EXIT
} STATUS;

/**************** parameter *****************/
//struct list_node_t	 list_node,*p_list_node;
/**************** function ********************/

link_list* create_list(void);

STATUS head_insert( link_list* list,int index,int data);

STATUS tail_insert( link_list* list,int index,int data);

STATUS get_node( link_list* list, int index, int* node_data);

STATUS get_middle_node( link_list*list, int* node_data);

STATUS get_back_k_node( link_list*list,int k, int* node_data);

STATUS delect_node( link_list* list,int index);

STATUS clear_list( link_list*list);

STATUS show_list_content(link_list*list);

#endif /*__LIST_H__*/

/**************** (.h) end file *******************/

 

 

/* Includes ------------------------------------------------------------------*/
#include "list.h"
#include "stdio.h"
#include "stdlib.h"
/* prama define discrible -----------------------------------------------------*/

/* strcuct  discrible --------------------------------------------------------*/

/* prama  discrible ---------------------------------------------------------*/

/* private fucntion  declaration --------------------------------------------*/
/******************************************************************************
* @Function: link_list* create_list(void)
* @Discrible:  创建空链表，返回链表头指针
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
link_list *create_list(void)
{
	link_list *head;
	head = (link_list *)malloc(sizeof(link_list));
	head->data = 1;
	head->p_next = NULL;
	return head;
}

/******************************************************************************
* @Function:  STATUS head_insert(link_list* list,int index, int data)
* @Discrible: index 位置前插入元素
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS head_insert(link_list *list, int index, int data)
{
	int i = 1;
	struct list_node_t *list_node, *pre_node;

	pre_node = list;

	/* 节点头插入，需要从第二个节点开始，第一个节点是不使用的节点，存储的是链表长度信息*/
	if (index < 2)
	{
		return LIST_SHORT;
	}

	/*头插算法实现是找到需要头插节点的前一个节点进行尾插*/
	while ((i < (index - 1)) && pre_node && pre_node->p_next)
	{
		pre_node = pre_node->p_next;
		i++;
	}
	/*如果节点为空，则说明节点不存在*/
	if ((!pre_node) || (!pre_node->p_next))
	{
		return NODE_NO_EXIT;
	}

	/*创建新节点*/
	list_node = (link_list *)malloc(sizeof(link_list));
	list_node->data = data;

	/*插入节点*/
	list_node->p_next = pre_node->p_next;
	pre_node->p_next = list_node;

	/*头结点计数加1*/
	pre_node->data++;

	return FINE;
}

/******************************************************************************
* @Function:  STATUS tail_insert(link_list* list,int index,int data)
* @Discrible:  index 位置后插入元素
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS tail_insert(link_list *list, int index, int data)
{
	int ret = 0;
	int i = 1;
	struct list_node_t *list_node, *pre_node;

	pre_node = list;
	// 节点尾插入，需要从第一个节点开始，第一个节点是不使用的节点，存储的是链表长度信息
	if (index < 1)
	{
		return LIST_SHORT;
	}

	while ((i < index) && pre_node)
	{
		pre_node = pre_node->p_next;
		i++;
	}

	/*如果节点为空，则说明节点不存在*/
	if (!pre_node)
	{
		return NODE_NO_EXIT;
	}

	/*创建新节点*/
	list_node = (link_list *)malloc(sizeof(link_list));
	list_node->data = data;

	/*插入节点*/
	list_node->p_next = pre_node->p_next;
	pre_node->p_next = list_node;

	/*头结点长度+1*/
	pre_node->data++;
	return FINE;
}

/******************************************************************************
* @Function: STATUS get_node(link_list* list, int index)
* @Discrible:  获取index节点数据
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS get_node(link_list *list, int index, int *node_value)
{
	int ret = 0;
	struct list_node_t *pre_node = list;

	while((index-- > 1) && pre_node)
	{
		pre_node = pre_node->p_next;
	}

	if(!pre_node)
	{
		node_value = NULL;
		return NODE_NO_EXIT;
	}
	*node_value = pre_node->data;
	return FINE;
}

/******************************************************************************
* @Function: STATUS get_middle_node(link_list *list)
* @Discrible:   获取中间节点数值
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS get_middle_node(link_list *list,int *node_value)
{
	int ret = 0;
	struct list_node_t *fast_point,*slow_point,*pre_list_node;

	fast_point = list;
	slow_point = list;
	pre_list_node = list;

	/*取中间节点的值，链表长度不小于3*/
	if((!pre_list_node) && (!pre_list_node->p_next) && (!pre_list_node->p_next->p_next))
	{	
		return LIST_SHORT;
	}

	/*算法原理，快指针是慢指针的两倍，当快指针走到链位时，慢指针刚好走到一半*/
	while(fast_point&&fast_point->p_next)
	{
		fast_point  = fast_point->p_next->p_next;
		slow_point  = slow_point->p_next;
	}

	*node_value = slow_point->data;
	return FINE;
}

/******************************************************************************
* @Function:  STATUS get_back_k_node(link_list *list, int k, int* node_data)
* @Discrible:  获取倒数第K个节点的数值
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS get_back_k_node(link_list *list, int k, int* node_data)
{
	int ret = 0;
	struct list_node_t *fast_point,*slow_point,*pre_list_node;

	fast_point = list;
	slow_point = list;
	pre_list_node = list;

	/*先将快指针移但比慢指针多K个节点的位置*/
     while((k-->0) && fast_point)
	 {
		 fast_point = fast_point->p_next;
	 }

	if((!fast_point))
	{
		return LIST_SHORT;
	}

	/*然后同时移动快慢指针，当快指针到达链尾时，慢指针就在距离链尾K个节点的位置*/
	 while(fast_point)
	 {
		 fast_point = fast_point->p_next;
		 slow_point = slow_point->p_next;
	 }

	 *node_data = slow_point->data;

	return FINE;
}

/******************************************************************************
* @Function: STATUS delect_node(link_list *list, int index)
* @Discrible: 删除某个节点
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS delect_node(link_list *list, int index)
{
	int ret = 0;
	struct list_node_t *pre_list_node,*list_node,*free_list_node;

	pre_list_node =  list;
	/*节点删除必须从第二个节点开始，因为第一个节点是存储的长度信息，不可用*/
	if(index < 2 )
	{
		return LIST_SHORT;
	}

	while(pre_list_node  && (index-- > 2))
	{
		pre_list_node = pre_list_node->p_next;
	}

	if((!pre_list_node))
	{
		return NODE_NO_EXIT;
	}
	/*删除节点头结点计数减1*/
	list_node = pre_list_node->p_next->p_next;
	free_list_node = pre_list_node->p_next;
	pre_list_node->p_next = list_node;
	pre_list_node->data--;

	/*释放删掉节点的空间*/
	free(free_list_node);
	free_list_node = NULL ;

	return FINE;
}

/******************************************************************************
* @Function:  STATUS clear_list(link_list *list)
* @Discrible:   清空链表
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS clear_list(link_list *list)
{
	int ret = 0;
	struct list_node_t *list_node,*free_list_node;

	/*清空链表，只保留表头的信息*/
	list_node  = list->p_next;
	list->data = 1;
	list->p_next = NULL;

	while(list_node)
	{
		free_list_node =  list_node;
		list_node = list_node->p_next;
		free(free_list_node);
		free_list_node = NULL;
	}
	return FINE;
}

/******************************************************************************
* @Function:  STATUS show_list_content(link_list *list)
* @Discrible:  打印链表内容
* @Param:
* @Return:
* @Others:
******************************************************************************
* @Recode    date       version         author             modify
*          ------------------------------------------------------------------
*          20190605      V1.0          VINCENT            Create
*
*******************************************************************************/
STATUS show_list_content(link_list *list)
{
	int ret = 0;
	link_list *pre_node = list;
	printf("\r\n----------- beagin -----------\r\n");
	while (pre_node)
	{
		printf("%d  ", pre_node->data);
		pre_node = pre_node->p_next;
	}
	printf("\r\n----------- end -----------\r\n");
	return FINE;
}
/************************ (C) END OF FILE ************************************/

 

文森特9527
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux代码分析 本文详细分析了 2.6.x 内核中链表结构的实现，并通过实例对每个链表操作接口进行了详尽的讲解。
01-08
本文详细分析了 2.6.x 内核中链表结构的实现，并通过实例对每个链表操作接口进行了详尽的讲解
链表操作接口
weixin_41839388的博客
08-21 418
链表（Linked List）数据结构概览链表（Linked List）是线性表的一种（线性表包含顺序表与链表），通过指针将一系列位于不连续的内存空间中的元素连接起来，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理，但也失去了快速随机存取的优点，同时增大了内存开销（存储指针域）。 链表数据结构由一连串节点（Node）组成，每个节点包含数据域（Data Fields）和一或两个用来指向上一个/或下一个节点位置的指针域（Pointer Fields）。链表可以方便地...
链表的几个接口实现
ChaserZHY的博客
11-21 378
在这篇博客介绍一下数据结构线性表链表的几个接口实现，话不多说，进入正题。 头插法 头插法是链表的几大接口之一，在进入头插时也得考虑有没有节点让你头插，如果没有就创造一个节点。所以先给出一个创造节点的函数： SListNode* BuySListNode(SLDataType x)//创造一个新的节点 { SListNode *Node = (SListNode*)melloc(sizeof(SL...
链表接口的实现
code力力
06-13 755
 # include # include # include # define StopCondition t!=0 /***根据实际程序需要修改***/ typedef int DataType; /***根据实际程序需要修改***/ typedef struct node{ DataType data; struct node *next; }No
[数据结构] 链表接口实现
giturtle's blog
03-04 326
链表定义 定义 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
基于C语言实现的顺序表以及基本接口实现
最新发布
02-14
顺序表是一种线性存储结构，它采用一段连续的物理地址存储数据元素，具有元素随机存取、存储密度高、插入...通过运用C语言的数据类型和函数库，可以简单实现一个顺序表，并提供常用的接口操作，如插入、删除、查找等。
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
11.9 链表的概念 182 11.10 枚举类型 184 11.10.1 枚举类型的定义和枚举变量的说明 184 11.10.2 枚举类型变量的赋值和使用 185 11.11 类型定义符typedef 12 位运算 12.1 位运算符Ｃ语言提供了六种位运算符： 189 ...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
11.9 链表的概念 182 11.10 枚举类型 184 11.10.1 枚举类型的定义和枚举变量的说明 184 11.10.2 枚举类型变量的赋值和使用 185 11.11 类型定义符typedef 12 位运算 12.1 位运算符Ｃ语言提供了六种位运算符： 189 ...
传智播客扫地僧视频讲义源码
04-03
18_配置文件读写案例_写和修改接口实现 19_文件加密案例_思路分析 20_文件加密案例_文件搬运实现 21_文件加密案例_文件加密功能集成 22_文件加密案例_文件加密实现 23_作业 24_学员二级指针代码bug调试_传智扫地僧 ...
单链表接口的实现
TANGY的博客
01-03 198
SList.h #ifndef __TEST_H__ #define __TEST_H__ #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; typedef int SLTDataType; typedef struct SListNode { S...
线性表的实现（使用接口）
qq_45568450的博客
08-28 434
用数组方式实现线性表，实现了增删查改的功能，同时也练习一下如何使用接口。
链表的一些基本接口
hu_junhua的博客
01-23 292
头文件： #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #define SUCCESS 0 #define FAILURE -1 struct node { int data; struct node *next; }; typedef struct node Node; typedef Node *LinkList; int
单链表基础接口实现
Emperor10的博客
04-29 307
链表概念 链表是一种物理存储单元上非连续的存储结构。 接口实现 以 非循环，不带头结点的单链表为例 1. 抽象链表类 class ListNode { public int val;//值 public ListNode next;//存储下一个节点的地址 也就是说 这个是一个引用 public ListNode() { } public ListNode(int val) { this.val = val; } } 1.
java——线性表接口实现
weixin_30265171的博客
08-27 300
线性表是存储顺序牌类的数据时最常用的数据结构。 实现线性表有两种方式。第一种是使用数组存储线性表的元素。数组是动态创建的。超过数组的容量时，创建一个 新的更大的数组，并且将当前数组中的元素复制到新建的数组中。另一种方法是用链表结构实现。链表由节点组成，每 个结点都是动态生成的，用来存储一个元素。所有的结点连接成一个线性表。 对于线性表的主要操作有： 1...
数据结构链表1的基本常用接口
under_control的博客
01-11 373
#include<stdlib.h> #include<stdio.h> typedef int LDataType; //定义结点：数据+指针 struct ListNode { LDataType _data; struct ListNode* _next; }ListNode; //定义链表的结构体 typedef struct List { //保存第一个节点的地址 struct ListNode* _head; }List; struct ListNode* creatLi
单链表的基本接口
Hello World！
07-19 658
SList.h #ifndef _SLIST_H_ #define _SLIST_H_ #include<stdio.h> #include<windows.h> typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SList...
链表函数 （接口实现）范例
MACHINE_128的博客
02-28 314
头文件（函数接口，链表类型定义）typedef struct node* link; struct node { int item; link next; }; typedef link Node; void initNodes(int); void freeNode(link); link newNode(int); void insertNext(link,link); link d...
java数据接口之链表_Java数据结构和算法之链表
weixin_42537499的博客
02-27 189
三、链表链结点在链表中，每个数据项都被包含在‘点“中，一个点是某个类的对象，这个类可认叫做LINK。因为一个链表中有许多类似的链结点，所以有必要用一个不同于链表的类来表达链结点。每个LINK对象中都包含一个对下一个点引用的字段(通常叫做next)但是本身的对象中有一个字段指向对第一个链结点的引用。单链表用一组地址任意的存储单元存放线性表中的数据元素。以元素(数据元素的映象) + 指针(指示后继元...
数据结构：实现单链表的各个接口
ETalien_的博客
11-06 297
实现单链表的各个接口 SList.h #pragma once #include &amp;amp;amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;amp;
实现线性链表逆置的思路
05-17
要实现线性链表的逆置，可以按照以下思路： 1. 定义三个指针：prev、curr、next； 2. 将 prev 初始化为 NULL，curr 初始化为链表头结点； 3. 遍历链表，每次将 curr 的 next 指针指向 prev，然后依次移动 prev、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值