单向链表的C语言实现

最新推荐文章于 2024-09-09 21:22:46 发布
最新推荐文章于 2024-09-09 21:22:46 发布
阅读量961 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mark_chalers/article/details/120343447
版权

单向链表的C语言实现

singlelinketlist.h

#ifndef SINGLE_LINKET_LIST_H__
#define SINGLE_LINKET_LIST_H__
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//单向链表结点

typedef int ETYPE;

//单向链表结点类型 
typedef struct Node{
	ETYPE elem;     //元素
	struct Node *next; //下一个节点的位置	
}SNode,*SLinketList; 

#define NODESIZE sizeof(struct Node)

SLinketList slinket_list_create(void); 
//判断单向链表是否为空 
bool slinket_list_is_empty(SLinketList head);
//单向链表中元素的个数
size_t slinket_list_size(SLinketList head);
//在指定位置pos插入一个元素elem  第一个位置默认为0 
int slinket_list_insert(SLinketList head,size_t pos,ETYPE elem);
//在单向链表前面插入一个元素elem
int slinket_list_insert_front(SLinketList head,ETYPE elem);
//在单向链表末尾插入一个元素elem
int slinket_list_insert_back(SLinketList head,ETYPE elem);
//删除指定位置pos的元素
int slinket_list_delete(SLinketList head,size_t pos,ETYPE *pelem);
//删除单向链表第一个元素
int slinket_list_delete_front(SLinketList head,ETYPE *pelem);
//删除末尾的元素
int slinket_list_delete_back(SLinketList head,ETYPE *pelem);
//获取指定位置pos的元素 
int slinket_list_get(SLinketList head,size_t pos,ETYPE *pelem);
//获取第一个元素
int slinket_list_get_front(SLinketList head,ETYPE *pelem);
//获取最后一个元素
int slinket_list_get_back(SLinketList head,ETYPE *pelem);
//根据值key来查找   返回-1表示没有该值  否则返回位置 
int slinket_list_find(SLinketList head,ETYPE *pelem);
//遍历单向链表
void slinket_list_travel(SLinketList head,void (*travel)(int)); 
//删除所有元素  清空所有元素 
void slinket_list_clear(SLinketList head);
//销毁单向链表
void slinket_list_destroy(SLinketList head); 
//单向链表逆序
void slinket_list_reverse(SLinketList head);
//获取倒数第n个元素
int slinket_list_get_last(SLinketList head,size_t pos,ETYPE *pelem);//[1,... 
// a1,a2,a3... an-1,an    a1,an,a2,an-1,a3,an-2,...
void slinket_list_reset_seq(SLinketList head);
// 按指定元素个数逆序  a1,a2,a3,a4,a5,a6,a7,a8   a3,a2,a1,a6,a5,a4,a8,a7
void slinket_list_reverse_by_count(SLinketList head,size_t count); 
#endif //SINGLE_LINKET_LIST_H__

singlelinketlist.c

#include "singlelinketlist.h"
SLinketList slinket_list_create(void){
	struct Node* head = (struct Node*)malloc(NODESIZE);//头结点  
	if(head==NULL){
		return NULL;
	}
	head->next = NULL;
	return head;
}
//判断单向链表是否为空 
bool slinket_list_is_empty(SLinketList head){//head 指针 指向头结点    *head头结点 
	return head->next == NULL; //(*head).next == NULL     
}
//单向链表中元素的个数
size_t slinket_list_size(SLinketList head){
	size_t size = 0;
	struct Node *node = head->next;//head指向头结点   head->next指向第一个结点 
	while(node != NULL){
		size++;
		node = node->next;//让node指针指向下一个节点 
	} 
	return size; 
}
//获取pos位置的前一个结点  如果pos过大，返回NULL 
static struct Node * slinket_list_get_prev_node(SLinketList head,size_t pos){
	struct Node *node = head; 
	size_t i;
	for(i=0;node!=NULL&&i<pos;i++){
		node = node->next;
	}
	return node;
} 
//在指定位置pos插入一个元素elem  第一个位置默认为0 
int slinket_list_insert(SLinketList head,size_t pos,ETYPE elem){	//要获取pos-1节点的指针  pos==0 头结点
	struct Node *prev = slinket_list_get_prev_node(head,pos);
	if(prev == NULL){
		return -1;
	}
	struct Node *node = (struct Node *)malloc(NODESIZE);
	if(node==NULL){
		return -2;
	}
	node->elem = elem;
	node->next = prev->next;
	prev->next = node;
	return 0;
}
//在单向链表前面插入一个元素elem
int slinket_list_insert_front(SLinketList head,ETYPE elem){
	struct Node *node = (struct Node *)malloc(NODESIZE);
	if(node==NULL){
		return -1;
	}
	node->elem = elem;
	node->next = head->next;
	head->next = node;
	return 0;
}
//在单向链表末尾插入一个元素elem
int slinket_list_insert_back(SLinketList head,ETYPE elem){
	//size_t size = slinket_list_size(head);
	//return slinket_list_insert(head,sie,elem);
	struct Node *last = head;
	while(last->next!=NULL){
		last = last->next;
	}
	//last->next == NULL
	//last->next = (struct Node *)malloc(NODESIZE);
	//last->next->elem = elem;  
	//last->next->next = NULL;
	struct Node *node = (struct Node *)malloc(NODESIZE);
	node->elem = elem;
	node->next = NULL;
	last->next = node;
	return 0;
}
//删除指定位置pos的元素
int slinket_list_delete(SLinketList head,size_t pos,ETYPE *pelem){
	struct Node *prev = slinket_list_get_prev_node(head,pos);
	if(prev == NULL || prev->next == NULL){
		return -1;
	}
	struct Node *curr = prev->next;
	prev->next = curr->next;
	*pelem = curr->elem;
	free(curr);
	return 0;
}
//删除单向链表第一个元素
int slinket_list_delete_front(SLinketList head,ETYPE *pelem){
	if(head->next == NULL){
		return -1;
	}
	*pelem = head->next->elem;
	struct Node *first = head->next;
	head->next = first->next;
	free(first);
	return 0;
}
//删除末尾的元素
int slinket_list_delete_back(SLinketList head,ETYPE *pelem){
	if(head->next == NULL){
		return -1;
	} 
	//size_t size = slinket_list_size(head);
	//return slinket_lsit_delete(head,size-1,pelem);
	struct Node *lastSec = head;
	while(lastSec->next->next != NULL){
		lastSec = lastSec->next;
	}
	//lastSec记录的是倒数第二个结点
	*pelem = lastSec->next->elem; 
	free(lastSec->next);//释放最后一个结点的内存 
	lastSec->next = NULL; 
	return 0; 
}
//获取指定位置pos的元素 
int slinket_list_get(SLinketList head,size_t pos,ETYPE *pelem){
	struct Node *node = slinket_list_get_prev_node(head,pos+1);
	if(node == NULL){
		return -1;
	}
	*pelem = node->elem;
	return 0;
}
//获取第一个元素
int slinket_list_get_front(SLinketList head,ETYPE *pelem){
	if(head->next == NULL){
		return -1;
	}
	*pelem = head->next->elem;
	return 0;
}
//获取最后一个元素
int slinket_list_get_back(SLinketList head,ETYPE *pelem){
	if(head->next == NULL){
		return -1;
	}
	struct Node *last = head->next;
	while(last->next != NULL){
		last = last->next; 
	}
	*pelem = last->elem;
	return 0;
}
//根据值key来查找   返回-1表示没有该值  否则返回位置 
int slinket_list_find(SLinketList head,ETYPE *pelem){
	struct Node *node = head->next;
	size_t i;
	for(i=0;node!=NULL;node=node->next,i++){
		if(node->elem == *pelem){
			return i;
		} 
	}
	return -1;
}
//遍历单向链表
void slinket_list_travel(SLinketList head,void (*travel)(int)){
	struct Node *node = head->next;
	while(node!=NULL){
		travel(node->elem);
		node = node->next;
	}
}

//删除所有元素  清空所有元素 
void slinket_list_clear(SLinketList head){
	struct Node *node,*next;
	for(node=head->next;node!=NULL;node=next){
		next = node->next;//提前保存node后面一个节点的位置 
		free(node);//释放node所指向的结点内存 
	}
	head->next = NULL;
}
//销毁单向链表
void slinket_list_destroy(SLinketList head){
	slinket_list_clear(head);
	free(head);//释放头结点的内存空间 
} 

//单向链表逆序
void slinket_list_reverse(SLinketList head){
	//没有结点 或者 只有一个结点 不需要做任何事情  
	if(head->next == NULL || head->next->next == NULL){
		return;
	}
	struct Node *prev = NULL;
	struct Node *curr = head->next;
	struct Node *next = NULL;
	while(curr!=NULL){
		next = curr->next; //保存当前结点的下一个结点的位置
		curr->next = prev; //逆转当前curr结点  指向原来的前结点
		prev = curr;
		curr = next; 
	}
	head->next = prev;
}
//获取倒数第n个元素
int slinket_list_get_last(SLinketList head,size_t pos,ETYPE *pelem){
	struct Node *front = head->next;
	struct Node *back = head->next;
	size_t i;
	for(i=1;front!=NULL&&i<pos;i++){
		front = front->next;//先让front先走pos-1步 
	}
	if(front == NULL){
		return -1;
	}
	while(front->next!=NULL){
		front = front->next;
		back = back->next; 
	}
	//front指向最后一个  back指向前面 pos-1
	*pelem = back->elem;
	return 0; 
}
// a1,a2,a3... an-1,an    a1,an,a2,an-1,a3,an-2,...
// 1 2 3 4 5 6 7 8 9 10   1 10 2 9 3 8 4 7 5 6

void slinket_list_reset_seq(SLinketList head){
	size_t size = slinket_list_size(head);
	if(size<=2)
		return;
	size_t i;
	struct Node *node = head->next;
	for(i=0;i<size/2;i++){
		node = node->next;
	}
	//node 作为头结点一样使用 
	slinket_list_reverse(node);
	struct Node *front = node->next, *back = head->next;
	node->next = NULL;
	node = head;
	bool flag = true;
	while(front!=NULL && back!=NULL){	
		node->next = back;
		back = back->next;
		node = node->next;
		node->next = front;
		front = front->next;
		node = node->next;				
xt = back;	
}

void slinket_list_reverse_by_count(SLinketList head,size_t count){
	struct Node *prev = NULL;
	struct Node *curr = head->next;
	struct Node *next = NULL;
	struct Node *last = head;//上次逆转之后的最后一个结点
	struct Node *first = NULL; 
	size_t i=0;
	while(curr != NULL){
		first = curr;//记录该次逆序的第一个结点  
		for(i=0;curr!=NULL&&i<count;i++){
			next = curr->next;
			curr->next = prev;
			prev = curr;
			curr = next;
		}
		last->next = prev;//上次逆转之后最后一个结点的下一个结点应该
		last = first; 
	}
	last->next = NULL;
}
Mark_Chalers
关注
专栏目录
【数据结构】超详细之单向链表（C语言实现）
m0_74088266的博客
05-03 1082
今天我要介绍单向链表，单向链表与之前我们学的顺序表作用相同，但与顺序表相比，单向链表使用起来更加灵活，效率更高，是一种非常常见且实用的数据结构.
单向链表c语言实现数据结构
09-18
通过这样的C语言实现，我们可以灵活地处理动态数据集，比如存储和操作一组未知大小的整数。单向链表虽然不如数组访问速度快，但其动态性使得它在许多场景下成为更合适的选择。理解并能熟练运用链表的实现对于学习...
十三种排序算法实现
weixin_52018610的博客
09-07 733
这里写目录标题内部排序插入直接折半二路希尔选择直接二路堆交换冒泡鸡尾酒快速归并二路归并基数计数外部排序 内部排序 插入 直接 void insert(int arr[],int n){//时间复杂度O(n^2) 空间复杂度 O(1) int i,j; for(i=1;i<n;i++){ int key=arr[i]; for(j=i-1;j>=0&&arr[j]>key;j--){ arr[j+1]=arr[j]; } arr[j+1]=key
C语言实现单向链表
最新发布
2401_86557724的博客
09-09 1261
本章使用C语言实现了数据结构中的单向链表，难度也不高，但值得作为学习数据结构的人去亲自实现一下。
单链表c语言实现,单向链表 c语言实现
weixin_36125445的博客
05-19 303
定义(引用百度百科)单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。场景在实际生产中，有可能在软件启动后，对一些数据进行多态扩容，比如，网卡收发包的时候，从协议栈上产生一个需求的包，需要暂时排队，等网卡把...
c语言单向链表的简单程序,C语言-------实现一个简单的单向链表
weixin_36155936的博客
05-20 457
#include #include struct node{int num;char name[20];struct node* next; //指向下一个地址的指针}; //声明一个链表,此时内存不分配内存typedef struct node Node; //重命名,便于书写,太长了struct nodetypedef struct node* Link;//构造函数,实现传过来的头指针指...
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
单向链表C语言实现
zcg_741454897的博客
11-05 1509
list.h #pragma once #ifndef _LIST_H #define _LIST_H struct Node { int data; struct Node * next; }; struct Header { int length; struct Node * next; }; typedef struct Node List; typedef struct H...
C语言实现带头结点的单向链表的基本操作
04-04
使用C语言实现了单向链表的创建，输出，插入元素和删除元素以及单向链表的逆序连接和两个有序线性表的归并
单向链表的C语言实现与基本操作
热门推荐
TECH_PRO的博客
04-17 5万+
本文的主要内容目录： 一、单向链表的C语言实现 二、单向链表的基本操作 一、单向链表的C语言实现 链表作为一种基本的数据结构在程序开发过程当中经常会使用到。对C语言来说链表的实现主要依靠结构体和指针，所以本文相关内容和程序需要有C语言当中指针和结构体的基础。 链表是一种线性存储数据的结构，存储内容在逻辑上连续的，在物理上却不一定连续。单向链表的组成包括一个链表头（head）和若干
单向链表C语言实现详解
hurryddd
11-25 480
目录 一、单向链表数据结构 二、单向链表增删改查函数声明 三、创建链表 1、链表头部动态创建 2、链表头部静态创建 四、节点添加 1、 头插法 2、 尾插法 3、 位置节点前或后插入 五、节点删除 六、链表清空 七、链表销毁 八、验证程序 一、单向链表数据结构 struct singal_list_node { struct singal_list_node...
C语言实现单向链表的各种操作
sinat_32771101的博客
11-14 318
1、单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 链表中的数据是以节点来表示的，每个结点的构成：元素( 数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 2、下面附上自己实现的代码，欢迎大家批评 特别说明：对于链表的逆序，实现思路是头插法实现反转 /*********************...
单链表的C语言实现
Monster_Girl
12-09 933
在学习数据结构中，紧接着顺序表接触的就是单链表，那么单链表是什么呢？ 1.什么是单链表？ 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
数据结构——单向链表（C语言版）
2301_80220607的博客
03-22 2667
数据结构单向链表简单直白的教学
【数据结构】单链表的实现(C语言实现）
ajin156的博客
06-08 1882
链表的定义及其分类，无头单向非循环链表的增删改查各个接口的实现
C语言实现单向链表的基本操作
"这篇资源是关于单向链表的基础知识，包括如何在C语言中实现单向链表的初始化、创建、销毁等操作。" 在数据结构中，链表是一种非常重要的非线性数据结构。单向链表是其中一种形式，每个节点包含一个数据元素和一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值