数据结构与算法笔记第2章 线性表 顺序表示

最新推荐文章于 2023-03-31 14:17:24 发布
最新推荐文章于 2023-03-31 14:17:24 发布
阅读量435 收藏 4
点赞数 3
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45459526/article/details/113574872
版权
2.1 线性表的定义和特点
  1. 定义：线性表是具有相同特性的数据元素的一个有限序列；
  2. ai-1，ai，ai+1 中ai-1为直接前趋ai+1为直接后继；
  3. 线性表是典型的线性结构；
  4. 线性表的优点：随机存取 ；
2.2 案例引入
  1. 一元多项式表示，记作 Pn(x)=p0+p1x+p2x2+…+pnxn，其中设定指数为 i 系数为 pi例如：P(x)=10+5x-4x2+3x3+2x4 表示为
  2. 一元多项式的运算：实现两个多项式加，减，乘运算；运算原理是分别从头遍历比较存放一元多项式的两个数组a和b的每一项，指数相同则相加存放在新数组中，指数不同则将较小的复制在新数组中。使用带头结点的链式存储实现；
2.3 线性表的类型定义

基本操作：

  • InitList(&L) 构造一个空的线性表；
  • DettroyList(&L) 销毁线性表；
  • CLearList(&L) 线性表的重置；
  • ListEmpty(L) 判断线性表是否为空，若为空则返回TURE，否则返回FALSE；
  • ListLength(L) 返回线性表L中的数据元素个数；
  • GetElem(L,i,&e) 用e返回线性表L中的第 i个数据元素的值；
  • LocateElem(L,e,compare()) 返回L中第1个与e满足compare()的数据元素的位序，若为空则返回为0；
  • PriorElem(L,cur_e,&pre_e) 若cur_e是L中的数据元素而且不是第一个元素，则用pre_e返回它的前趋，否则无效；
  • NextElemr_e,&next_e) 若cur_e是L中的数据元素而且不是最后一个元素，则用next_e返回它的后继，否则无效；
  • ListInsert(&L,i,e) 在L的第i个位置之前插入新的数据元素e，L的长度加一；
  • ListDelete(&L,i,&e) 删除L的第i个数据元素，并且用e返回其值，L的长度减一；
  • ListTraverse(&L,visited()) 依次对线性表中的每个元素调用visited()；
2.4 线性表的顺序表示
静态数组和动态数组的区别

  • 静态数组在内存中位于栈区，是在定义时就已经在栈上分配了固定大小，在运行时这个大小不能改变，如：int a[10]，在函数执行完以后，系统自动销毁；

  • 动态数组是malloc或者new出来的，位于内存的堆区，它的大小是在运行时给定，并且可以改变其，如：
    int *a;
    a = new int[10];
    动态数组，其创建麻烦，使用完必须由程序员自己通过free或者delete释放，否则严重会引起内存泄露；

  • new[]/delete[]，malloc/free new/delete 区别：他们都是对堆区的操作，程序员申请内存，用完要记得释放，否则会内存泄漏，多次申请释放，会造成堆区碎片；
    new/delete是操作符，malloc/free是标准库函数，前者可以重载，可以有构造和析构函数，可以返回某种类型对象的指针，后者返回void指针。

线性表的顺序表示
  1. 顺序表中元素存储位置的计算：LOC(ai) = LOC(a1) + (i-1) * l，其中l是每个元素所占的存储单元；
  2. 顺序表特点：地址连续，依次存放，随机存取，类型相同；
  3. 顺序表示定义模板：
#define MAXSIZE 100//顺序表所能达到的最大长度
typedef struct
{
	/*数据类型定义*/
	float real;
	double imag;
}ElemType;
typedef struct
{
	ElemType *elem;//数组动态分配
	int Length;//当前长度
}SqList;//顺序存储结构类型为SqList
补充 类C语言规定

顺序表类型定义：

[1]
typedef struct
{
	ElemType data[MAXSIZE];
	int length;
}SqList;//顺序表类型

[2]
typedef struct
{
	ElemType *elem;
	int length;
}SqList;//顺序表类型

1.ElemType 所表示的是所定义的数据类型，可以为char，int,…也可以自己定义复杂类型。
简单数据类型定义例如：

typedef char ElemType;//定义ElemType为字符型数据类型

复杂数据类型定义例如：

typedef struct
{
	int a;
	char b;
	double c;
}ElemType;

2.数组定义方式的不同
数组静态分配：

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

数组动态分配：

typedef struct
{
	ElemType *elem;
	int length;
}SqList;

例如：数组动态分配完整示例

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef struct
{
	int num;
	char name[20];
}ElemType;
typedef struct
{
	ElemType* elem;//数组基地址
	int length;
}SqList;
int main()
{
	SqList L;
	L.elem = (ElemType*)malloc(sizeof(ElemType) * MAXSIZE);//分配空间
	/*L.elem=new ElemType[MAXSIZE]*/
	……
	return 0;
}
补充 C++中的参数传递

函数调用时传递给形参表的实参必须与形参 三个一致：类型，个数，顺序；
参数传递的两种方式：传值方式，传地址；
例：两个数的交换程序
传值方式：

//输出：3 5
#include<stdio.h>
void swap(int a, int b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a=3；
	int b=5;
	swap(a, b);
	printf("%d %d\n",a,b);
	return 0;
}

由此可见，传值方式并没有改变a，b的值；
传地址：

//输出：5 3
#include<stdio.h>
void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
int main()
{
	int a = 3;
	int b = 5;
	int* p1, * p2;
	p1 = &a;
	p2 = &b;
	swap(p1, p2);
	printf("%d %d\n",a,b);
	return 0;
}

传地址：参数为指针变量，参数为引用类型，参数数组名；
数组名作参数
例：输出数组的最大值

//输出：5
#include<stdio.h>
#define N 5
int max(int b[])
{
	int i;
	int m;
	m = b[0];
	for (i = 1; i < N; i++)
	{
		if (b[i] > m)
		{
			m = b[i];
		}
	}
	return m;
}
int main()
{
	int a[N] = { 1,2,3,4,5 };
	int n;
	n = max(a);
	printf("%d\n",n);
	return 0;
}

引用类型作参数
例：两个数的交换程序

//输出：5 3
#include<stdio.h>
void swap(int &a, int &b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 3;
	int b = 5;
	swap(a, b);
	printf("%d %d\n", a, b);
	return 0;
}
2.4 线性表的顺序表实现

[ 算法2.4.1 ] 线性表L的初始化

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
int n;//定义全局变量 n
typedef int Status;
typedef char ElemType;
typedef struct
{
	ElemType* elem;
	int length;
}SqList;
Status InitList(SqList& L)
{
	L.elem = new ElemType[n];//这个 n 是可变的 
	/*L.elem = (ElemType*)malloc(sizeof(ElemType) * MAXSIZE);*/
	if (!L.elem)
	{
		exit(OVERFLOW);
	}
	L.length = 0;
	return OK;
}
int main()
{
	cin >> n;
	SqList L;
	InitList(L);
	……
	return 0;
}

[ 算法2.4.2 ] 销毁线性表

void DestroyList(SqList& L)
{
	if (L.elem)
	{
		free(L.elem);//释放存储空间
		//delete L.elem;
	}
}

[ 算法2.4.3 ] 清空线性表

void ClearList(SqList& L)
{
	L.length = 0;//将线性表的长度置为 0
}

[ 算法2.4.4 ] 求线性表的长度

int GetLength(SqList L)
{
	return (L.length);
}

[ 算法2.4.5 ] 判断线性表是否为空

int IsEmpty(SqList L)
{
	if (L.length == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

[ 算法2.4.6 ] 顺序表的取值

int GetElem(SqList L, int i, ElemType& e)
{
	if (i<1 || i>L.length)
	{
		return ERROR;
	}
	e = L.elem[i - 1];
}

[ 算法2.4.7 ] 顺序表的查找

int LocateElem(SqList L, ElemType e)
{
	int i;
	for (i = 0; i < L.length; i++)
	{
		if (L.elem[i] == e)
		{
			return i + 1;
		}
	}
	return 0;
}

[ 算法2.4.8 ] 顺序表的插入

情况分析： 插入位置在最后，插入位置在中间，插入位置在最前面；
算法思想： 判断插入位置是否合法，判断是否溢出；

Status ListInsert(SqList& L, int i, ElemType e)
{
	int j;
	if (i<1 || i>L.length + 1)
	{
		return ERROR;
	}
	if (L.length == MAXSIZE)
	{
		return ERROR;
	}
	for (j = L.length - 1; j >= i - 1; j--)
	{
		L.elem[j + 1] = L.elem[j];
	}
	L.elem[i - 1] = e;
	L.length++;
	return OK;
}

[ 算法2.4.9 ] 顺序表的删除

情况分析： 删除位置在最后，删除位置在中间，删除位置在最前面；
算法思想： 判断删除位置是否合法；

Status ListDelete(SqList& L, int i)
{
	int j;
	if (i<1 || i>L.length)
	{
		return ERROR;
	}
	for (j = i - 1; j < L.length; j++)
	{
		L.elem[j] = L.elem[j + 1];
	}
	L.length--;
	return OK;
}
顺序表的优缺点

优点：

  • 存储密度大；
  • 随机存取；

缺点：

  • 时间效率低；
  • 浪费存储空间；
  • 静态存储形式，数据元素的个数不能自由扩充；
线性表的顺序表示和实现完整参考代码
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int ElemType;
typedef int Status;
typedef struct
{
	/*
	数组动态的时候使用
	ElemType *elem;
	*/
	ElemType elem[MAXSIZE];//静态数组
	int length;
}SqList;
Status InitList(SqList& L)//线性表L的初始化
{
	/*
	数组动态的时候使用
	L.elem = (ElemType*)malloc(sizeof(ElemType) (n + 1));
	//L.elem = new ElemType[n + 1];//n + 1 的原因是因为最后 free 的时候不会认为溢出判错
	if (!L.elem)
	{
		exit(OVERFLOW);
	}
	*/
	L.length = 0;
	return OK;
}
void print(SqList L)//输出线性表
{
	int i;
	for (i = 0; i < L.length; i++)
	{
		printf("%d ",L.elem[i]);
	}
	printf("\n");
}
int GetLength(SqList L)//获取线性表的长度
{
	return L.length;
}
int IsEmpty(SqList L)//判断线性表是否为空
{
	if (L.length == 0)
	{
		return 1;//线性表为空
	}
	else
	{
		return 0;
	}
}
Status ClearList(SqList &L)//清空线性表
{
	L.length = 0;
	return OK;
}
Status GetElem(SqList L, int i, ElemType& e)//获取线性表元素
{
	if (i<1 || i>L.length)
	{
		printf("输入的取值位置错误！\n");
		return ERROR;
	}
	e = L.elem[i - 1];
	return OK;
}
int LocateElem(SqList L, ElemType e)//查找线性表元素
{
	int i;
	for (i = 0; i < L.length; i++)
	{
		if (L.elem[i] == e)
		{
			return i + 1;
		}
	}
	return 0;
}
Status ListInsert(SqList& L, int i, ElemType e)//线性表元素插入
{
	if (i<1 || i>L.length)
	{
		return ERROR;
	}
	if (L.length == MAXSIZE)
	{
		return ERROR;
	}
	for (int j = L.length - 1; j >= i - 1; j--)
	{
		L.elem[j + 1] = L.elem[j];
	}
	L.elem[i - 1] = e;
	L.length++;
	return OK;
}
Status ListDelete(SqList& L, int i)//线性表元素删除
{
	if (i<1 || i>L.length)
	{
		return ERROR;
	}
	for (int j = i - 1; j < L.length; j++)
	{
		L.elem[j] = L.elem[j + 1];
	}
	L.length--;
	return OK;
}
int main()
{
	SqList L;
	ElemType e;
	int i;
	int m;//元素的个数
	InitList(L);/*线性表L的初始化*/
	printf("输入线性表的个数：");
	scanf("%d", &m);
	printf("请输入线性表元素：");
	for (i = 0; i < m; i++)
	{
		scanf("%d", &L.elem[i]);
		L.length++;
	}
	printf("线性表的长度为：%d\n", GetLength(L));/*求线性表的长度*/
	printf("输出线性表：");
	print(L);
	printf("判断线性表是否为空：");
	if (IsEmpty(L) == 1)
	{
		printf("线性表为空\n");
	}
	else
	{
		printf("线性表不为空\n");
	}
	printf("输入要取出的位置：");
	scanf("%d",&i);
	printf("取出的值为：");
	GetElem(L, i, e);/*线性表的取值*/
	printf("%d\n",e);
	printf("输入要查找的元素：");
	scanf("%d",&e);
	printf("查找到的线性表的位置：%d\n", LocateElem(L, e));/*线性表的查找*/
	printf("输入要插入的位置：");
	scanf("%d",&i);
	printf("输入要插入的元素：");
	scanf("%d",&e);
	ListInsert(L, i, e);/*线性表的插入*/
	printf("输出线性表：");
	print(L);
	printf("输入要删除元素的位置：");
	scanf("%d", &i);
	ListDelete(L, i);/*线性表的删除*/
	printf("输出线性表：");
	print(L);
	printf("清空线性表后判断线性表是否为空：");
	ClearList(L);/*线性表的清空*/
	if (IsEmpty(L) == 1)
	{
		printf("线性表为空\n");
	}
	else
	{
		printf("线性表不为空\n");
	}
	return 0;
}
free(L.elem);
释放空间出现的错误

先看代码和错误提示：

样例输入：
3
1 1 1
样例输出：
1 1 1

#include <iostream>
using namespace std;
const int MAXSIZE = 100;
int n;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
typedef struct
{
	ElemType* elem;
	int length;
}SqList;
Status InitList(SqList &L)
{
	//L.elem = (ElemType*)malloc(sizeof(ElemType) * n);
	L.elem = new ElemType[n];
	L.length = 0;
	return OK;
}
Status print(SqList L)
{
	if (L.length == 0) return ERROR;
	else
	{
		for (int i = 0; i < L.length; i++) cout << L.elem[i] << " ";
	}
	cout << endl;
	return OK;
}
void DestroyList(SqList L)
{
	if (L.elem) free(L.elem);
}
int main()
{
	SqList L;
	InitList(L);
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> L.elem[i];
		L.length++;
	}
	print(L);
	DestroyList(L);
	return 0;
}

在这里插入图片描述
发现错误的原因是代码 L.elem = new ElemType[n]; 这一行，因为输入了 n 个数，所以我申请开辟的空间乘以了 n 个，但是在最后的释放的时候会显示错误弹窗。当把代码改成 L.elem = new ElemType[n + 1]; 的时候就会正确。

正确代码如下：

#include <iostream>
using namespace std;
const int MAXSIZE = 100;
int n;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
typedef struct
{
	ElemType* elem;
	int length;
}SqList;
Status InitList(SqList &L)
{
	//L.elem = (ElemType*)malloc(sizeof(ElemType) * (n + 1));
	L.elem = new ElemType[n + 1];
	L.length = 0;
	return OK;
}
Status print(SqList L)
{
	if (L.length == 0) return ERROR;
	else
	{
		for (int i = 0; i < L.length; i++) cout << L.elem[i] << " ";
	}
	cout << endl;
	return OK;
}
void DestroyList(SqList L)
{
	if (L.elem) free(L.elem);
}
int main()
{
	SqList L;
	InitList(L);
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> L.elem[i];
		L.length++;
	}
	print(L);
	DestroyList(L);
	return 0;
}

free()的时候程序宕机，很多时候都是和内存溢出或者说内存分配问题有关，一句话就是你想释放的内存和你释放的内存不一致，很多时候是大小不一致。 因为在分配的时候，代码：L.elem = new ElemType[n]； 上面只开辟了sizeof(n)个内存，但是实际上节点被绑到其它数据块上了，它远远不止sizeof(n)字节的内存，因此在释放上就会存在内存溢出的错误。

清纯献给了作业
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2.线性表顺序表，模板类实现
xiguanlant的博客
08-22 233
线性表的定义和基本概念 定义： 线性表是具有相同数据类型的n (n>=0）个数据元素的有限序列，其中n为表长，当n = 0时线性表是一个空表。若用L命名线性表，则其一般表示为 L = (a1, a2, …. , ai, ai+1,…. , an) 顺序表： 定义： 用顺序存储的方式实现线性表 实现： 头文件：SList.h #ifndef _SLIST_H_ #define _SLIST_H_ #define MaxSize 100 // 最大长度 //静态分配 template<cl
线性表的操作 (1)实现 A= A U B
zmg_指针博客
05-13 547
/* LA和LB分别表示两个集合(现在要求一个新的集合 A = A U B) LA = {1,2,3,4} LB = {2,3,4,5}*/ #include #include #include #define LIST_INIT_SIZE 10 //线性表存储空间的初始分配量 #define LISTINCREMENT 2 //线性表存储空间的分配增量 typedef struct
线性表-顺序存储结构之顺序表
Code-lover's Learning Notes
08-14 3141
顺序表 1． 顺序表的定义 (1) 顺序存储方法 　 即把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。 (2) 顺序表（Sequential List） 　 用顺序存储方法存储的线性表简称为顺序表（Sequential List）。 2． 结点ai 的存储地址 　不失一般性，设线性表中所有结点的类型相同，则每个结点所占用存储空间大小亦相同。假设表中每个
教新手小白学习——线性表
最新发布
m0_74781727的博客
03-31 127
教新手小白学习——线性表（往后会持续更新）
链表的基础操作实现
qq_44749483的博客
10-22 302
首先是构造链表 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef struct{ int *elem; int length; }SqList;//定义一个结构体 void InitList(SqList *L)//构造一个空的链表 { L->elem=(int *)malloc...
数据结构与算法笔记（三）线性表 定义线性表节点的结构.pdf
04-18
线性表是一种基础而重要的数据结构，它是由n（n>=0...总的来说，线性表和链表是数据结构的基础，它们的理解和熟练应用是学习更高级算法和数据结构的前提。无论是面试还是实际开发，掌握好这些基础知识都是非常关键的。
链表顺序表实验报告--数据结构与算法分析.doc
10-10
链表顺序表实验报告数据结构与算法分析 本实验报告的标题为“链表顺序表实验报告--数据结构与算法分析”，该报告的描述为数据结构与算法分析课程设计报告，标签为“windows”。实验报告的主要内容是使用 C++ 语言...
自考数据结构笔记.ppt
02-21
本资源摘要信息来自自考数据结构笔记.ppt，涵盖了数据结构的基本概念、算法和算法分析、线性表的逻辑结构和存储结构等知识点。 一、数据结构基本概念 数据结构是研究非数值计算的程序设计问题中计算机的操作对象及...
数据结构考研 笔记 完结 西电）.pdf
11-04
本笔记总结了数据结构的基本概念、逻辑结构、存储结构、数据运算等知识点，涵盖了线性表、栈、队列、串、树、图、查找、排序等数据结构的基本概念和算法。 一、逻辑结构 * 线性结构：元素之间的逻辑关系是线性的，...
数据结构视频教程学习笔记
12-19
在本教程的第二章中，我们深入研究了线性表的顺序存储结构，即顺序表。顺序表通常使用一维数组实现，数组下标从0开始，而线性表元素序号从1开始。这导致逻辑位序和物理位序相差1。顺序表的操作包括初始化、销毁、...
数据结构之线性表
qq_43607916的博客
10-05 285
线性表 文章目录： 线性表的定义 线性表的基本操作 顺序表的定义 顺序表的两种实现方式 顺序表的基本操作 其他笔记的总结 3.顺序表的定义 4.顺序表的两种实现方式 静态分配 动态分配 5.顺序表的基本操作 插入 删除 按位查找 按值查找 6.其他笔记的总结 以上是顺序表的内容，之后会更新单链表的相关知识内容。 ...
（数据结构习题）向类型为Sqlist的顺序表L的第i个元素之后插入一个新元素x。
烟敛寒林的博客
09-21 1万+
向类型有Sqlist的顺序表L的第i个元素（0&lt;=i&lt;=L.len）之后插入一个新元素x。 Status ListInsert(SqList *L,int i,ElemType x) { // 向线性表L中第i个元素之后插入值为x的新元素 if( L-&gt;length == 0 ) // 顺序表为空 return ERROR; if( i...
数据结构之线性表(三)——顺序存储结构(2 C/C++语言有关操作)
daocaoren_的博客
07-16 405
顺序表类型定义，如下， typedef struct { ElemType data[]; int length }SqList; 这里的ElemType是顺序表中数据元素的类型。 如果数据元素类型为字符，ElemType定义如下， typedef char ElemType 如果数据元素类型为整型，ElemType定义如下， typedef int ElemType 等等，也...
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
【数据结构】顺序表定义和基本操作
Z_sea的博客
12-11 3663
线性表主要两种结构： 顺序存储  和  链式存储： 这次写的顺序表，指的是线性表的顺序存储模式； 定义类型： #define ListInitSize 100 #define ListIncrement 10 #define LElemType int typedef struct Sqlist{ LElemType *base; int length; int...
C语言实现顺序表的基本操作
OnlyLove_KD的博客
09-12 2万+
数据结构老师给了几个接口，叫我们自己去实现顺序表的功能，感想就是顺序表实现起来比链表容易，但是还是要花费挺长的时间来构思，这一次的收获还是挺多的。
【数据结构与算法分析】 第三章 表
zhangxiafll的博客
08-14 275
【数据结构与算法分析】 第三章 表 1.抽象数据类型 抽象数据类型（ADT）是一些操作的集合。 对表、集合、图和他们的操作一起可以看作是抽象数据类型，就像整数、实数和布尔量是数据类型一样。对于集合ADT，可以有并、交、测定大小及取余等操作。或者只要两种操作：并和查找，这两种操作又在该集合上定义了一种不同的ADT 2.表ADT 在表ADT上运行的操作的集合： PrintList和Make...
线性表 代码展示
one_above_all_的博客
03-21 264
1.顺式线性表 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<windows.h> //函数结果状态字符 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0
面试——数据结构二
weixin_30325071的博客
06-25 46
排序及查找方法 #include <malloc.h> #include<stdio.h> #define N 11 /*用监视哨查找*/ int search(int array[],int n,int k) {int i; i=n-1; array[0]=k; while(array[i]!=k) i--; return(i); } /*...
数据结构与算法学习笔记：线性表和顺序存储
"数据结构与算法的学习笔记，包含基本数据结构的概念、代码实现及图片，但笔记格式不美观。" 本文将深入探讨数据结构与算法的相关知识，首先，我们要理解数据结构这一概念。数据结构是一门研究非数值计算中数据元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

清纯献给了作业

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值