带头节点 (非头指针) 双向循环链表 (doubly linked list)

最新推荐文章于 2024-09-22 14:45:41 发布
原创 最新推荐文章于 2024-09-22 14:45:41 发布 · 1.5k 阅读 · 6 ·
CC 4.0 BY-SA版权
世上没有白读的书，每一页都算数。
文章标签：

#头节点 - 非头指针 #双向循环链表 #doubly #linked list

本文介绍双向循环链表的基本概念及其实现细节，包括如何在链表中插入和删除节点，并提供具体的C语言代码示例。

带头节点 (非头指针) 双向循环链表 (doubly linked list)

bidirectional circular linked list：双向循环链表

建议使用带头结点，而非头指针的双向循环链表。
在这里插入图片描述

1. 双向链表

双向链表的每个数据结点中都有两个指针，分别指向直接后继 (next) 和直接前驱 (prev) 。

在这里插入图片描述

在这里插入图片描述

2. 双向循环链表

本节图片参考 https://www.cnblogs.com/skywang12345/p/3561803.html

双向链表和单链表都是由节点组成，双向链表的每个数据结点中都有两个指针，分别指向直接后继 (next) 和直接前驱 (prev) 。

双向循环链表最后一个结点的直接后继 (next) 指向表头 (head) 结点，而不像双向链表置为 NULL。

在判断是否到达表尾时，判断该结点直接后继 (next) 是否是表头结点，当直接后继 (next) 等于表头指针时，说明已到表尾。而不像双向链表那样判断直接后继 (next) 是否为 NULL。

从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
在这里插入图片描述

头节点 (非头指针) 双向循环链表示例图

在这里插入图片描述

在这里插入图片描述

表头 head 为空，head 的后继节点 (next) 为节点 10 (数据为 10 的节点)；节点 10 的后继节点 (next) 是节点 20 (数据为 20 的节点)，节点 20 的前继节点 (prev) 是节点 10；节点 20 的后继节点 (next) 是节点 30，节点 30 的前继节点 (prev) 是节点 20；…；末尾节点的后继节点 (next) 是表头 head。

2.1 头节点 (非头指针) 双向循环链表删除节点

在这里插入图片描述

头节点 (非头指针) 双向循环链表删除节点示例图

删除节点 30 (数据为 30 的节点)
删除之前：节点 20 的后继节点 (next) 为节点 30，节点 30 的前继节点 (prev) 为节点 20。节点 30 的后继节点 (next) 为节点 40，节点 40 的前继节点 (prev) 为节点 30。
删除之后：节点 20 的后继节点 (next) 为节点 40，节点 40 的前继节点 (prev) 为节点 20。

2.2 头节点 (非头指针) 双向循环链添加节点

在这里插入图片描述

在这里插入图片描述

头节点 (非头指针) 双向循环链表添加节点示例图

在节点 10 与 节点 20 之间添加节点 15
添加之前：节点 10 的后继节点 (next) 为节点 20，节点 20 的前继节点 (prev) 为节点 10。
添加之后：节点 10 的后继节点 (next) 为节点 15，节点 15 的前继节点 (prev) 为节点 10。节点 15 的后继节点 (next) 为节点 20，节点 20 的前继节点 (prev) 为节点 15。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3. 带头节点 (非头指针) 双向循环链表 (doubly linked list)

在这里插入图片描述

在这里插入图片描述

3.1 insert_first - delete_node - display

//============================================================================
// Name        : doubly linked list
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif

#define MAX_NODE_LEN 401
#define NULL 0

#include <stdio.h>

typedef struct NODE {
	int data;
	struct NODE *prev;
	struct NODE *next;
} Node;

Node node_array[MAX_NODE_LEN];
int node_array_idx = 0;

void insert_first(Node *head, Node *node)
{
	node->next = head->next;
	node->prev = head;

	// equality: head->next->prev = node;
	node->next->prev = node;
	head->next = node;
}

void delete_node(const Node *node)
{
	Node *prev_node = node->prev;
	Node *next_node = node->next;
	// current node - node

	prev_node->next = next_node;
	next_node->prev = prev_node;
}

void delete_node_v1(const Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;
}

void delete_node_v2(Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;

	node->next = node->next = NULL;
}

void display(const Node *head)
{
	int n = 1;

	Node *node = head->next;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->next;
	}
}

int main()
{
	// 头节点 (非头指针)
	Node root;

	// initialization
	// root.prev = &(root);
	// root.next = &(root);
	root.prev = root.next = &(root);
	root.data = 0;

	for (int i = 0; i < MAX_NODE_LEN; ++i)
	{
		node_array[i].prev = NULL;
		node_array[i].next = NULL;
		node_array[i].data = 0;
	}

	// insert 0
	node_array[0].data = 0;
	insert_first(&root, &(node_array[0]));

	// insert 2
	node_array[2].data = 2;
	insert_first(&root, &(node_array[2]));

	// insert 4
	node_array[4].data = 4;
	insert_first(&root, &(node_array[4]));

	// insert 6
	node_array[6].data = 6;
	insert_first(&root, &(node_array[6]));

	// insert 8
	node_array[8].data = 8;
	insert_first(&root, &(node_array[8]));

	display(&root);

	// delete 4
	delete_node_v1(&(node_array[4]));
	printf("\ndelete data %d\n", 4);
	display(&root);

	// delete 0
	delete_node_v1(&(node_array[0]));
	printf("\ndelete data %d\n", 0);
	display(&root);

	// delete 8
	delete_node_v1(&(node_array[8]));
	printf("\ndelete data %d\n", 8);
	display(&root);

	// insert 10
	node_array[10].data = 10;
	insert_first(&root, &(node_array[10]));
	printf("\ninsert data %d\n", 10);
	display(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->next;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->next;
			if (2 == ptr_node->data) {
				delete_node(ptr_node);
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ndelete data %d\n", 2);
	display(&root);

	// insert 12
	node_array[12].data = 12;
	insert_first(&root, &(node_array[12]));
	printf("\ninsert data %d\n", 12);
	display(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->prev;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->prev;
			if (10 == ptr_node->data) {
				delete_node(ptr_node);
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ndelete data %d\n", 10);
	display(&root);

	return 0;
}


node 1: 8
node 2: 6
node 3: 4
node 4: 2
node 5: 0

delete data 4
node 1: 8
node 2: 6
node 3: 2
node 4: 0

delete data 0
node 1: 8
node 2: 6
node 3: 2

delete data 8
node 1: 6
node 2: 2

insert data 10
node 1: 10
node 2: 6
node 3: 2

delete data 2
node 1: 10
node 2: 6

insert data 12
node 1: 12
node 2: 10
node 3: 6

delete data 10
node 1: 12
node 2: 6
请按任意键继续. . .

3.2 insert_first - delete_node_v1 - display

//============================================================================
// Name        : doubly linked list
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif

#define MAX_NODE_LEN 401
#define NULL 0

#include <stdio.h>

typedef struct NODE {
	int data;
	struct NODE *prev;
	struct NODE *next;
} Node;

Node node_array[MAX_NODE_LEN];
int node_array_idx = 0;

void insert_first(Node *head, Node *node)
{
	node->next = head->next;
	node->prev = head;

	// equality: head->next->prev = node;
	node->next->prev = node;
	head->next = node;
}

void delete_node(const Node *node)
{
	Node *prev_node = node->prev;
	Node *next_node = node->next;
	// current node - node

	prev_node->next = next_node;
	next_node->prev = prev_node;
}

void delete_node_v1(const Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;
}

void delete_node_v2(Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;

	node->next = node->next = NULL;
}

void display(const Node *head)
{
	int n = 1;

	Node *node = head->next;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->next;
	}
}

int main()
{
	// 头节点 (非头指针)
	Node root;

	// initialization
	// root.prev = &(root);
	// root.next = &(root);
	root.prev = root.next = &(root);
	root.data = 0;

	for (int i = 0; i < MAX_NODE_LEN; ++i)
	{
		node_array[i].prev = NULL;
		node_array[i].next = NULL;
		node_array[i].data = 0;
	}

	// insert 0
	node_array[0].data = 0;
	insert_first(&root, &(node_array[0]));

	// insert 2
	node_array[2].data = 2;
	insert_first(&root, &(node_array[2]));

	// insert 4
	node_array[4].data = 4;
	insert_first(&root, &(node_array[4]));

	// insert 6
	node_array[6].data = 6;
	insert_first(&root, &(node_array[6]));

	// insert 8
	node_array[8].data = 8;
	insert_first(&root, &(node_array[8]));

	display(&root);

	// delete 4
	delete_node_v1(&(node_array[4]));
	printf("\ndelete data %d\n", 4);
	display(&root);

	// delete 0
	delete_node_v1(&(node_array[0]));
	printf("\ndelete data %d\n", 0);
	display(&root);

	// delete 8
	delete_node_v1(&(node_array[8]));
	printf("\ndelete data %d\n", 8);
	display(&root);

	// insert 10
	node_array[10].data = 10;
	insert_first(&root, &(node_array[10]));
	printf("\ninsert data %d\n", 10);
	display(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->next;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->next;
			if (2 == ptr_node->data) {
				delete_node_v1(ptr_node);
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ndelete data %d\n", 2);
	display(&root);

	// insert 12
	node_array[12].data = 12;
	insert_first(&root, &(node_array[12]));
	printf("\ninsert data %d\n", 12);
	display(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->prev;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->prev;
			if (10 == ptr_node->data) {
				delete_node_v1(ptr_node);
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ndelete data %d\n", 10);
	display(&root);

	return 0;
}


node 1: 8
node 2: 6
node 3: 4
node 4: 2
node 5: 0

delete data 4
node 1: 8
node 2: 6
node 3: 2
node 4: 0

delete data 0
node 1: 8
node 2: 6
node 3: 2

delete data 8
node 1: 6
node 2: 2

insert data 10
node 1: 10
node 2: 6
node 3: 2

delete data 2
node 1: 10
node 2: 6

insert data 12
node 1: 12
node 2: 10
node 3: 6

delete data 10
node 1: 12
node 2: 6
请按任意键继续. . .

3.3 insert_first - delete_node_v1 - display_v1

//============================================================================
// Name        : doubly linked list
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif

#define MAX_NODE_LEN 401
#define NULL 0

#include <stdio.h>

typedef struct NODE {
	int data;
	struct NODE *prev;
	struct NODE *next;
} Node;

Node node_array[MAX_NODE_LEN];
int node_array_idx = 0;

void insert_first(Node *head, Node *node)
{
	node->next = head->next;
	node->prev = head;

	// equality: head->next->prev = node;
	node->next->prev = node;
	head->next = node;
}

void delete_node(const Node *node)
{
	Node *prev_node = node->prev;
	Node *next_node = node->next;
	// current node - node

	prev_node->next = next_node;
	next_node->prev = prev_node;
}

void delete_node_v1(const Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;
}

void delete_node_v2(Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;

	node->next = node->next = NULL;
}

void display(const Node *head)
{
	int n = 1;

	Node *node = head->next;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->next;
	}
}

void display_v1(const Node *head)
{
	int n = 1;

	Node *node = head->prev;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->prev;
	}
}

int main()
{
	// 头节点 (非头指针)
	Node root;

	// initialization
	// root.prev = &(root);
	// root.next = &(root);
	root.prev = root.next = &(root);
	root.data = 0;

	for (int i = 0; i < MAX_NODE_LEN; ++i)
	{
		node_array[i].prev = NULL;
		node_array[i].next = NULL;
		node_array[i].data = 0;
	}

	// insert 0
	node_array[0].data = 0;
	insert_first(&root, &(node_array[0]));

	// insert 2
	node_array[2].data = 2;
	insert_first(&root, &(node_array[2]));

	// insert 4
	node_array[4].data = 4;
	insert_first(&root, &(node_array[4]));

	// insert 6
	node_array[6].data = 6;
	insert_first(&root, &(node_array[6]));

	// insert 8
	node_array[8].data = 8;
	insert_first(&root, &(node_array[8]));

	display_v1(&root);

	// delete 4
	delete_node_v1(&(node_array[4]));
	printf("\ndelete data %d\n", 4);
	display_v1(&root);

	// delete 0
	delete_node_v1(&(node_array[0]));
	printf("\ndelete data %d\n", 0);
	display_v1(&root);

	// delete 8
	delete_node_v1(&(node_array[8]));
	printf("\ndelete data %d\n", 8);
	display_v1(&root);

	// insert 10
	node_array[10].data = 10;
	insert_first(&root, &(node_array[10]));
	printf("\ninsert data %d\n", 10);
	display_v1(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->next;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->next;
			if (2 == ptr_node->data) {
				delete_node_v1(ptr_node);
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ndelete data %d\n", 2);
	display_v1(&root);

	// insert 12
	node_array[12].data = 12;
	insert_first(&root, &(node_array[12]));
	printf("\ninsert data %d\n", 12);
	display_v1(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->prev;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->prev;
			if (10 == ptr_node->data) {
				delete_node_v1(ptr_node);
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ndelete data %d\n", 10);
	display_v1(&root);

	return 0;
}


node 1: 0
node 2: 2
node 3: 4
node 4: 6
node 5: 8

delete data 4
node 1: 0
node 2: 2
node 3: 6
node 4: 8

delete data 0
node 1: 2
node 2: 6
node 3: 8

delete data 8
node 1: 2
node 2: 6

insert data 10
node 1: 2
node 2: 6
node 3: 10

delete data 2
node 1: 6
node 2: 10

insert data 12
node 1: 6
node 2: 10
node 3: 12

delete data 10
node 1: 6
node 2: 12
请按任意键继续. . .

在这里插入图片描述

3.4 在任意节点之后插入新节点

//============================================================================
// Name        : doubly linked list
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif

#define MAX_NODE_LEN 401
#define NULL 0

#include <stdio.h>

typedef struct NODE {
	int data;
	struct NODE *prev;
	struct NODE *next;
} Node;

Node node_array[MAX_NODE_LEN];
int node_array_idx = 0;

void insert_first(Node *head, Node *node)
{
	node->next = head->next;
	node->prev = head;

	// equality: head->next->prev = node;
	node->next->prev = node;
	head->next = node;
}

void delete_node(const Node *node)
{
	Node *prev_node = node->prev;
	Node *next_node = node->next;
	// current node - node

	prev_node->next = next_node;
	next_node->prev = prev_node;
}

void delete_node_v1(const Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;
}

void delete_node_v2(Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;

	node->next = node->next = NULL;
}

void display(const Node *head)
{
	int n = 1;

	Node *node = head->next;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->next;
	}
}

void display_v1(const Node *head)
{
	int n = 1;

	Node *node = head->prev;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->prev;
	}
}

int main()
{
	// 头节点 (非头指针)
	Node root;

	// initialization
	// root.prev = &(root);
	// root.next = &(root);
	root.prev = root.next = &(root);
	root.data = 0;

	for (int i = 0; i < MAX_NODE_LEN; ++i)
	{
		node_array[i].prev = NULL;
		node_array[i].next = NULL;
		node_array[i].data = 0;
	}

	// insert 0
	node_array[0].data = 0;
	insert_first(&root, &(node_array[0]));

	// insert 2
	node_array[2].data = 2;
	insert_first(&root, &(node_array[2]));

	// insert 4
	node_array[4].data = 4;
	insert_first(&root, &(node_array[4]));

	// insert 6
	node_array[6].data = 6;
	insert_first(&root, &(node_array[6]));

	// insert 8
	node_array[8].data = 8;
	insert_first(&root, &(node_array[8]));

	display(&root);

	// insert 10
	node_array[10].data = 10;
	insert_first(&root, &(node_array[10]));
	printf("\ninsert data %d\n", 10);
	display(&root);

	/********************************* traverse function *********************************/
	{
		Node *head = &root;
		Node *ptr_node = head->prev;
		Node *tmp_node;
		while (ptr_node != head)
		{
			tmp_node = ptr_node->prev;
			if (8 == ptr_node->data) {
				// insert 24
				node_array[24].data = 24;
				insert_first(ptr_node, &(node_array[24]));
			}

			ptr_node = tmp_node;
		}
	}
	/********************************* traverse function *********************************/

	printf("\ninsert data %d\n", 24);
	display(&root);

	return 0;
}



node 1: 8
node 2: 6
node 3: 4
node 4: 2
node 5: 0

insert data 10
node 1: 10
node 2: 8
node 3: 6
node 4: 4
node 5: 2
node 6: 0

insert data 24
node 1: 10
node 2: 8
node 3: 24
node 4: 6
node 5: 4
node 6: 2
node 7: 0
请按任意键继续. . .

在这里插入图片描述

References

https://www.cnblogs.com/skywang12345/p/3561803.html
https://www.alphacodingskills.com/ds/circular-doubly-linked-list.php

C/C++ 双向链表Doubly Linked List算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-26 2535
双向链表（Doubly Linked List）是一种链表的数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。相比于单向链表，双向链表可以实现双向遍历。双向链表（Doubly Linked List）是一种链表的数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。相比于单向链表，双向链表可以实现双向遍历。双向链表（Doubly Linked List）是一种链表的数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。
C/C++ Doubly Linked List双向链表算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-21 2785
Doubly Linked List（双向链表）是一种链表的实现方式，它与普通的单向链表相比，每个节点不仅包含一个指向下一个节点的指针，还包含一个指向前一个节点的指针。在插入和删除节点时，相比单向链表，双向链表不需要通过遍历链表来找到被操作节点的前一个节点，因为每个节点都有一个指向前一个节点的指针，可以直接进行操作，提高了效率。注意在设计双向链表时，需要考虑头节点和尾节点的特殊情况，确保链表的操作能够正确处理这些情况。在插入和删除节点时，需要小心处理节点之间的指针关系，保证链表的完整性，避免内存泄漏。
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
10820
CSND12333的博客
06-01 270
就是欧拉函数的应用，求2-n的每个数的欧拉函数的2倍+1，用了三种方法，前两种是一个一个求，第一种卡着时间过的，第二种预处理之后就很快了， 第三种用的求连续的1-n内的每个数的欧拉函数的模版求的，非常快 //============================================================================ // Name...
双向链表(Doubly Linked List)
热门推荐
Catherine的笔记
05-03 1万+
双向链表(Doubly Linked List) 1. 双向链表的概念 1.1 双向链表的定义 双向链表又称为双链表，是链表的一种。 1.2 双向链表的结点结构 双向链表的结点包括三个部分：前驱指针域、数据域和后继指针域。 (1)前驱指针域(lLink)，又称为左链指针，用于存放一个指针，该指针指向上一个结点的开始存储地址。 (2)数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
带头节点 (非头指针) 双向链表 (doubly linked list)
程永强
03-14 1963
带头节点 (非头指针) 双向链表 (doubly linked list) 线性表是一种线性结构，它具有相同类型的 n (n≥0)n \ (n ≥ 0)n (n≥0) 个数据元素组成的有限序列。线性表：数组、单向链表、双向链表。 doubly (bidirectional) linked list：双向链表 1. 单向链表 (singly linked list) 单向链表是一种使用指针来存储值的数据结构。链表中的每个节点包含一个字段，用于指向链表的下一个节点。另外有一个独立的根指针指向
无指针的静态链表的实现
weixin_34315485的博客
06-06 218
早期语言没有c，更不用说java等一些高级语言。那么是怎么描述链表这种实现呢？这次以单链表的模拟为例，深究一下 静态链表 的实现。 静态链表结构 按照之前单链表的性质，我们需要游标和数据。当然，每个元素都有下标（类似数组） 游标的含义 静态链表中，首节点和尾结点都没有数据（数据为空） 首节点的游标指向第一个含有数据为空的元素的下标。 最后一个节点的游标指向第一个含有数据（不为空）的元素的下...
【数据结构】循环链表(circular linked list) && 双向链表(doubly linked list)
infinitor的博客
11-12 658
更多精彩尽在微信公众号【程序猿声】 本节纲要 预备知识 顺序表(Sequential List) 单链表(Singly Linked List ) 静态链表(Static list ) 循环链表(circular linked list) 双向链表(doubly linked list) 05 循环链表 5.1什么是循环链表？ 前面介绍了单链表，相信大家还记得相关的概念。其实循环链表跟单链表...
DoublyLinkedList:使用 Maven 和 SonarQube 实现双向链表的 Java
06-04
本项目是关于使用 Java 语言实现双向链表（DoublyLinkedList）的一个实例，同时结合了 Maven 作为项目管理工具以及 SonarQube 作为代码质量管理平台，确保代码的质量和规范性。 **Java 双向链表（DoublyLinkedList...
用c语言写个获取双向循环链表（Doubly Linked List，DLL）的元素个数代码
最新发布
12-06
在C语言中，我们可以使用结构体定义双向循环链表节点，并编写函数来计算链表的元素个数。假设我们有一个名为`Node`的结构体，包含`data`、`prev`和`next`指针： ```c #include #include typedef struct Node { ...
doubly_linked_list.rar
05-10
该代码的主要功能是根据双向链表中的数据大小排序，排序方式是选择法和冒泡法两种，其中选择法是用交换指针来实现的。
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回false. 给出表中数据元素的个数。 给定一个索引（位置），返回指向该位置的数据元素的指针，如果给定的位置号不合法，则返回空指针。 给定数据元素x，如果表中有该元素，则返回x第一次出现的索引，若x 不存在，则返回-1. 删除给定索引的数据元素。 给定索引index ,数据元素x，将x插入到index的位置。 C++：设计一个结构体struct chainNode，再设计一个具体类 class doubleChain 作为抽象类 class linearList的派生类实现类linearList中的所有方法，外加实现双向迭代器； Java：设计一个接口interface linearList，设计一个类class doubleChainNode相当于C++中的结构体，设计一个类class doubleChainjava实现了了接口linearList所有方法，以及实现迭代器接口Iterable中的一个方法Iterator iterator();
数据结构:双向链表（Doubly Linked List篇）手把手带你入门数据结构~
Jdxxwu的博客
09-22 2004
手把手带你了解双向链表的实现，图文详解，最后总结有源码奉上，观众老爷们需要自取~
DoublyLinkedList
Sodino的专栏
03-16 900
package lab.sodino.linklist;public class LinkedNode { private Object value; private LinkedNode preNode; private LinkedNode nextNode; public LinkedNode(Object obj) { this.value = obj;
Doubly Linked List
qq_41998938的博客
12-11 289
Doubly Linked List 题目： Your task is to implement a double linked list. Write a program which performs the following operations: insert x: insert an element with key x into the front of the list. delet...
【数据结构】Doubly-Linked List双向链表（更新时间：2016-04-13）
KuroNeko黑猫
04-13 683
【数据结构】Doubly-Linked List双向链表（更新时间：2016-04-03） 啊哈，Doge 来补之前遗留下的关于链表的扩展的东西了 在学习了之前的单链表的基础上，Doge在这里再给大家介绍一下链表的一些拓展，主要是关于链表的指针域不同的连接方式会形成不同的链表类型。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yongqiang Cheng

梦想不是浮躁，而是沉淀和积累。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值