25版王道数据结构课后习题详细分析 第二章线性表 2.2线性表的顺序表示 代码题部分

已于 2024-10-02 16:53:41 修改
阅读量473 收藏 6
点赞数 9
分类专栏： 数据结构 文章标签： 数据结构 算法 考研
于 2024-07-28 16:37:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2406_86301373/article/details/140675047
版权

二、综合应用题

————————————————————

————————————————————

算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
using namespace std;


typedef int ElemType;
#define MaxSize 6           //定义线性表的最大长度为6

typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;

bool Del_Min(SqList &L, ElemType &value) {
	if (L.length == 0)
		return false;
	value = L.data[0];
	int pos = 0;
	for (int i = 1; i < L.length; i++) {
		if (L.data[i] < value) {
			value = L.data[i];
			pos = i;
		}
	}
	L.data[pos] = L.data[L.length - 1];
	L.length--;
	return true;

}



int main() {
	SqList L;
	int value;
	L.length = 0;
	printf("请依次输入顺序表的所有值:");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &L.data[i]);
		L.length++;                  //每输入一个数顺序表的当前长度加1 
	}

	printf("原顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");

	Del_Min(L, value);
	printf("使用函数后的顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}

	return 0;
}

运行结果：

————————————————————

————————————————————

算法思想：扫描顺序表L的前半部分元素，对于元素工.data[i](0<=i<L.length/2)，将其与后半部分的对应元素L.data[L.length-i-1]进行交换。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
#define MaxSize 6           //定义线性表的最大长度为6

typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;

void Reverse(SqList& L) {         
	ElemType temp;
	for (int i = 0; i < L.length / 2; i++) {
		temp = L.data[i];
		L.data[i] = L.data[L.length - 1 - i];
		L.data[L.length - 1 - i] = temp;
	}
}



int main() {
	SqList L;
	L.length = 0;
	printf("请依次输入顺序表的所有值:");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &L.data[i]);
		L.length++;                  //每输入一个数顺序表的当前长度加1 
	}

	printf("原顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");

	Reverse(L);
	printf("使用逆置函数后的顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}

	return 0;
}

运行结果：

————————————————————

————————————————————

算法思想：设一个变量k，初始值为0，扫描时将不等于x的元素移到下标为k的位置，并更新k值。最后需要修改L的长度。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
#define MaxSize 6           //定义线性表的最大长度为6

typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;

void Del_x(SqList& L, ElemType x) {         
	ElemType k = 0;
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] != x) {
			L.data[k] = L.data[i];
			k++;
		}
	}
	L.length = k;
}



int main() {
	SqList L;
	L.length = 0;
	printf("请依次输入顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &L.data[i]);
		L.length++;                  //每输入一个数顺序表的当前长度加1 
	}

	printf("原顺序表为: ");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");

	ElemType x;
	printf("请输入需要删除的元素x: ");
	scanf("%d", &x);

	Del_x(L, x);

	printf("使用函数后的顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}

	return 0;
}

运行结果：

————————————————————

————————————————————

算法思想：从前向后扫描顺序表L，用k记录值在s和t之间的元素个数(初始时k=0)。对于当前扫描的元素，若其值不在s和 t之间，则前移k个位置;否则执行k++。由于每个不在s和t之间的元素仅移动一次，因此算法效率高。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
#define MaxSize 6           //定义线性表的最大长度为6

typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;

bool Del_s_t(SqList& L, ElemType s, ElemType t) {
	ElemType k = 0;
	if (L.length == 0 || s >= t) {
		return false;
	}
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] >= s && L.data[i] <= t)
			k++;
		else
			L.data[i - k] = L.data[i];
	}
	L.length -= k;
	return true;
}



int main() {
	SqList L;
	L.length = 0;
	printf("请依次输入顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &L.data[i]);
		L.length++;                  //每输入一个数顺序表的当前长度加1 
	}

	printf("原顺序表为: ");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");

	ElemType s, t;
	printf("请输入s和t: ");
	scanf("%d%d", &s, &t);

	Del_s_t(L, s, t);

	printf("使用函数后的顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}

	return 0;
}

运行结果：

————————————————————

————————————————————

算法思想：注意是有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同，则继续向后判断，若不同，则插入前面的非重复有序表的最后，直至判断到表尾为止。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
#define MaxSize 6           //定义线性表的最大长度为6

typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;

bool Del_Same(SeqList& L) {
	if (L.length == 0)
		return false;
	int i, j;
	for (i = 0, j = 1; j < L.length; j++) {
		if (L.data[i] != L.data[j])    //查找与上个元素值不同的元素
			L.data[++i] = L.data[j];    //找到后，将元素前移
	}
	L.length = i + 1;
	return true;
}



int main() {
	SeqList L;
	L.length = 0;
	printf("请依次输入顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &L.data[i]);
		L.length++;                  //每输入一个数顺序表的当前长度加1 
	}

	printf("原顺序表为: ");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");

	Del_Same(L);

	printf("使用函数后的顺序表为:");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}

	return 0;
}

运行结果：

 ————————————————————

————————————————————

算法思想：首先，按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
#define MaxSize 10

typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;

bool Merge(SeqList A, SeqList B, SeqList &C) {

	//将有顺序的顺序表A,B合并到新的有序顺序表C中

	if (A.length + B.length > MaxSize)//判断非空 
		return false;

	int i = 0, j = 0, k = 0;

	while (i < A.length && j < B.length) {
		if (A.data[i] <= B.data[j])
			C.data[k++] = A.data[i++];
		else
			C.data[k++] = B.data[j++];
	}
	while (i < A.length)	//还剩一个没有比较完的顺序表 ,多余的部分，直接加在后面 
		C.data[k++] = A.data[i++];
	while (j < B.length)
		C.data[k++] = B.data[j++];
	C.length = k;
	return true;

}



int main() {
	SeqList A, B, C;
	A.length = 0;
	B.length = 0;
	C.length = 0;
	int i;
	char s;

	i = 0;
	printf("请依次输入A顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &A.data[i]);
		A.length++;
		s = getchar();
		if (s == '\n')
			break;
	}

	i = 0;
	printf("请依次输入B顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &B.data[i]);
		B.length++;
		s = getchar();
		if (s == '\n')
			break;
	}


	printf("原顺序表A为: ");
	for (int i = 0; i < A.length; i++) {
		printf("%d ", A.data[i]);
	}
	printf("\n");

	printf("原顺序表B为: ");
	for (int i = 0; i < B.length; i++) {
		printf("%d ", B.data[i]);
	}
	printf("\n");

	Merge(A, B, C);

	printf("使用函数后的顺序表C为:");
	for (int i = 0; i < C.length; i++) {
		printf("%d ", C.data[i]);
	}

	return 0;
}

运行结果：

————————————————————

————————————————————

算法思想：首先将数组A[m ＋n]中的全部元素(a1, a2, a3,… , am, b1, b2, b3,…. bn)原地逆置为(bn, bn-1, bn-2,…, b1, am, am-1, am-2,…, a1)，然后对前n个元素和后m个元素分别使用逆置算法，即可得到(b,1 b2, b3,…, bn, a1, a2, a3,…, am)，从而实现顺序表的位置互换。

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
typedef int DataType;
#define MaxSize 10

typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;


void Reverse(DataType A[], int left, int right, int arraySize) {	//起始位置left和终止位置right
	DataType temp;	//中间变量
	if (left >= right || right >= arraySize) {
		return;	//void类型的函数直接return
	}
	int mid = (left + right) / 2;
	for (int i = 0; i <= mid - left; i++) {
		temp = A[left + i];
		A[left + i] = A[right - i];
		A[right - i] = temp;
	}
}
void Exchange(DataType A[], int m, int n, int arraySize) {
	Reverse(A, 0, m + n- 1, arraySize);
	Reverse(A, 0, n - 1, arraySize);
	Reverse(A, n, m + n - 1, arraySize);
}




int main() {
	DataType A[MaxSize] = {0};
	int m = 4;
	int n = 6;
	

	printf("请依次输入顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &A[i]);
	}


	printf("原顺序表为: ");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", A[i]);
	}
	printf("\n");

	Exchange(A, m, n, MaxSize);

	printf("使用函数后的顺序表为:");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", A[i]);
	}

	return 0;
}

运行结果：

————————————————————

————————————————————

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


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

typedef int ElemType;
typedef int DataType;
#define MaxSize 6

typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;


void SearchExchangeInsert(ElemType A[], ElemType x, int n) {
	int low = 0, high = n - 1;
	int mid;	//low和high指向顺序表下界和上界的下标
	while (low <= high) {
		mid = (low + high) / 2;       //找中间位置
		if (A[mid] == x) break;    //找到x
		else if (A[mid] < x) low = mid + 1;    //到中点mid的右半部去查
		else high = mid - 1;        //到中点mid的左半部去查
	}       //下面两个if语句只会执行一个
	if (A[mid] == x && mid != n - 1) {   //若最后一个元素与x相等，则不存在与其后继交换的操作 
		int t = A[mid]; A[mid] = A[mid + 1]; A[mid + 1] = t;
	}
	if (low > high) {  //查找失败，插入数据元素X
		int i;
		for (i = n - 1; i > high; i--)   A[i + 1] = A[i];       //后移元素
		A[i + 1] = x;   //插入X
	}   //插入结束

}




int main() {
	ElemType A[MaxSize] = { 0 };
	int x;

	printf("请依次输入顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &A[i]);
	}

	printf("请输入要查找的值: ");
	scanf("%d", &x);


	printf("原顺序表为: ");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", A[i]);
	}
	printf("\n");

	SearchExchangeInsert(A, x, MaxSize);

	printf("使用函数后的顺序表为:");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", A[i]);
	}

	return 0;
}

运行效果：

————————————————————

————————————————————

解答：

(1)使用三个下标变量从小到大遍历数组。当三个下标变量指向的元素相等时，输出并向前推进指针，否则仅移动小于最大元素的下标变量，直到某个下标变量移出数组范围，即可停止。

(2)

#define _CRT_SECURE_NO_WARNINGS//禁用安全函数警告
#pragma warning(disable:6031)//禁用 6031 的安全警告


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <algorithm>
using namespace std;


typedef int ElemType;
#define MaxSize 3

typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;


void samekey(int A[], int B[], int C[], int n) {
	int i = 0, j = 0, k = 0;	//定义三个工作指针
	while (i < n && j < n && k < n) {	//相同则输出，并集体后移
		if (A[i] == B[j] && B[j] == C[k]) {
			printf("%d\n", A[i]);
			i++; j++; k++;
		}
		else {
			int maxNum = max(A[i], max(B[j], C[k]));
			if (A[i] < maxNum) i++;
			if (B[i] < maxNum) j++;
			if (C[i] < maxNum) k++;
		}
	}
}




int main() {
	ElemType A[MaxSize] = { 0 };
	ElemType B[MaxSize] = { 0 };
	ElemType C[MaxSize] = { 0 };

	printf("请依次输入A顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &A[i]);
	}
	printf("请依次输入B顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &B[i]);
	}
	printf("请依次输入C顺序表的所有值: ");
	for (int i = 0; i < MaxSize; i++) {
		scanf("%d", &C[i]);
	}


	printf("原顺序表为: ");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", A[i]);
	}
	printf("\n");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", B[i]);
	}
	printf("\n");
	for (int i = 0; i < MaxSize; i++) {
		printf("%d ", C[i]);
	}
	printf("\n");

	printf("重复的元素为:");
	samekey(A, B, C, MaxSize);





	return 0;
}

运行结果：

（3）

每个指针移动的次数不超过n次，且每次循环至少有一个指针后移，所以时间复杂度为O(n)，算法只用到了常数个变量，空间复杂度为O(1)。

————————————————————

————————————————————

解答：

————————————————————

————————————————————

解答：

————————————————————

————————————————————

解答：

————————————————————

————————————————————

解答：

————————————————————

————————————————————

解答：

苦学数据结构
关注
专栏目录
25版王道数据结构课后习题详细分析 第二章线性表 2.3线性表的链式表示 代码题部分
2406_86301373的博客
08-06 181
在带头结点的单链表工中，删除所有值为x的结点，并释放其空间，假设值为x的结点 不唯一，试编写算法以实现上述操作。 试编写在带头结点的单链表L中删除一个最小值结点的高效算法(假设该结点唯一)。 试编写算法将带头结点的单链表就地逆置，所谓“就地”是指辅助空间复杂度为O(1)。 设A和B是两个单链表(带头结点),其中元素递增有序。设计一个算法从A和B中的 公共元素产生单链表 C,要求不破坏 A、B的结点。
2024王道数据结构课后习题代码
m0_51057239的博客
03-14 4565
2.1.2 顺序表初始化（动态） 2.1.3 顺序表上插入和删除 2.2综合题 这些题是王道教材的p18-p19的1-14题，2.2.1即为第一题 2.2.2 2.2.3 未完待续… 2023年四月末之前将更新完本书所有习题
王道数据结构考研课后习题（线性表）
2201_75825034的博客
08-26 253
int* data;int length;}SeqList;int pos;L.length--;return 0;
25版王道数据结构课后习题详细分析 第二章线性表 2.2线性表的顺序表示 选择题部分
2406_86301373的博客
07-17 730
下述是顺序存储结构的优点通常说顺序表具有随机存取的特性，指的是一个顺序表所占用的存储空间大小与无关在n个元素的线性表的数组表示中，时间复杂度为O(1)的操作是在一个长度为n的顺序表中删除第i (1≤i≤n)个元素时，需向前移动个元素对于顺序表，访问第i个位置的元素和在第i个位置插入一个元素的时间复杂度为顺序表的插入算法中，当n个空间已满时，可再申请增加分配m个空间，若中请失败，则说明系统没有可分配的存储空间。在下列对顺序存储的有序表（长度为n）实现给定操作的算法中，平均时间复杂度为O(1)的是
25版王道数据结构课后习题详细分析 第二章线性表 2.3线性表的链式表示 选择题部分
2406_86301373的博客
08-06 1244
关于线性表的顺序存储结构和链式存储结构的描述中正确的是对于一个线性表，既要求能进行较快速地插入和删除链式存储设计时，结点内的存储单元地址设线性表中有2n个元素在单链表上实现要比在顺序表上实现效率更高在一个单链表中，已知q所指结点是p所指结点的前驱结点给定有n个元素的一维数组，建立一个有序单链表的最低时间复杂度是将长度为n的单链表链接在长度为m的单链表后面单链表中，增加一个头结点的目的是在一个长度为n的带头结点的单链表h上对于一个头指针为head 的带头结点的单链表通过含有n(n>1)个元素的数组a
25版王道数据结构课后习题详细分析 第二章线性表 2.1线性表的定义和基本操作
2406_86301373的博客
07-16 296
01．线性表是具有n个（)的有限序列。 A．数据表 B.字符 C．数据元素 D、数据项 02.以下()是一个线性表。 A.由n个实数组成的集合 B.由100个字符组成的序列 C．所有整数组成的序列 D、邻接表 03．在线性表中，除开始元素外，每个元素()。 A．只有唯一的前驱元素 B.只有唯一的后继元素 c．有多个前驱元素 D、有多个后继元素 2025年数据结构考研复习指导— 04．若非空线性表中的元素既没有直接前驱，又没有直接后继，则该表中有()个元素。 B.2 c.3 D.n
25版王道数据结构课后习题详细分析 第三章栈、队列和数组 3.1栈 选择题部分
2406_86301373的博客
08-09 795
单项选择题 栈和队列具有相同的 假定用数组a[1.n]存储一个栈，初始栈顶指针top=n+1,则元素x进栈的操作是 和顺序栈相比，链栈有一个比较明显的优势，即 设链表不带头结点且所有操作均在表头进行，则下列最不适合作为链栈的是向一个栈顶指针为top的链栈(不带头结点)中插入一个x结点，则执行 链栈(不带头结点)执行Pop操作，并将出栈的元素存在x中，应该执行 GetTop(st,x)3个不同元素依次进栈，能得到种不同的出栈序列 4个元素依次进栈的次序为a,b,c,d,则以c,d开头的出栈序列的个数为
2024 王道数据结构 代码习题部分 第二章 线性表
weixin_56638583的博客
09-19 347
2024 王道数据结构 代码习题部分 第二章 线性表
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
【数据结构王道2023课后练习题】线性表
07-31
【数据结构王道2023课后练习题】线性表C源码
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
热门推荐
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 429
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
【笔记】数据结构12
m0_52024881的博客
09-29 543
看到的社区的一个知识总结，这里记录一下。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1130
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 403
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1260
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1235
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
深入理解 C# 中的集合与数据结构
qq_45728381的博客
10-02 1342
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值