数据结构_链表

于 2021-04-25 23:13:00 发布
阅读量154 收藏
点赞数
分类专栏： 数据结构学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44342705/article/details/116140500
版权

链表

类型：
单向链表：
双向链表：
- 双向链表的前向指针指向前一个结点的首地址，后向指针指向下一个节点的首地址，并且指针类型相同，且只能指向与自己类型相同的结构体。
循环链表：
通用链表：
- 通用链表的前向指针指向前一个结点的指针域的首地址，后向指针指向下一个节点的指针域的首地址，所以在不同的结构体中定义相同的指针域就可以了，也就是说，单独定义一个结构体类型，其成员只有指针域，并且在其他结构体中定义这种结构体类型的变量。

单向链表

  • 单向单指针操作
/*
 * 3_stu_input.c
现有学生结构体(id,name,score),写代码实现
(1)从键盘初始化学员
(2)使用链表
(3)遍历打印所有学员
 */


#include <stdio.h>
#include <stdlib.h>
#define SIZE 3
struct student
	{
		char name[20];
		int id;
		int score;
		struct student* next;
	};
typedef struct student stud;
void output(void);
void insert(void);
stud* creat(stud* p);

stud* head=NULL;

int main(void)
{
	head=creat(head);
	char n='\0';
	while(n!='q'){
		insert();
		printf("按任意键继续，或者按'q'退出：\n");
		while(getchar()!='\n');
		scanf("%c",&n);
		
	}
	printf("输入的学生信息为：\n");
	output();
	
	return 0;
}
stud* creat(stud* p){
	p=(stud*)malloc(sizeof(stud));
	p->next=NULL;
	return p;
}
	
void insert(void){
	stud* p=(stud*)malloc(sizeof(stud));
	printf("请输入学生的学号，名字和成绩：");
	scanf("%d %s %d",&p->id,p->name, &p->score);
	p->next=NULL;
	
	stud* current = head; 
	while(current->next!=NULL) current=current->next;
	current->next=p;

}

void output(void){
	for(stud* current=head; 
			current->next!=NULL; current=current->next)	
		printf("%d %s %d\n",current->next->id,current->next->name, current->next->score);
}//此处判断到结点指向NULL就会退出，无法输出最终项，所以使用current=head，current->next->name来输出。

双向链表

  • 链表结点数据结构定义
struct xLIST_ITEM
{
	TickType_t xItemValue;					//辅助值，用于帮助节点进行排序
	struct xLIST_ITEM* pxNext;			//指向链表下一个节点
	struct xLIST_ITEM* pxPrevious;		//指向链表上一个节点
	void* pvOwner;   //指向拥有该节点的对象
	void* pvContainer;  //指向该节点所在的链表
};
typedef struct xLIST_ITEM ListItem_t;
  • 链表节点初始化
void vListInitializeItem(ListItem_t* const pxItem)
{
	//初始化该节点所在链表为空，表示节点还未插入任何链表
	pxItem->pvContainer = NULL;
}
  • 链表根节点数据结构定义
typedef struct xList
{
	UBaseType_t uxNumberOfItems;	//链表节点计数器
	ListItem_t* pxIndex;	//链表节点索引指针
	MiniListItem_t xListEnd;	//链表最后一个节点
}List_t;
  • 链表精简节点结构体定义
struct xMINI_LIST_ITEM
{
	TickType_t xItemValue;					//辅助值，用于帮助节点进行排序
	struct xLIST_ITEM* pxNext;			//指向链表下一个节点
	struct xLIST_ITEM* pxPrevious;		//指向链表上一个节点
};
typedef struct xMINI_LIST_ITEM MiniListItem_t;
  • 链表根节点的初始化
void vListInitialize(List_t* const pxList)
{
	//将链表索引指针指向最后一个节点
	pxList->pxIndex = (ListItem_t*) &(pxList->xListEnd);	
	
	//将链表最后一个节点的辅助排序值设置最大
	pxList->xListEnd.xItemValue = portMAX_DELAY;
	
	//将最后一个节点的next 和 previous指针均指向节点本身，表示链表为空
	pxList->xListEnd.pxNext = (ListItem_t*) &(pxList->xListEnd);	
	pxList->xListEnd.pxPrevious = (ListItem_t*) &(pxList->xListEnd);	
	
	//初始化链表计数器值为0,表示链表为空
	pxList->uxNumberOfItems = (UBaseType_t) 0U;
	
}

双向循环链表操作

/*双循环通用链表*/

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

typedef struct Link link_t;
 
struct Link
{
	void *data;
	link_t *pre;
	link_t *next;
};

link_t* creathead(void);
link_t* creatnode(void); 
link_t* insertnode(link_t *head, void *data, int size);
void display_link(link_t *head); 
void destroy_allnode(link_t *head); 

void sort_link(link_t *start, link_t *end, int (*cp)(const void *, const void *));
int compare(const void* p1, const void *p2);

int main(void)
{
	int data = 0;
	link_t *head = creathead();
	for (int i = 0; i < 10; i++){
		data = rand() % 100;
		insertnode(head, &data, sizeof(data));
	}
	
	display_link(head); 
	sort_link(head->next, head->pre, compare);
	display_link(head); 
	
	destroy_allnode(head);
	
	return 0;
}

link_t* creathead(void)
{
	link_t *head = NULL;
	head = (link_t*)malloc(sizeof(link_t)); 
	if (NULL == head){
		perror("malloc failed!");
		return NULL;
	}
	memset(head, 0, sizeof(link_t));
	head->pre = head;
	head->next = head;
	
	return head;
}

link_t* creatnode(void)
{
	link_t *p = NULL;
	p = (link_t*)malloc(sizeof(link_t)); 
	if (NULL == p){
		perror("malloc failed!");
		return NULL;
	}
	memset(p, 0, sizeof(link_t));
	
	return p;
}

//尾插
link_t* insertnode(link_t *head, void *data, int size)
{
	link_t *node = NULL;
	if (NULL == head || NULL == data){
		return NULL;
	}
	node = creatnode(); //创建节点
	if (NULL == node){
		printf("node is null!");
		return NULL;
	}
	node->data = malloc(size); //扩展一个data数据长度的空间
	if (NULL == node->data){ //创建失败则返回
		free(node);
		return NULL;
	}
	memcpy(node->data, data, size); //将数据内存拷贝给节点数据指针
	
	head->pre->next = node;	//最后一个节点为head->pre 
	node->pre = head->pre;
	node->next = head;
	head->pre = node;
	
	return node;
}

link_t *findnode(link_t *head, void *data, int (*cp)(const void *, const void *))
{
	link_t *p = NULL;
	if (NULL == head){
		return NULL;
	}
	p =  head->next; 
	while (p != head){
		if (cp(p->data, data) == 0){
			return p;
		} 
		p = p->next;
	} 
	
	return NULL;
}

link_t* deletenode(link_t *head, void *data, int (*cp)(const void *, const void *))
{
	link_t *p = NULL;
	if (NULL == head){
		return NULL;
	}
	p = findnode(head, data, cp);
	if (NULL == p){
		return p;
	}
	p->pre->next = p->next;
	p->next->pre = p->pre;
	
	free(p->data);
	free(p);
	p = NULL;
	
	return head;
}

link_t* updatenode(link_t *head, void *alter, void *data, int size, int (*cp)(const void *, const void *))
{
	link_t *p = NULL;
	if (NULL == head){
		return NULL;
	}
	p = findnode(head, alter, cp);
	if (NULL == p){
		return p;
	}
	memcpy(p->data, data, size); 
	
	return p;
}

void sort_link(link_t *start, link_t *end, int (*cp)(const void *, const void *))
{
	link_t *l = NULL, *r = NULL;
	void *key = NULL;
	if (NULL == start || NULL == end || start == end || end->next == start || start->pre == end) 
	{
		return;
	}
	l = start, r = end;
	key = l->data;
	while (l != r){
		while(l != r && cp(key, r->data) > 0){ 
			r = r->pre;
		}
		l->data = r->data;
		while(l != r && cp(l->data, key) > 0){
			l = l->next;
		}
		r->data = l->data;
	}
	l->data = key;
	sort_link(start, l->pre, cp);
	sort_link(l->next, end, cp);
}

void display_link(link_t *head)
{
	link_t *p = NULL;
	if (NULL == head){
		return;
	}
	p =  head->next;
	while (p != head){
		printf("%d ", *(int*)p->data);
		p = p->next;
	}
	putchar('\n');
}

void destroy_allnode(link_t *head)
{
	link_t *p = NULL;
	if (NULL == head){
		return;
	} 
	while (head->pre != head){
		p = head->pre;
		head->pre = p->pre;
		free(p->data);
		free(p);
	}
	free(head);
}

int compare(const void* p1, const void *p2)
{
	return *(int*)p1 >= *(int*)p2;
}

通用链表

  • 声明和宏定义：
#ifndef __LIST_HEAD_H__
#define __LIST_HEAD_H__

//通用链表节点类型  双向链表
struct list_head{
    struct list_head *prev; //前级指针
    struct list_head *next;//后级指针
};

void INIT_LIST_HEAD(struct list_head *list);//初始化通用链表
void list_add(struct list_head *node,struct list_head *head);//插入节点
void list_add_tail(struct list_head *node,struct list_head *head);//尾插
void list_del(struct list_head *node);//删除节点

/*遍历链表  依次为：从头节点的下一个节点开始遍历   
*           从头节点的上一个节点开始遍历
*（以list_for_next_each为例理解：首先节点指针pos指向头节点的下一个节点，判断 pos是否指向头节点，不是的话就向后继续遍历）
*/
#define list_for_next_each(pos,head)\for(pos=(head)->next;pos!=(head);pos=pos->next)#define list_for_prev_each(pos,head)\for(pos=(head)->prev;pos!=(head);pos=pos->prev)

//提取数据结构   ptr 是链接因子的指针  type是包含了链接因子的数据类型  member是链接因子成员名
#define container_of(ptr,type,member)\
    (type *)( (int)ptr - (int)(&((type *)0)->member) )

#endif
  • 链表操作函数：
#include "list_head.h"

void INIT_LIST_HEAD(struct list_head *list)//初始化通用链表
{
    //前后级指针都指向本身
    list->next=list;
    list->prev=list;
}
void list_add(struct list_head *node,struct list_head *head)//插入节点
{
    node->next=head->next;
    node->prev=head;
    head->next->prev=node;
    head->next=node;

}
void list_add_tail(struct list_head *node,struct list_head *head)//尾插
{
    node->next=head->prev;
    node->prev=head;
    head->prev->next=node;
    head->prev=node;
}
void list_del(struct list_head *node)//删除节点
{
        node->prev->next=node->next;
        node->next->prev=node->prev;
}
  • 数据定义：
#ifndef __STU_H__
#define __STU_H__
#define N 32
#include "list_head.h"
struct STU{
    int id;
    char name[N];
    char pwd[N];
    float score;
    struct list_head list;//链接因子
};
#endif
  • 测试文件：
#include <stdio.h>
#include <stdlib.h>
#include "list_head.h"
#include "stu.h"

int main(int argc, const char *argv[])
{

    int i;
    struct STU *stu;
    struct STU *stup;
    struct list_head *pos;
    struct list_head stu_list;//学生表的首节点

    stu=(struct STU *)malloc(sizeof(struct STU)*5);  //分配节点空间
    if(!stu)
    {
        perror("fail to malloc");
        return -1;
    }

    //初始化通用链表
    INIT_LIST_HEAD(&stu_list);
    for(i=0;i<5;i++)  //赋值学生信息
    {
        stu[i].id=i;
        sprintf(stu[i].name,"stu%d",i);
        sprintf(stu[i].pwd,"160%d",i);
        stu[i].score=10*i;
        list_add(&stu[i].list,&stu_list);//插入链表
    }

    //遍历学生信息
    list_for_next_each(pos,&stu_list)
    {
        stup=container_of(pos,struct STU,list);
        printf("stu:id=%d,name=%s,pwd=%s,score=%f\n",\
                stup->id,stup->name,stup->pwd,stup->score);
    }

    puts("--------------------------------");

    list_for_prev_each(pos,&stu_list)
    {
        stup=container_of(pos,struct STU,list);
        printf("stu:id=%d,name=%s,pwd=%s,score=%f\n",\
                stup->id,stup->name,stup->pwd,stup->score);
    }

    return 0;
}
Leslie X徐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的数据结构
HelloJFS的博客
12-30 297
链表结构的定义：链表应该由三部分部分组成： 结点： 结点由结点的值和指针（每个独立的结点只申明指针，并不指向具体的对象） 表头 结点指针指向的对象 链表定义一个大类： 表头（变量） 结点（类） 尾部添加结点（方法）：结点的值添加在哪个结点的后面，当然新增加的结点只能在最后： 添加结点方法的描述： 新定义一个结点； 判断有没有头结点，如果没有头结点，就将新结点作为头结点； 如果有头结点，就取出头结点，
数据结构：链表的基本操作
m0_51148715的博客
02-04 1661
链表，一种重要的数据结构。它与数组不同，数组是分配一段连续的存储空间；而链表则是动态地分配离散空间，并用指针串联。 下面是链表的基本操作。 #include "stdio.h" #include "stdlib.h" #define OK 1 #define ERROR 0 typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; ElemType length; struct LNode *n
C语言_结构体练习
weixin_44342705的博客
04-15 3262
2021-04-15 结构体练习 结构体及变量 struct 结构体名 { 成员列表; } 结构体变量名; 结构体作为函数参数和返回值 struct student avg_fun(struct student s) { s.avg=(s.Chinese+s.English+s.Math)/3.0; return s; } 结构体的嵌套，链式访问 注意：结构体不能嵌套它自身（除非是结构体指针类型） struct score { int Chinese; int English;
【C语言】用结构体数组完成：有5个学生（包括学号，姓名，成绩），要求按照成绩高低输出学生信息.
热门推荐
韩豆豆的博客
04-13 8万+
//用结构体数组完成：有5个学生（包括学号，姓名，成绩），要求按照成绩高低输出学生信息 #include struct Stu { int num; char name[20]; int score; }; int main() { int i,j; struct Stu student[5]={{317,"han",89},{318,"hu",50},{319,"kang",84},
C语言-请定义一个结构体类型，能够存储学生的姓名，学号，分数。定义结构体变量。定义10个元素的此结构体的数组，然后循环遍历，从键盘获取数据输入进去。
weixin_45880658的博客
07-21 5105
#include<stdio.h> #include<stdlib.h> #include<string.h> #define Max 10 struct Student { char Name[100]; int StudentID; int score; }student; int main(int* arcg, char* argv[]) { struct Student su; fo..
数据结构_链表的分类_数据结构_
10-02
数据结构C语言的入门，数据链表的分类，能够帮助你学习数据结构
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
数据结构的链表关系，用TC2.0 编写，比较完整，可以作为学生的教学用
数据结构_队列_链表1
08-03
数据结构_队列_链表1
ds_lab_3_链表_链表操作_数据结构_
10-02
使用C语言实现了基本的链表操作，为处理链式结构的数据提供支持。
<C语言>结构体的各种定义、初始化、操作代码实例----注释详解
WSG的博客--盛年不重来,一日难再晨.及时当勉励,岁月不待人.
08-14 1274
//>>>>>>>> //作者：wsg //时间：2017年8月14日 #include #include struct student //定义结构体模板 { char name[50]; int age; float score; }; /* //还可以这样定义 struct student { char name[50]; int age; float score; }
sql语句面试题
颜小小的博客
12-19 2359
1）请编写sql语句对年龄进行升序排列 select * from afinfo order by birth; 2）请编写sql语句查询对“徐”姓开头的人员名单 select * from afinfo where name like ‘徐%’; 3）请编写sql语句修改“陈晓”的年龄为“45” update afinfo set age=45 and birth=birth-YEAR(45) where name=“陈晓”; 4）请编写sql删除王芳芳这表数据记录。 delete from afinfo
C语言：用结构体类型建立一个学生的简单信息表，再定义一个结构体变量并赋值，输出学号、姓名及一门课程的成绩
Caleb Sung的博客
05-26 2万+
题目来源：大工慕课 链接 作者：Caleb Sung 题目要求 建立一个学生的简单信息表，包括学号、姓名及一门课程的成绩。（注：定义一个结构体类型，再定义一个结构体变量并赋值，输出结构体变量各成员。） 参考代码 #include "stdio.h" void main(){ struct Student{ char id[10]; char...
定义结构体，包含学生学号，姓名和3门课成绩
lyz1_2_3的博客
05-12 4万+
定义结构体，包含学生学号，姓名和3门课成绩。定义一个函数，求若干学生的平均成绩（主函数负责结构体数组的定义和输入） #include <stdio.h> struct student//定义结构体变量并初始化 { long int num; char name[20]; float score[3]; } stu[3]; void printf();//定义输出函数 int main() { int i,j; for(i=0;i<=2;i++) { print
ListNode链表
zdj666666的博客
04-11 5725
            ListNode链表此类里面是:                public class ListNode{                ListNode next=null;                int val;                public ListNode(int val){                this.val=val;     ...
C语言-请定义一个结构体类型，能够存储学生的姓名，学号，分数。定义结构体变量，初始化为xiaoming,15,95.将变量传入到函数中，修改为xiaohong,18,100。
weixin_45880658的博客
07-21 1586
#include<stdio.h> #include<stdlib.h> #include<string.h> struct Student { char Name[100]; int StudentID; int score; }student = { "xiaoming",15, 95 }; void Display(struct Student su) {//指针类型访问(char *p) p-&g...
结构体成员和结构体指针初始化
hk121的博客
06-28 6621
#include&lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;string&gt;struct student{    char *name;    int score;    struct student* next;   }stu,*stu1;    int main(){     stu.name = (char*)malloc(s...
结构体初始化及结构体指针.结构体数组.结构体函数的调用赋值等
Mr.Wang的博客
07-30 6206
#include "stdio.h" #include "stdlib.h" #include "string.h" int fun(void); int ARRSCORE[3]={133,123,124};    //学生  姓名 性别  年龄 考试成绩 struct STWDENT {     char name[10]; char sex; int age; i
数据结构python链表
最新发布
11-05
链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表可以分为单向链表和双向链表两种类型。在Python中，我们可以通过定义节点类和链表类来实现链表数据结构。节点类包含数据和指向下一个节点的指针，链表类包含头节点和一些基本操作方法，如插入、删除、查找等。具体实现可以参考引用中的资料。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值