线性结构——双向链表

最新推荐文章于 2024-04-24 16:09:08 发布
最新推荐文章于 2024-04-24 16:09:08 发布
阅读量1k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangliang19950813/article/details/121263725
版权

一、概念

双向链表概念

( double linked List) 是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。所以在双向链表中的结点都有两个指针域， 一个指向直接后继，另一个指向直接前驱。

在这里插入图片描述

二、双向不循环链表

在这里插入图片描述

2.1 定义数据类型

typedef void * datatype;
typedef struct list_s
{
  struct list_s *prev;  //指向直接前驱
  datatype data;        //数据域
  struct list_s *next;  //指向直接后驱
}list_t;

2.2 生成头节点

list_t *create_list(void)  //新建双向链表
{
	list_t *list = NULL;
	
	list = malloc(sizeof(*list));
	list->data = NULL;
	list->prev = NULL;
	list->next = NULL;

	return list;
}

2.3 插入节点

2.3.1 头/尾插

enum
{
	HEADLIST,
	TRAILLIST
};

int insert_list (list_t *head,const datatype data,int datasize,int mode)  //头插、尾插数据
{
  list_t *new = NULL;
  list_t *q = NULL;
  
  new = malloc( sizeof(*new) );
  new->data = malloc(sizeof(datasize));
  new->prev = NULL;
  new->next = NULL;
  memcpy(new->data,data,datasize);

  switch(mode) {
	case HEADLIST:
		new->next=head->next;
		new->prev=head;
		head->next->prev = new;  //必须保证至少有一个数据节点
		head->next=new;
		break;
	case TRAILLIST:
      for (q = head; q->next != NULL; q = q->next);
      q->next = new;
      new->prev = q;
		break;
	default:
		free(new->data);
		free(new);
		return -1;
	}

	return 0;
}

2.3.2 选择插

int insert_select_list (list_t *head, int num, datatype data)  //选择插
{
  int i;
  list_t *q = NULL;
  list_t *new = NULL;

  if (doulist_length (head) < num || num <= 1) {
    printf ("insert_select_list num is erorr!\n");
    return -1;
  }
  
  new = malloc( sizeof(*new) );
  new->data = malloc(sizeof (int));
  new->prev = NULL;
  new->next = NULL;
  memcpy(new->data,data,sizeof(int));
  
  for (i = 1, q = head; q->next != NULL; i++, q = q->next) {
    if (i == num) {
      new->next = q->next;
      new->prev = q;
      new->next->prev = new;
      q->next = new;
      return 0;
    } 
  }

  return -1;
}

2.4 打印

int display_list (list_t *head)  //打印链表
{
	list_t *list;
  
  printf ("head : %p <--> ",head);
	for(list = head->next; list != NULL ; list = list->next) {
		printf(" %d - %p < -- > ",*((int *)(list->data)), list);
	}
  printf ("\n");

	return 0;
}

2.5 判空

int isempty_list (list_t *head)  //判空
{
  return head->next == NULL ? 1 : 0;
}

2.6 返回链表长度

int doulist_length (list_t *head) //返回链表长度
{
  int i;
  list_t *q = NULL;

  for (i = 0, q = head; q->next != NULL; q = q->next, i++);

  return i;
}

2.7 删除链表某个节点

int delete_list(list_t *head, const datatype data, int datasize) //删除链表某个节点
{
	list_t *q = NULL;
	if(isempty_list(head))
		return -1;

	for(q = head->next; q != NULL; q = q->next) {
		if(!memcmp(q->data,data,datasize)) {
			q->prev->next=q->next;
			q->next->prev=q->prev;
      free (q->data);
			return -1;
		}
	}
 
	return 0;
}

2.8 排序

int func_order(void *s1, void *s2)        //作为函数指针,顺序
{
	return *((int *)s1) - *((int *)s2);
}

int func_invert(void *s1, void *s2)        //作为函数指针,反序
{
	return *((int *)s2) - *((int *)s1);
}


int sort_list(list_t *head,int (*sort)(void *,void *))  //排序
{
	list_t *p;

	int i, num, length;
  
  length = doulist_length (head);

	for(i = 0; i < length - 1; i++) {
    num = length - i - 1;
    
		for(p = head->next; num > 0; p = p->next, num--)
		{
			if(sort(p->data, p->next->data) > 0) {
				void *tmp = p->data;
				p->data = p->next->data;
				p->next->data = tmp;
			}
		}
	}
	return 0;
}

2.9 查找某个数据

int find_list(list_t *head,const datatype data,int datasize) //查找某个数据
{
	list_t *q = NULL;

	for(q = head->next; q != NULL; q = q->next) {
		if( !memcmp (q->data,data,datasize) ) {
			printf ("find data: %d\n",*((int *)(q->data)));
      return 0;
		}
	}

	return -1;
}

2.10 销毁链表

void destory_list (list_t *head)  //销毁链表
{
	list_t *q = NULL;

	for(q = head->next->next; q != NULL; q = q->next) {
		free(q->prev->data);
		free(q->prev);
	}

	free(head->data);
	free(head);
}

2.11 测试

int main(void)
{
  list_t *list = NULL;
  int data[10] = {8, 10, 7, 1, 6, 4, 9, 2, 3, 5};
  
  list = create_list ();
  if (isempty_list (list) ) {
    printf ("doulist is null !\n");
  }
  insert_list (list, &data[0], sizeof (int), TRAILLIST);
  insert_list (list, &data[1], sizeof (int), TRAILLIST);
  insert_list (list, &data[2], sizeof (int), TRAILLIST);
  insert_list (list, &data[3], sizeof (int), TRAILLIST);
  printf ("tail insert, doulist length is : %d\n",doulist_length(list));
  display_list (list);

  insert_list (list, &data[4], sizeof (int), HEADLIST);
  insert_list (list, &data[5], sizeof (int), HEADLIST);
  insert_list (list, &data[6], sizeof (int), HEADLIST);
  insert_list (list, &data[7], sizeof (int), HEADLIST);
  printf ("head insert, doulist length is : %d\n",doulist_length(list));
  display_list (list);

  insert_select_list (list, 2, &data[8]);
  insert_select_list (list, 2, &data[9]);
  printf ("select insert, doulist length is : %d\n",doulist_length(list));
  display_list (list);

  delete_list(list, &data[1], sizeof (int));
  printf ("delete data: 10, doulist length is : %d\n",doulist_length(list));
  display_list (list);
  
  sort_list (list, func_order);
  printf ("order sort data, doulist length is : %d\n",doulist_length(list));
  display_list (list);

  sort_list (list, func_invert);
  printf ("invert sort data, doulist length is : %d\n",doulist_length(list));
  display_list (list);
  
  find_list(list,  &data[2], sizeof (int));

  destory_list(list);

	return 0;
}

在这里插入图片描述

三、双向循环链表

3.1 定义数据类型

在这里插入图片描述

typedef void * datatype;

typedef struct list_s
{
	struct list_s *prev;  //指向直接前驱
  datatype data;        //数据域
	struct list_s *next;  //指向直接后驱
}list_t;

3.2 生成节点

list_t *create_listloop(void)  //新建双向链表
{
	list_t *list = NULL;
	
	list = malloc(sizeof(*list));
	list->data = NULL;
	list->prev = list;
	list->next = list;

	return list;
}

3.3 插入节点

3.3.1 头/尾插

enum
{
	HEADLIST,
	TRAILLIST
};

int insert_listloop (list_t *head,const datatype data,int datasize,int mode)  //头插、尾插数据
{
	list_t *new = NULL;
  list_t *q = NULL;

	new = malloc( sizeof(*new) );
	new->data = malloc(sizeof(datasize));
  new->prev = NULL;
  new->next = NULL;
	memcpy(new->data,data,datasize);

	switch(mode) {
	case HEADLIST:
		new->next=head->next;
		new->prev=head;
		head->next->prev = new;  //必须保证至少有一个数据节点
		head->next=new;
		break;

	case TRAILLIST:
    for (q = head; q->next != head; q = q->next);
    q->next = new;
    new->next = head;
    new->prev = q;
		break;

	default:
		free(new->data);
		free(new);
		return -1;
	}

	return 0;
}

3.3.2 选择插

int insert_select_listloop (list_t *head, int num, datatype data)  //选择插
{
  int i;
  list_t *q = NULL;
  list_t *new = NULL;

  if (doulistloop_length (head) < num || num <= 1) {
    printf ("insert_select_list num is erorr!\n");
    return -1;
  }
  
  new = malloc( sizeof(*new) );
	new->data = malloc(sizeof (int));
  new->prev = NULL;
  new->next = NULL;
	memcpy(new->data,data,sizeof(int));
  
  for (i = 1, q = head; q->next != head; i++, q = q->next) {
    if (i == num) {
      new->next = q->next;
      new->prev = q;
      new->next->prev = new;
      q->next = new;
      return 0;
    } 
  }

  return -1;
}

3.4 打印

int display_listloop (list_t *head)  //打印链表
{
	list_t *list;
  
  printf ("head : %p <--> ",head);
	for(list = head->next; list != head ; list = list->next) {
		printf(" %d - %p < -- > ",*((int *)(list->data)), list);
	}
  printf ("\n");

	return 0;
}

3.5 判空

int isempty_listloop (list_t *head)  //判空
{
	return head->next == head ? 1 : 0;
}

3.6 返回链表长度

int doulistloop_length (list_t *head) //返回链表长度
{
  int i;
  list_t *q = NULL;

  for (i = 0, q = head; q->next != head; q = q->next, i++);

  return i;
}

3.7 删除链表某个节点

int delete_listloop(list_t *head, const datatype data, int datasize) //删除链表某个节点
{
	list_t *q = NULL;
	if(isempty_listloop(head))
		return -1;

	for(q = head->next; q != head; q = q->next) {
		if(!memcmp(q->data,data,datasize)) {
			q->prev->next=q->next;
			q->next->prev=q->prev;
      free (q->data);
			return -1;
		}
	}
 
	return 0;
}

3.8 排序

int func_order(void *s1, void *s2)        //作为函数指针,顺序
{
	return *((int *)s1) - *((int *)s2);
}

int func_invert(void *s1, void *s2)        //作为函数指针,反序
{
	return *((int *)s2) - *((int *)s1);
}


int sort_listloop(list_t *head,int (*sort)(void *,void *))  //排序
{
	list_t *p;

	int i, num, length;
  
  length = doulistloop_length (head);

	for(i = 0; i < length - 1; i++) {
    num = length - i - 1;
    
		for(p = head->next; num > 0; p = p->next, num--)
		{
			if(sort(p->data, p->next->data) > 0) {
				void *tmp = p->data;
				p->data = p->next->data;
				p->next->data = tmp;
			}
		}
	}
	return 0;
}

3.9 查找某个数据

int find_listloop(list_t *head,const datatype data,int datasize) //查找某个数据
{
	list_t *q = NULL;

	for(q = head->next; q != head; q = q->next) {
		if( !memcmp (q->data,data,datasize) ) {
			printf ("find data: %d\n",*((int *)(q->data)));
      return 0;
		}
	}

	return -1;
}

3.10 销毁链表

void destory_listloop (list_t *head)  //销毁链表
{
	list_t *q = NULL;

	for(q = head->next->next; q != head; q = q->next) {
		free(q->prev->data);
		free(q->prev);
	}

	free(head->data);
	free(head);
}

3.11 测试

int main(void)
{
  list_t *list = NULL;
  int data[10] = {8, 10, 7, 1, 6, 4, 9, 2, 3, 5};
  
  list = create_listloop ();
  if (isempty_listloop (list) ) {
    printf ("doulist loop is null !\n");
  }

  insert_listloop (list, &data[0], sizeof (int), TRAILLIST);
  insert_listloop (list, &data[1], sizeof (int), TRAILLIST);
  insert_listloop (list, &data[2], sizeof (int), TRAILLIST);
  insert_listloop (list, &data[3], sizeof (int), TRAILLIST);
  printf ("tail insert, doulist loop length is : %d\n",doulistloop_length(list));
  display_listloop (list);

  insert_listloop (list, &data[4], sizeof (int), HEADLIST);
  insert_listloop (list, &data[5], sizeof (int), HEADLIST);
  insert_listloop (list, &data[6], sizeof (int), HEADLIST);
  insert_listloop (list, &data[7], sizeof (int), HEADLIST);
  printf ("head insert, doulist loop length is : %d\n",doulistloop_length(list));
  display_listloop (list);

  insert_select_listloop (list, 2, &data[8]);
  insert_select_listloop (list, 2, &data[9]);
  printf ("select insert, doulist loop length is : %d\n",doulistloop_length(list));
  display_listloop (list);

  delete_listloop(list, &data[1], sizeof (int));
  printf ("delete data: 10, doulist loop length is : %d\n",doulistloop_length(list));
  display_listloop (list);
  
  sort_listloop (list, func_order);
  printf ("order sort data, doulist loop length is : %d\n",doulistloop_length(list));
  display_listloop (list);

  sort_listloop (list, func_invert);
  printf ("invert sort data, doulist loop length is : %d\n",doulistloop_length(list));
  display_listloop (list);
  
  find_listloop(list,  &data[2], sizeof (int));

  destory_listloop(list);

	return 0;
}

在这里插入图片描述

Mr.小张
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#数据结构与算法揭秘三 链表
01-01
上文我们讨论了一种最简单的线性结构——顺序表，这节我们要讨论另一种线性结构——链表。 什么是链表了，不要求逻辑上相邻的数据元素在物理存储位置上也相邻存储的线性结构称之为链表。举个现实中的例子吧，假如一...
数据结构 — 双向链表
lio-zero 的博客
05-28 677
双向链表，又称为双链表，是一种表示元素集合的线性数据结构，其中每个元素都指向下一个和上一个元素。双向链表中的第一个元素是 head，最后一个元素是 tail。 JavaScript 双向链表可视化 双向链表数据结构的每个元素必须具有以下属性： value：元素的值 next：指向双向链表中下一个元素的指针(如果没有，则为 null) previous：指向双向链表中上一个元素的指...
【数据结构】线性表——带头双向循环链表
qq_65596720的博客
05-10 980
带头双向循环链表的优点 1.支持任意位置时间复杂度为O(1)的插入和删除。 2.按照需求申请释放空间，无需担心空间不够用，无需担心浪费。 3.带头可以省去链表为空时的判断，可以使代码更加简约 带头双向循环链表的缺点 1.不可以进行下标随机访问。 2.缓存利用率低 带头双向循环链表是线性表的一种，带头双向循环链表是链式存储的线性表，不同于顺序表，链表在内存空间中不连续。 带头：带头就是带哨兵位，可以省链表为空时进行的判断。 双向：由结构体内的next指针下一条数据进行链接，由prev对前一条数据
[Data structure]双链表 | 一文带你了解线性数据结构之一的双链表
逐梦苍穹的博客
05-13 1145
本文介绍数据结构的双向链表！
数据结构之线性结构--双向链表
无_空
10-02 4467
一、双向链表在单链表中若需要查找某一个元素时，都必须从第一个元素开始进行查找，而双向链表除开头节点和最后一个节点外每个节点中储存有两个指针，这连个指针分别指向前一个节点的地址和后一个节点的地址，这样无论通过那个节点都能够寻找到其他的节点。 二、双向链表的基本操作双链表的删除除元素的时候需要注意的是，他有一个指向前驱指针和一个指向下一个节点的指针，当元素被删除时，上一个节点的指针会指向被删除节点的下
数据结构与算法专题之线性表——链表（二）双向链表
Shannon-Nansen
07-26 1126
本文是线性表之链表第二弹——双向链表。在学习本章节之前，应该首先学习并掌握链表的概念及单链表的原理和实现，还未学习的小伙伴请移步上一篇文章，传送门： 　　数据结构与算法专题之线性表——链表（一）单链表 　　能看到这里，我就默认你学会了单链表并且理解了链表的基本概念，下面我们开始双向链表的学习。 双向链表的概念及结构 基本概念 　　双向链表，顾名思义，就是拥有前后两个方
几分钟让你了解--数据结构（线性表）
ck_67的博客
10-23 640
线性表 线性表的逻辑定义 线性表： 是最简单和最常用的一种数据结构 基本运算 置空表 构造一个空的线性表 L 求表长 ：返回线性表 L 中元素的个数，即表长 取表中第 i 个元素，如果 i 不为开头和结尾，则返回第i 个元素 按值查找 ：在表L中 查找第一个值为X的元素，并返回该元素在L中的位置，若表中没有元素的值为X,则返回0 插入，在表的第i个元素之前插入一个值为X的...
线性表——双向链表
Alyson_jm的博客
09-22 548
双向链表简介 双向链表是一种特殊的链表。 在单向链表中我们要查找下一个结点非常的方便，但是要查找上一个节点就困难了，双向链表克服了单链表的单向性这个缺点， 单链表和双向链表的区别 单链表：只能向一个方向遍历 双向链表：向两边都可以遍历。 双向链表的实现 为了找到节点和前驱，我们给节点增加一个指向其前驱的指针，如下图所示 既然单链表可以循环，那么双向链表也就可以循环，如下图所示即...
数据结构之线性结构--双向循环链表
无_空
10-08 2918
一、双向循环链表特点双向循环链表的结构是在双向链表的基础上使头节点的前驱指针指向末尾的节点，而使末尾的节点的一个指针指向开始节点，形成一个循环结构。 双向循环链表在进行节点的删除的时候的操作： 双向循环链表在进行节点的插入时的操作： 二、双向循环链表的实现AL_Node.h文件#ifndef AL_NODE_INCLUDE #define AL_NODE_INCLUDE#include
数据结构之线性表——双向链表
ds_kuen的博客
05-11 497
1 双向链表描述
数据结构之线性表(七)——双向链表
daocaoren_的博客
07-20 393
为什么要用双向链表？ 因为单链表中的结点有指示后继结点的指针域，找后继结点方便。即，查找某结点后继结点的复杂度为O(1)O(1)O(1)。 但是在单链表中，没有指示前驱结点的指针域，找前驱结点难，要从表头出发查找。即，查找某结点前驱结点的复杂度为O(n)O(n)O(n)。 而双向链表可以克服这种缺点。 双向链表的定义与特点 1.定义 双向链表：在单链表中的每个结点里在增加一个指向其前驱结点的指...
数据结构C++描述
03-15
3.4.7 双向链表 95 3.4.8 小结 96 3.5 间接寻址 99 3.5.1 基本概念 99 3.5.2 操作 100 3.6 模拟指针 102 3.6.1 SimSpace的操作 103 3.6.2 采用模拟指针的链表 106 3.7 描述方法的比较 110 3.8 应用 111 3.8.1 箱子...
数据结构 C++描述
08-04
3.4.7 双向链表 95 3.4.8 小结 96 3.5 间接寻址 99 3.5.1 基本概念 99 3.5.2 操作 100 3.6 模拟指针 102 3.6.1 SimSpace的操作 103 3.6.2 采用模拟指针的链表 106 3.7 描述方法的比较 110 3.8 应用 111 3.8.1 箱子...
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1064
数据结构——树和二叉树的基本概念
数据结构中的栈和队列（附实际案例代码）
JAZJD的博客
04-23 764
栈（Stack）和队列（Queue）
【做算法学数据结构】二叉树的层序遍历【二叉树】
yh4494的博客
04-24 729
`二叉树`是一种常见的树形数据结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的特点是每个节点最多有两个子节点，并且子节点的顺序是有序的，即左子节点在前，右子节点在后。
数据结构 -- 二叉树&二叉搜索树
2301_79602614的博客
04-20 1428
这样看似prev = node.val 也就是 prev = 5,但因为你的prev是作为一个参数,是对整个方法中生效的,也就是4这个点有doValid(node.left,prev) 和 doValid(node.right,prev)这两个prev都是4这个点传入的prev并不会说因为在doValid(node.prev)中prev=5导致这个方法的所有prev都变为了5,本质也就是这个参数只是这个方法的局部变量,局部变量的修改不会影响到其他的方法。如何知道右子树处理完成呢？
学习笔记-数据结构-线性表（2024-04-18）- 单向链表选择排序
XuJiaKai的博客
04-20 450
正经的单向链表选择排序！！不是别人的那种交换值的！
数据结构之常见排序算法
m0_69468924的博客
04-24 1033
数据结构之常见排序算法
高级线性表——静态链表
05-19
静态链表是一种使用数组实现的链表结构。与动态链表不同，静态链表的大小在创建时就已经确定，不能动态地增加或删除元素。静态链表通过使用数组存储元素，同时利用数组的一些空闲位置来存储链表中的指针信息，从而...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值