【数据结构】C语言实现双向链表（双向循环链表，无尾指针）

最新推荐文章于 2024-09-11 13:53:20 发布
最新推荐文章于 2024-09-11 13:53:20 发布
阅读量661 收藏
点赞数
分类专栏： 【数据结构】C语言版
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qregi/article/details/79090664
版权

DLinklist.h

#pragma once
 

#include<stdio.h>
#include<stddef.h>

typedef char DLinkType;

//双向链表
typedef struct DLinkNode {

	DLinkType data;
	struct DLinkNode* _next;
	struct DLinkNode* _prev;

}DLinkNode;
//
//typedef struct DLinkList{
//
//	struct DLinkNode head;
//	struct DLinkNode tail;
//	size_t size;
//
//}DLinkList;

//创建结点
DLinkNode* CreatNewNode(DLinkType data);
//初始化
void DLinkListInit(DLinkNode** head);
//尾插一个元素
DLinkNode* DLinkListPushBack(DLinkNode* head, DLinkType value);
//打印双向链表
void PrintDLinkNode(DLinkNode* head, const char* msg);
//释放某个结点的地址空间
void DestoyNode(DLinkNode* node);
//尾删一个元素
void DLinkListPopBack(DLinkNode* head);
//头插一个元素
void DLinkListPushFront(DLinkNode* head, DLinkType value);
//头删一个元素
void DLinkListPopFront(DLinkNode* head);
//查找一个元素
DLinkNode* DLinkListFind(DLinkNode* head, DLinkType to_find);
//往指定位置之前插入一个元素
void DLinkListInsert(DLinkNode* pos, DLinkType value);
//往指定位置之后插入一个元素
void DLinkListInsertAfter(DLinkNode* pos, DLinkType value);
//删除指定位置的元素
void DLinkListErase(DLinkNode* pos);
//删除指定值的元素
void DLinkListRemove(DLinkNode* head, DLinkType value);
//求出链表的长度
size_t DLinkListSize(DLinkNode* head);
//删除所有链表中指定值得元素
void DLinkLisrRemoveAll(DLinkNode** head,DLinkType to_delete);
//判断链表是否为空
int DLinkListEmpty(DLinkNode* head);


DLinklist.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"DlinkList.h"

DLinkNode* CreatNewNode(DLinkType data) {

	//给数据申请空间
	DLinkNode* new_node = (DLinkNode*)malloc(sizeof(DLinkNode));

	if (new_node != NULL) {
		new_node->data = data;
		new_node->_next = NULL;
		new_node->_prev = NULL;
	}
	return new_node;

}

//创建链表的头节点
void DLinkListInit(DLinkNode** head) {
	
	if (head == NULL) {
		return;
	}
	*head = CreatNewNode('0');
	(*head)->_next = *head;
	(*head)->_next = *head;

	
}
/*
**尾插一个元素
*/
DLinkNode* DLinkListPushBack(DLinkNode* head, DLinkType value) {

	if (head == NULL) {
		printf("链表头节点初始化失败");
		return;
	}
	DLinkNode* new_node = CreatNewNode(value);

		int i = 0;
		DLinkNode* cur = head;
		/*
		**如果链表里面有元素，通过遍历到链表的末尾，然后进行插入
		*/
		while (cur->_next != head) {
			cur = cur->_next;
		}
		cur->_next = new_node;
		new_node->_prev = cur;

		head->_prev = new_node;
		new_node->_next = head;

}

void PrintDLinkNode(DLinkNode* head,const char* msg) {

	if (head == NULL) {
		return;
	}
	//正着打印

	printf("%s\n", msg);
	DLinkNode* cur = head->_next;
	printf("\n\n head -> ");
	while (cur != head) {
		printf(" [%c]->", cur->data);
		cur = cur->_next;
	}
	printf("head\n");

	//反着打印
	DLinkNode* cur2 = head->_prev;
	printf("\n\n head ->");
	while (cur2 != head) {
		printf(" [%c]->", cur2->data);
		cur2 = cur2->_prev;
	}
	printf("head\n\n\n");

}

/*
**销毁一个结点
*/
void DestoyNode(DLinkNode** node) {
	if (node == NULL) {
		//元素非法
		return;
	}
	if (*node == NULL) {
		//参数传入出错误
		return;
	}
	free(*node);
	*node = NULL;
}
/*
**在双向链表中，尾删一个元素
*/
void DLinkListPopBack(DLinkNode* head) {

	if (head == NULL) {
		//初始化头结点失败
		return;
	}

	if (head->_next == head || head->_prev == head) {
		printf("链表为空！");
		return;
	}

	DLinkNode* cur = head;

	//通过循环遍历，找到最后一个元素cur
	while (cur->_next != head) {
		cur = cur->_next;
	}
	//创建一个结构体变量，pre代表倒数第二个元素
	DLinkNode* pre = cur->_prev;

	head->_prev = pre;
	pre->_next = head;

	DLinkNode* Delete = cur;
	DestoyNode(&Delete);

}


/*
**在双向链表中，头插一个元素
*/
void DLinkListPushFront(DLinkNode* head, DLinkType value) {

	if (head == NULL) {
		//头节点不存在，初始化错误
		return;
	}
	DLinkNode* NewNode = CreatNewNode(value);
	//创建新结点存储数据
	//爆粗链表的第一个元素
	DLinkNode* OldNode = head->_next;

	head->_next = NewNode;
	NewNode->_prev = head;

	NewNode->_next = OldNode;
	OldNode->_prev = NewNode;

}

//头删一个元素
void DLinkListPopFront(DLinkNode* head) {

	if (head == NULL) {
		return;
	}
	//判断链表是否为空
	if (head->_next == head || head->_prev == head) {
		printf("链表为空！");
		return;
	}

	//先保存要删除的结点
	DLinkNode* Delete = head->_next;
	//然后从链表拆除结点
	DLinkNode* cur = head->_next->_next;

	head->_next = cur;
	cur->_prev = head;

	DestoyNode(&Delete);

}

//查找一个元素
DLinkNode* DLinkListFind(DLinkNode* head, DLinkType to_find) {

	if (head == NULL) {
		return;
	}
	DLinkNode* error = CreatNewNode('-1');
	DLinkNode* cur = head->_next;

	while (cur != head) {

		if (cur->data == to_find) {
			return cur;
		}
		cur = cur->_next;
	}
	printf("链表中没有该元素！\n");
	return error;

}

//往指定位置之前插入一个元素
void DLinkListInsert(DLinkNode* pos, DLinkType value) {

	if (pos == NULL) {
		//传入的位置错误
		return;
	}
	DLinkNode* Insert = CreatNewNode(value);

	DLinkNode* pre = pos->_prev;
	//插入
	pre->_next = Insert;
	Insert->_prev = pre;

	Insert->_next = pos;
	pos->_prev = Insert;

}

//往指定位置之后插入一个元素
void DLinkListInsertAfter(DLinkNode* pos, DLinkType value) {

	if (pos == NULL) {
		return;
	}

	DLinkNode* InsertAfter = CreatNewNode(value);
	DLinkNode* PosNext = pos->_next;

	//插入
	pos->_next = InsertAfter;
	InsertAfter->_prev = pos;

	InsertAfter->_next = PosNext;
	PosNext->_prev = InsertAfter;

}

//删除指定位置的元素
void DLinkListErase(DLinkNode* pos) {

	if (pos == NULL) {
		//位置传入错误
		return;
	}
	DLinkNode* before = pos->_prev;
	DLinkNode* after = pos->_next;

	before->_next = after;
	after->_prev = before;

	DestoyNode(&pos);

}

//删除指定值的元素
void DLinkListRemove(DLinkNode* head, DLinkType value) {

	if (head == NULL) {
		//头节点不存在,初始化失败
		return;
	}
	DLinkNode* cur = head->_next;
	while (cur != head) {

		//找到匹配的元素了
		if (cur->data == value) {
			DLinkNode* cur_prev = cur->_prev;
			DLinkNode* cur_next = cur->_next;

			//删除
			cur_prev->_next = cur_next;
			cur_next->_prev = cur_prev;
			return;

		}
		cur = cur->_next;
	}

}

//求出链表的长度
size_t DLinkListSize(DLinkNode* head) {

	if (head == NULL) {
		return;
	}
	DLinkNode* cur = head->_next;
	size_t sz = 0;
	while (cur != head) {
		++sz;
		cur = cur->_next;
	}
	return sz;

}

//删除所有链表中指定值得元素
void DLinkLisrRemoveAll(DLinkNode** head, DLinkType to_delete) {

	if (head == NULL) {
		return;
	}
	if (*head == NULL) {
		return;
	}
	size_t sz = DLinkListSize(*head);
	while (sz) {
		DLinkListRemove(*head, to_delete);
		sz--;
	}

}

//判断链表是否为空
int DLinkListEmpty(DLinkNode* head) {

	if (head == NULL) {
		return;
	}
	if (head->_next == head || head->_prev == head) {
		return -1;
	}
	else{
		return 1;
	}

}


test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"DlinkList.h"
#include<stdlib.h>

#define MYTESTHEADE printf("----------------%s----------------\n\n",__FUNCTION__);

void TestPushBack() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink,"尾插七个元素:");
}

void TestPopBack() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink,"尾插七个元素:");
	DLinkListPopBack(Dlink);
	DLinkListPopBack(Dlink);
	PrintDLinkNode(Dlink, "尾删两个元素:");
}

void TestPushFront() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkListPushFront(Dlink, 'b');
	DLinkListPushFront(Dlink, 'a');

	PrintDLinkNode(Dlink, "头插两个元素：");
}

void TestPopFront() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkListPopFront(Dlink);
	PrintDLinkNode(Dlink, "头删一个元素");

}

void TestFind() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkNode* test_find = DLinkListFind(Dlink, 'g');
	printf("expect g, actual: %c\n", test_find->data);
}

void TestInsert() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkNode* pos_c = DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkListInsert(pos_c, 'u');
	PrintDLinkNode(Dlink, "在pos_c位置前插入一个元素u");

}

void TestInsertAfter() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkNode* pos_g = DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkListInsertAfter(pos_g, 'u');
	PrintDLinkNode(Dlink, "在pos_g之后插入一个元素u:");
}

void TestErase() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkNode* pos_g = DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkListErase(pos_g);
	PrintDLinkNode(Dlink, "删除元素g");
}

void TestRemove() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkListRemove(Dlink, 'a');
	PrintDLinkNode(Dlink, "删除元素a");

	DLinkListRemove(Dlink, 'g');
	PrintDLinkNode(Dlink, "删除元素g");

	DLinkListRemove(Dlink, 'u');
	PrintDLinkNode(Dlink, "尝试删除元素u");
}

void TestSize() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'd');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'g');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	size_t sz = DLinkListSize(Dlink);
	printf("expect 7，actual：%d", sz);
}

void TestRemoveAll() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'a');
	PrintDLinkNode(Dlink, "尾插七个元素:");

	DLinkLisrRemoveAll(&Dlink, 'a');
	PrintDLinkNode(Dlink, "删除链表中所有的元素a:");
}

void TestEmpty() {
	DLinkNode* Dlink;
	MYTESTHEADE;
	DLinkListInit(&Dlink);
	int i = DLinkListEmpty(Dlink);
	printf("expect -1,actual :%d\n",i);
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'b');
	DLinkListPushBack(Dlink, 'c');
	DLinkListPushBack(Dlink, 'a');
	DLinkListPushBack(Dlink, 'e');
	DLinkListPushBack(Dlink, 'f');
	DLinkListPushBack(Dlink, 'a');
	PrintDLinkNode(Dlink, "尾插七个元素:");
	i = DLinkListEmpty(Dlink);
	printf("expcet 1,actual :%d\n",i);
}

int main() {
	TestPushBack();
	TestPopBack();
	TestPushFront();
	TestPopFront();
	TestFind();
	TestInsert();
	TestInsertAfter();
	TestErase();
	TestRemove();
	TestSize();
	TestRemoveAll();
	TestEmpty();
	system("pause");
	return 0;
}



Qregi
关注
专栏目录
C语言中双向链表和双向循环链表详解
08-30
在C语言中，双向链表是一种数据结构，具有前驱结点和后驱结点两个指针，分别指向前一个结点和后一个结点。双向循环链表则是双向链表的一种特殊形式，其中最后一个结点的next指向头结点，头结点的prior指向最后一个...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
双向链表和双向循环链表（无头无尾节点）python
hbk5241的博客
04-15 259
# -*- coding=utf-8 -*- # software: 算法学习 # datetime:2020/4/13 12:56 下午 class Node(object): """ 链表的节点对象：包含数据与和指针域 """ def __init__(self, data=None, next=None, pre=None): self....
不使用指针实现双向链表
qq_45860423的博客
10-27 340
java中将指针封装之后，也可以实现双向链表，创建对象时产生栈，使用内存空间 参考代码 package Test; class Link{ //存放的数据 public int data; //左节点 public Link prior; //右节点 public Link next; public Link(int data) { this.data = data; } public void print() { System.out.print(data +" ");
C语言双向链表
最新发布
2301_79840227的博客
09-11 1128
2。
C语言实现双链表(带头节点)
weixin_34318326的博客
07-31 268
双链表和单链表性质相似只是在多加了一个前指针 1.定义结构体 typedef struct Node{ int data; struct Node *prior; struct Node *next; }Node,*LinkedList; 2.比单链表一个指向 LNew->data = i; L->next = LNew; LNew->...
数据结构（双向链表）（C语言）
x18261294286的博客
08-10 1283
利用C语言实现双向链表的基本功能： 头文件： //LinkList.c #ifndef _LINKLIST_H #define _LINKLIST_H #define SUCCESS 10000 #define FAILURE 10001 #define TRUE 10002 #define FALSE 10003 typedef int Elemtype; typedef s...
C语言指针（六）-- 双向链表和循环链表
难波儿万的博客
12-18 333
在“C语言指针（四）–链表”这篇文章中我讲解了单向链表，但是在链表的家族中我们还经常见到双向链表和双（单）向循环链表。我们可以从他们的名字想象出它们在内存中的样子。 我们根据上图定义双链表节点的数据结构实现插入、删除和遍历等操作： typedef struct node { int data; struct node *prev; struct node *next; }Node; ...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
在本示例中，我们关注的是C语言实现的双向循环链表。双向循环链表是一种特殊类型的链表，它允许在链表的前后两个方向上进行遍历，与传统的单链表相比，具有更大的灵活性。 首先，我们要理解链表的基本概念。链表...
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
C语言实现双向链表(navie版本)
Yannie's Blog
12-09 3683
一直以来以为自己知道双向链表，不就是每个节点都有两个指针，分别指向前驱和后继吗～错❌❌❌，大大的错。今天实现进程的就绪队列的时候，才发现自己数据结构的知识如此薄弱。 头节点和尾节点这两个成员是固定不变的，它们是链表固定的两个入口。新插入的结点不会替代它们的位置， 只是会插入在 head和 tail之间。就像火车一样，两头的火车头是不变的，要增加车厢，只是往中间加。 而我们的第一个元素也不是头节点...
C++ 循环双链表（带头结点）
qq_43650934的博客
11-19 856
文章目录总结归纳代码实现 总结归纳 在 InsertPriorNode 函数（前插操作）中，如果想在表尾处插入结点，则无法进行，需要特殊处理，比较简单，这里没有写出；同时，也可以使用 InsertNextNode 函数（后插操作）来实现。 循环双链表的实现与循环单链表大同小异，甚至还更为简洁。由于可以快速找到指定结点的前驱结点，所以很多对头结点、尾节点的插入和删除操作就不用特殊处理。 当然，循环双链表要付出一定的内存代价。 代码实现 /* 循环双链表(带头结点) */ #include <ios
数据结构-链式表之带头双向循环链表
lxt0202as的博客
07-25 644
带头双向循环列表，结构较复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环列表。虽然结构复杂，但是该结构会使程序实现简单方便。
数据结构 || 带头非循环双链表
Template Code
11-13 1554
带头非循环双链表学习
数据结构第二章顺序表的基本操作
m0_57440665的博客
10-21 346
什么是顺序表？ 顺序表是线性表的顺序表示，即用一组地址连续的存储单元依次存储线性表的数据元素 顺序表的结构图 顺序表的基本操作 定义状态量 #include <stdlib.h> #include <stdio.h> #define OK 1 #define ERROR 0 #define OVERFLOW –2 #define TRUE 1 #define FALSE 0 typedef int Status; 定义顺序表的结构体 #def...
数据结构自学记录(四):循环链表
Liuyang
11-11 3330
循环链表是另一种形式的链式存储结构形式: 循环单链表:将表中尾节点的指针域改为指向表头节点,整个链表形成一个环。由 此从表中任一节点出发均可找到链表中其他节点。节点类型与普通单链表节点类型相同. 循环双链表:...形成两个环。节点类型与普通双链表节点类型相同.          循环单链表图示: 与非循环单链表比较：1:链表中没有空的指针域. 2:p如果为尾结点,则p-&gt;next ...
【数据结构】链表最强结构-带头双向循环链表（超详解）
~
10-28 1905
目录 前言 写在前面的话 链表类型区别 带头+双向+循环链表增删查改实现 接口展示 构建节点类型 创建链表及初始化 节点开辟 链表摧毁 链表打印 链表尾插 链表尾删 链表头插 链表头删 链表查找 链表pos位置前插 链表pos删除 总结 前言 本章将带你们走进带头双向循环链表的实现与讲解 写在前面的话 在前一章我们学习实现了单链表（无头单向不循环链表），这里我们引入带头双向循环链表 很明显这两种结构截然不同，但都是作为链表最常使用链表结构 ...
单链表、双链表、循环链表和静态链表以及相应习题习题
热门推荐
Wlain的博客
08-26 1万+
一、单项选择题1.关于线性表的顺序存储结构和链式存储结构的描述中，正确的是（ ）。 Ⅰ.线性表的顺序存储结构优于其链式存储结构 Ⅱ.链式存储结构比顺序存储结构能更方便地表示各种逻辑结构 Ⅲ.如频繁使用插入和删除结点操作，顺序存储结构更优于链式存储结构 Ⅳ.顺序存储结构和链式存储结构都可以进行顺序存取A. Ⅰ、Ⅱ、Ⅲ B. Ⅱ、Ⅳ C. Ⅱ、Ⅲ D. Ⅲ、Ⅳ2.对于一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值