双向链表的实现

已于 2023-08-16 18:42:34 修改
阅读量25 收藏
点赞数
文章标签： 链表 数据结构
于 2023-08-14 23:14:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45951812/article/details/132287890
版权

llist.h

#pragma once
#ifndef LLIST_H__
#define LLIST_H__

#define FORM 1
#define BACK 2
typedef void llist_op(void*);
typedef int llist_fd(void*, void*);

typedef struct node_st
{
	void* data;
	struct node_st* next;
	struct node_st* pre;
}node ;

typedef struct
{
	int size;
	node node;

}LLIST;



LLIST* llist_creat(int size);


int llist_insert(LLIST * head,void *data,int mode);

int llist_delete(LLIST *,void* ,llist_fd);

int llist_fetch(LLIST*, void* key, llist_fd*, void* data);

void* llist_find(LLIST *,void *key, llist_fd*);


void llist_travel(LLIST *,llist_op*);


void llist_destroy(LLIST *);
#endif

llist.c

#include <stdio.h>
#include <stdlib.h>
#include <String.h>
#include "llist.h"

LLIST* llist_creat(int size)
{
	LLIST* head;
	head = (LLIST*)malloc(sizeof(*head));
	if (head == NULL)
		return NULL;

	head->size = size;
	head->node.data = NULL;
	head->node.pre = &(head->node);
	head->node.next = &(head->node);
	return head;
}

//输入模式错误，返回-3
//创建失败，返回-1
int llist_insert(LLIST* head, void* data, int mod)
{
	node* nd;
	nd = (node*)malloc(sizeof(*nd));
	if (nd == NULL) {
		return -1;
	}

	nd->data = malloc(head->size);
	if (nd->data == NULL)
		return -2;
	memcpy(nd->data, data, head->size);
	if (mod == FORM)
	{
		nd->next = head->node.next;
		nd->pre = &(head->node);
	}
	else if (mod == BACK)
	{
		nd->next = &(head->node);
		nd->pre = head->node.pre;
	}
	else
	{
		return -3;
	}
	nd->pre->next = nd;
	nd->next->pre = nd;
	return 0;
}


int llist_delete(LLIST* head)
{

	return 0;
}

static node* find_(LLIST* head, void* key, llist_fd* fd)
{
	node* nd = head->node.next;
	while (nd != &head->node)
	{
		if (fd(nd->data, key) == 0)
		{
			break;
		}
		nd = nd->next;
	}
	return nd;
}

void* llist_find(LLIST* head,void* key, llist_fd* fd)
{
	return find_(head, key, fd)->data;
}


void llist_travel(LLIST* head, llist_op* op)
{
	node* nd;
	nd = head->node.next;
	while (nd != &(head->node))
	{
		op(nd->data);
		nd = nd->next;
	}

}


int llist_delete(LLIST* head,void* key,llist_fd* fd)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return -1;
	nd->pre->next = nd->next;
	nd->next->pre = nd->pre;
	free(nd->data);
	free(nd);
	return 0;
}

int llist_fetch(LLIST* head, void* key, llist_fd* fd, void* data)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return -1;

	if (nd->data != NULL)
		memcpy(data, nd->data, head->size);
	
	nd->pre->next = nd->next;
	nd->next->pre = nd->pre;
	free(nd->data);
	free(nd);
	return 0;

}




void llist_destroy(LLIST* head)
{
	node* p;
	p = head->node.next;

	while (p != &head->node)
	{
		p = p->next;
		free(p->pre->data);
		free(p->pre);
	}
	free(head);
}

main.c

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

#define NAMESIZE 8

typedef struct score_st
{
	int id;
	char name[NAMESIZE];
	int math;
	int chinese;

}score;

static void print_s(void* data)
{
	score* sc = (score*)data;
	printf("%d %s %d %d\n", sc->id, sc->name, sc->math, sc->chinese);
}

static int find_s(void* data,void* key)
{
	score* sc = (score*)data;
	int* k = (int*)key;
	return (*k - sc->id);
}

static int find_name(void* data, void* key)
{
	score* sc = (score*)data;
	const char* name = (char*)key;
	return strcmp(sc->name, name);

}


int main()
{
	LLIST* head;
	score temp,st;
	int ret;
	head = llist_creat(sizeof(temp));
	if (head == NULL)
		exit(1);
	for (int i = 0; i < 7; i++)
	{
		temp.id = i;
		snprintf(temp.name, NAMESIZE, "std%d", i);
		temp.math = rand() % 100;
		temp.chinese = rand() % 100;
		ret = llist_insert(head, &temp, FORM);
		if (ret != 0)
			exit(1);
	}
	
	
	llist_travel(head,print_s);
	printf("----------------------------------------\n");
	//查找
	//score* scc;
	//int id = 32;
	//scc = (score*)llist_find(head, &id, find_s);
	//if (scc == NULL)
	//	printf("没有找到\n");
	//else
	//	print_s(scc);

	int id = 3;
	char name[5] = "std3";
	ret = llist_delete(head, name, find_name);
	if (ret != 0)
		printf("EROOR!\n");
	llist_travel(head,print_s);


	llist_destroy(head);

}

---------------------------------------------------------------------------------------------------------------------------------修改为边长结构体

.h

#pragma once
#ifndef LLIST_H__
#define LLIST_H__

#define FORM 1
#define BACK 2
typedef void llist_op(void*);
typedef int llist_fd(void*, void*);

//边长结构体
typedef struct node_st
{
	struct node_st* next;
	struct node_st* pre;
	char data[0];
}node;

typedef struct
{
	int size;
	node node;

}LLIST;



LLIST* llist_creat(int size);


int llist_insert(LLIST * head,void *data,int mode);

int llist_delete(LLIST *,void* ,llist_fd);

int llist_fetch(LLIST*, void* key, llist_fd*, void* data);

void* llist_find(LLIST *,void *key, llist_fd*);


void llist_travel(LLIST *,llist_op*);


void llist_destroy(LLIST *);
#endif

llist.c

#include <stdio.h>
#include <stdlib.h>
#include <String.h>
#include "llist.h"


LLIST* llist_creat(int size)
{
	LLIST* head;
	head = (LLIST*)malloc(sizeof(*head));
	if (head == NULL)
		return NULL;

	head->size = size;
	head->node.pre = &(head->node);
	head->node.next = &(head->node);
	return head;
}


int llist_insert(LLIST* head, void* data, int mod)
{
	node* nd;
	nd = (node*)malloc(sizeof(*nd) + head->size);
	if (nd == NULL) {
		return -1;
	}

	memcpy(nd->data, data, head->size);
	if (mod == FORM)
	{
		nd->next = head->node.next;
		nd->pre = &(head->node);
	}
	else if (mod == BACK)
	{
		nd->next = &(head->node);
		nd->pre = head->node.pre;
	}
	else
	{
		return -3;
	}
	nd->pre->next = nd;
	nd->next->pre = nd;
	return 0;
}

int llist_delete(LLIST* head)
{

	return 0;
}


static node* find_(LLIST* head, void* key, llist_fd* fd)
{
	node* nd = head->node.next;
	while (nd != &head->node)
	{
		if (fd(nd->data, key) == 0)
		{
			break;
		}
		nd = nd->next;
	}
	return nd;
}

void* llist_find(LLIST* head, void* key, llist_fd* fd)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return NULL;
	return nd->data;
}


void llist_travel(LLIST* head, llist_op* op)
{
	node* nd;
	nd = head->node.next;
	while (nd != &(head->node))
	{
		op(nd->data);
		nd = nd->next;
	}

}


int llist_delete(LLIST* head, void* key, llist_fd* fd)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return -1;
	nd->pre->next = nd->next;
	nd->next->pre = nd->pre;
	free(nd);
	return 0;
}

int llist_fetch(LLIST* head, void* key, llist_fd* fd, void* data)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return -1;

	if (nd->data != NULL)
		memcpy(data, nd->data, head->size);

	nd->pre->next = nd->next;
	nd->next->pre = nd->pre;
	free(nd);
	return 0;

}




void llist_destroy(LLIST* head)
{
	node* p;
	p = head->node.next;

	while (p != &head->node)
	{
		p = p->next;
		free(p->pre);
	}
	free(head);
}

main.c

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

#define NAMESIZE 8

typedef struct score_st
{
	int id;
	char name[NAMESIZE];
	int math;
	int chinese;

}score;

static void print_s(void* data)
{
	score* sc = (score*)data;
	printf("%d %s %d %d\n", sc->id, sc->name, sc->math, sc->chinese);
}

static int find_s(void* data,void* key)
{
	score* sc = (score*)data;
	int* k = (int*)key;
	return (*k - sc->id);
}

static int find_name(void* data, void* key)
{
	score* sc = (score*)data;
	const char* name = (char*)key;
	return strcmp(sc->name, name);

}


int main()
{
	LLIST* head;
	score temp,st;
	int ret;
	head = llist_creat(sizeof(temp));
	if (head == NULL)
		exit(1);
	for (int i = 0; i < 7; i++)
	{
		temp.id = i;
		snprintf(temp.name, NAMESIZE, "std%d", i);
		temp.math = rand() % 100;
		temp.chinese = rand() % 100;
		ret = llist_insert(head, &temp, FORM);
		if (ret != 0)
			exit(1);
	}
	
	
	llist_travel(head,print_s);
	printf("----------------------------------------\n");
	//查找
	//score* scc;
	//int id = 32;
	//scc = (score*)llist_find(head, &id, find_s);
	//if (scc == NULL)
	//	printf("没有找到\n");
	//else
	//	print_s(scc);

	int id = 3;
	char name[5] = "std3";
	ret = llist_delete(head, name, find_name);
	if (ret != 0)
		printf("EROOR!\n");
	llist_travel(head,print_s);


	llist_destroy(head);

}

------------------------------------------------------------------------------------------------------------------------------------------------将方法封装到结构体中

llist.h

#pragma once
#ifndef LLIST_H__
#define LLIST_H__

#define FORM 1
#define BACK 2
typedef void llist_op(void*);
typedef int llist_fd(void*, void*);

//边长结构体
typedef struct node_st
{
	struct node_st* next;
	struct node_st* pre;
	char data[0];
}node;

typedef struct llist_head
{
	int size;
	//定义了一个函数指针，返回值为int，参数类型如下，名为insert
	int (*insert)(struct llist_head*, void* , int );
	void* (*find)(struct llist_head*, void* key, llist_fd*);
	int (*delet)(struct llist_head*, void*, llist_fd);
	int (*fetch)(struct llist_head*, void* key, llist_fd*, void* data);
	void (*trave)(struct llist_head*, llist_op*);
	void (*destroy)(struct llist_head*);
	struct node_st node;
}LLIST;



LLIST* llist_creat(int size);
void llist_destroy(LLIST*);


#endif

llist.c

#include <stdio.h>
#include <stdlib.h>
#include <String.h>
#include "llist.h"

int llist_insert(LLIST *, void* , int );
void* llist_find(LLIST*, void* key, llist_fd*);
int llist_delete(LLIST*, void*, llist_fd);
int llist_fetch(LLIST*, void* key, llist_fd*, void* data);
void llist_travel(LLIST*, llist_op*);
void llist_destroy(LLIST*);

LLIST* llist_creat(int size)
{
	LLIST* head;
	head = (LLIST*)malloc(sizeof(*head));
	if (head == NULL)
		return NULL;

	head->size = size;
	head->node.pre = &(head->node);
	head->node.next = &(head->node);
	//赋值，让结构体里的函数指针指向函数，注意函数没有'()'
	head->insert = llist_insert;
	head->delet = llist_delete;
	head->find = llist_find;
	head->fetch = llist_fetch;
	head->trave = llist_travel;


	return head;
}


int llist_insert(LLIST* head, void* data, int mod)
{
	node* nd;
	nd = (node*)malloc(sizeof(*nd) + head->size);
	if (nd == NULL) {
		return -1;
	}

	memcpy(nd->data, data, head->size);
	if (mod == FORM)
	{
		nd->next = head->node.next;
		nd->pre = &(head->node);
	}
	else if (mod == BACK)
	{
		nd->next = &(head->node);
		nd->pre = head->node.pre;
	}
	else
	{
		return -3;
	}
	nd->pre->next = nd;
	nd->next->pre = nd;
	return 0;
}

int llist_delete(LLIST* head)
{

	return 0;
}


static node* find_(LLIST* head, void* key, llist_fd* fd)
{
	node* nd = head->node.next;
	while (nd != &head->node)
	{
		if (fd(nd->data, key) == 0)
		{
			break;
		}
		nd = nd->next;
	}
	return nd;
}

void* llist_find(LLIST* head, void* key, llist_fd* fd)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return NULL;
	return nd->data;
}


void llist_travel(LLIST* head, llist_op* op)
{
	node* nd;
	nd = head->node.next;
	while (nd != &(head->node))
	{
		op(nd->data);
		nd = nd->next;
	}

}


int llist_delete(LLIST* head, void* key, llist_fd* fd)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return -1;
	nd->pre->next = nd->next;
	nd->next->pre = nd->pre;
	free(nd);
	return 0;
}

int llist_fetch(LLIST* head, void* key, llist_fd* fd, void* data)
{
	node* nd;
	nd = find_(head, key, fd);
	if (nd == &head->node)
		return -1;

	if (nd->data != NULL)
		memcpy(data, nd->data, head->size);

	nd->pre->next = nd->next;
	nd->next->pre = nd->pre;
	free(nd);
	return 0;

}




void llist_destroy(LLIST* head)
{
	node* p;
	p = head->node.next;

	while (p != &head->node)
	{
		p = p->next;
		free(p->pre);
	}
	free(head);
}

main.c

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

#define NAMESIZE 8

typedef struct score_st
{
	int id;
	char name[NAMESIZE];
	int math;
	int chinese;

}score;

static void print_s(void* data)
{
	score* sc = (score*)data;
	printf("%d %s %d %d\n", sc->id, sc->name, sc->math, sc->chinese);
}

static int find_s(void* data,void* key)
{
	score* sc = (score*)data;
	int* k = (int*)key;
	return (*k - sc->id);
}

static int find_name(void* data, void* key)
{
	score* sc = (score*)data;
	const char* name = (char*)key;
	return strcmp(sc->name, name);

}


int main()
{
	LLIST* head;
	score temp,st;
	int ret;
	head = llist_creat(sizeof(temp));
	if (head == NULL)
		exit(1);
	for (int i = 0; i < 7; i++)
	{
		temp.id = i;
		snprintf(temp.name, NAMESIZE, "std%d", i);
		temp.math = rand() % 100;
		temp.chinese = rand() % 100;
		//定义的头结点名为head，head里封装了方法
		ret = head->insert(head, &temp, FORM);
		if (ret != 0)
			exit(1);
	}
	
	
	head->trave(head,print_s);

/*

	printf("----------------------------------------\n");
	//查找
	//score* scc;
	//int id = 32;
	//scc = (score*)llist_find(head, &id, find_s);
	//if (scc == NULL)
	//	printf("没有找到\n");
	//else
	//	print_s(scc);

	int id = 3;
	char name[5] = "std3";
	ret = llist_delete(head, name, find_name);
	if (ret != 0)
		printf("EROOR!\n");
	llist_travel(head,print_s);


	llist_destroy(head);
	*/
}

南木_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
双向链表实现
hxy1625309592的博客
12-15 2099
1.1 基本介绍 1、单向链表优缺点 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。 2、双向链表基本介绍 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
双向链表实现栈
m0_56398287的博客
10-03 1219
双向链表来实现栈
【数据结构】双向链表实现
m0_73367097的博客
03-26 1628
双向链表的定义与实现
基于 HashMap 和 双向链表实现 LRU
ikun的博仔的博客
06-26 891
基于HashMap和双向链表实现LRU
基于双向链表实现的栈
Gee_Zer的博客
08-15 3391
看了LinkedList的源码，明白了LinkedList底层使用的是双向链表，一直想找个机会实现一下双向链表，今天写到力扣的每日一题20.有效的括号，正好此题需要使用到栈，所以借此机会来自己实现一下基于双向链表实现的栈，实现栈之前要了解以下知识 1.什么是双向链表 双向链表是指一个节点有一个数据域，两个指针域，一个指针域指向上一个节点，一个指针域指向下一个节点，现在将指向上一个节点的指针域命名为pre，将指向下一个节点的指针域命名为next，节点命名为node，一个合格的双向链表如下图所示 中间的nod
用双向链表实现栈（C）
u014801954的博客
05-15 4096
目录 一.结构定义： 二.结构操作 三.测试代码 四.运用
使用线程安全型双向链表实现简单 LRU Cache 模拟
热门推荐
苏州程序大白的博客
11-16 1万+
使用线程安全型双向链表实现简单 LRU Cache 模拟目录????博主介绍前言1、动机1.1、要解决的问题2、系统设计2.1、系统总体框架2.2、系统功能模块2.3 系统整体流程3、数据结构设计4、关键技术与系统实现4.1、生成访问序列4.2 各进程的推进4.3、修改链表结构的相关方法实现4.4、访问链表的相关方法实现4.5、应用封装层的实现4.6、统计缓冲区命中率5、系统运行结果5.1、运行环境5.2、运行与测试结果5.2.1、运行结果5.2.2、链表方法测试6、调试与改进????作者相关的文章、资源分
java模拟双向链表实现
congge
03-10 6301
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 下图是双向链表的逻辑结构图，和单链表不同的是，双向链表中每个节点包含两个节点的指针引用，和一个数据域，这两个节点分别指向前一个节点和后一个节点； 双向链表的这种结构比起单链表，其改进之处正在于此，通过对前后节点的引用可以使得在...
双向链表实现(c/c++)
qq_52095705的博客
11-16 2158
前言 数据结构还是得来一手。 一.关于链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。链表通过指针域能把多个元素串联起来。 一般的链表中每个元素只有一个指向下一个元素的指针域，而我们的双向链表却有两个指针域，其中一个指针域指向下一个元素，另一个指针域指向这个元素的上一个元素。 接下来看程序
Java实现双向链表
weixin_64448174的博客
06-01 3826
一、双向链表的简单理解 1、双向链表是什么？ 在前面的文章中，我们仔细讲解了单向链表，并且用代码实现了单向链表。单向链表的好处很多，虽然单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并不是效率最优的存储结构。比如说，如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合 "从前往后" 找，而 "从后往前" 找并不是它的强项，因此我们就有了双向链表这个东西，双向链表顾名思义就是链表的高级版，他与单向链表有所不同的一点在于在具有
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
C++的双向链表实现
04-15
代码基于标准C++，可以用vscode，vs，qt等IDE打开。具备基本的双链表操作，如头插尾插，前驱遍历和后继遍历，求长度等等。
九、数据结构（并查集）
n666fgh的博客
06-13 830
通常用“帮派”的例子来说明并查集的应用背景：在一个城市中有nn1061号、2号是朋友；1号、3号也是朋友，那么他们都属于一个帮派。在分析完所有的朋友关系之后，问有多少帮派，每人属于哪个帮派。这个数据量应该是不能用暴力的办法求解，那我们应该怎么办呢？由此，我们引出一种新的数据结构：并查集。
十、数据结构（图的基础）
n666fgh的博客
06-15 570
intgraphNNintgraphNN，每个节点graphijgraphij表示从iii到jjj的距离。graphii!
Java实现数据结构——顺序表
2303_80472275的博客
06-10 592
笔者在以前的文章中实现过顺序表本文在理论上不会有太详细的讲述如有需要可以翻看笔者之前的文章Java中已经封装好了顺序表的类但在使用之前先自己实现一遍。
数据结构之B树
最新发布
ruky36的专栏
06-15 973
处理删除后节点的键值数少于 \(\lceil \frac{m}{2} \rceil - 1\) 的情况，通过合并或借用兄弟节点的键值来维护B树的性质。- 一个节点最多可以包含 \(m-1\) 个键值和 \(m\) 个指针（其中 \(m\) 是B树的阶，通常大于等于3）。2. 平衡性：B树总是保持平衡，所有叶节点都在同一层，保证了搜索、插入、删除操作的时间复杂度为 \(O(\log n)\)。1. 高效的磁盘读写：由于每个节点可以包含多个键值和指针，B树减少了访问磁盘的次数，提高了大数据量情况下的性能。
探索算法的时间复杂度：五种不同时间复杂度的算法介绍
gygkhd的博客
06-15 558
在计算机科学中，理解和分析算法的时间复杂度是非常重要的，它可以帮助我们预测算法在处理不同规模数据时的性能表现。本文将介绍五种不同时间复杂度的算法，并解释每个算法如何得出其时间复杂度。我们将使用C语言来展示每个算法的实现。
双向链表实现多级菜单
09-22
以下是一个使用双向链表实现多级菜单的示例代码： ```python class MenuItem: def __init__(self, label): self.label = label self.child = None self.parent = None self.next_sibling = None def create_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值