数据结构代码题--计算机考研大师兄

已于 2023-12-02 17:18:40 修改
阅读量316 收藏 11
点赞数
文章标签： 数据结构 考研
于 2023-11-08 23:54:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chocolatey/article/details/133869350
版权

图的广度优先遍历

FirstNeighbor,NextNeighbor,需要用到图Graph，队列Enqueue,Dequeue，数组visit[];

bool visited[MAX_VERTEX_NUM];//标记访问数组
//如果是非连通图需要加上下面这段代码
//1.初始化数组
//2.初始化队列
void BFSTravel(Grapg G){
	for(i=0;i<G.vexnum;++i){
		visited[i]=FALSE;
		}//for
	InitQueue(Q);
	for(i=0;i<G.vexnum;++i){
		if(!visited[i])
			BFS(G,i);
		}//for
}
//广度优先遍历
void BFS(Graph G,int v){
	visit(v);
	visited[v]=TRUE;
	Enqueue(Q,v);
	while(!isEmpty(Q)){
		Dequeue(Q,v);
		for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w){
			if(!visited[w]){
				visit(w);
				visted[w]=TRUE;
				EnQueue(Q,w);
				}//if
			}//for
		}while
}

图的深度优先遍历

需要数组visited[],图Graph;

bool viste[MAX_VERTEX_NUM];
void DFSTravel(Graph G){
	for(v=0;v<G.vexnum;++v)
		visited[v]=FALSE;
	for(v=0;v<G.vexnum;++v){
		if(!visited[v])
			DFS(G,v);
		}
}
void DFS(Grapg G,int v){
	visit(v);
	visited[v]=TRUE;
	for(w=FirstNeighbor;w>=0;w=NextNeighbor(G,v,w){
		if(!visited[w])
			DFS(G,W);
		}//for
}

DAY1

在这里插入图片描述
算法思想：让p指针从第一个元素开始遍历整个数据，用指针q标记值为x的结点并删除。
tips：删除某结点要按照后前的顺序修改指针，遍历链表按照前后的顺序修改指针，且pre一开始是指向头结点的，p指向第一个元素。

bool Delete_X(SeqList &L,int x){
    //遍历指针p
    //标记指针q
    //p的前指针pre
    LNODE *p=L->next, *q,*pre=L;
    while(p!=NULL){
      if(p->data==x){
        q=p;
        p=p->next;
        pre->next=p;
        free(p);
        L->Length--;
      }else{
         pre=p;
         p=p->next;
      }
    }
}

DAY 2

在这里插入图片描述
算法思想：将顺序表A中元素依次和B表中元素比较，把比较小的那个元素放入C表，指针各加一后再依次遍历，直至一个表为空，把另一个表中的剩余元素都加入C表即可。

bool Merge(SqList &A,SqList &B,SqList &C){
if(A.length+B.length>C.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];
      k++;
      i++;
    }else{
      C.data[k]=B.data[jJ;
      k++;
      j++;
    }
  }
  while(i<A.length){//忘了剩下的元素
  C.data[k]=A.data[i];
  k++;
  i++;
  }
  while(j<B.length){
    C.data[k]=B.data[j];
    k++;
    j++;
  }
  C.length=k;//忘了长度
  return ture;
}

DAY3

在这里插入图片描述
算法思想1：依次交换第一个元素和最后一个元素；
算法思想2：用递归实现；

tips:数组元素从0——n，长度为L.length=n+1,n=L.length-1

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

方法二：
void Reverse(int low,int hign,int *A){
	while(low<high){
		Swap(A[low],A[high]
	}
}

DAY4

![在这里插入图片描述](https://img-blog.csdnimg.cn/b5e7672eaa944553a2c241e2f60955ec.png
算法思想：设置一个定时器k，遍历整个顺序表，若当前元素值为k，则k+1,后面元素向前移动k+1个单位。

void Delete_X (SqList &L,int x）{
	int k=0;
	for(int i=0;i<=L.length-1;i++){
		if(L.data[i]==x){
			k++;
		else
			L.data[i-k]=L.data[i];
		}
	}
	L.length=L.length-k;
	return true;
}

DAY5

在这里插入图片描述
算法思想一：设置一个计数器K，从头遍历顺序表，若当前元素在s和t之间，则k加1，其他不满足条件的元素向前移动k个位置，
算法思想2：将顺序表有序排列，再从头遍历。

bool Delete(SqList &L,int s,int t){
	if(s<=t) return false;
	if(L.length<=0) return false;
	int k=0;  //计数器
	for(int i=0;i<=L.length-1;i++){
		if(L.data[i]<=t&&L.data[i]>=s){
			k++;
		}	
		L.data[i-k]=L.data[i];
	}
	L.length=L.length-k;
	return true;
}

DAY6

在这里插入图片描述
算法思想：从第二个元素开始遍历，若前后两个元素相等则不保留，不相等则保留。

bool Delete_Same(SqList %L){
	int i=1;//第一个元素不会重复，所有从下标1开始
	int j=i+1;
	int k=0;//计数器
	for(i=0;i<=L,length-1;i++){
		if(L.data[i]!=L.data[j]{
			i++;j++;
		}else{
			j++;
			k++;
		}
	}
	L。length=L.length-k;
	return true;
}

DAY7

在这里插入图片描述

bool Reverse(SqList &A,int low,int high){
//这个函数传入的参数为
	/*要逆置的数组
	 *要逆置这个数组那一段的开始下标from
	 *要逆置那一段的结束下标to
	 */
	int temp;
	for(i=0;i<(high-low+1)/2;i++){
		temp=L.data[low+i];
		L.data[low+i]=L.data[high-i];
		L.data[high-1]=temp;
	}
	return true
}
void Exchange(SqList &A,int n,int m){
	Reverse(A,0,m-1);
	Reverse(A,m,m+n-1);
	Reverse(A,0,m+n-1);
}

DAY8

在这里插入图片描述

void Reverse(int R[],int from,int to){
	int temp;
	for(i=0;i<=(to-from+1)/2;i++){
		temp=R.data[from+i];
		R.data[from+i]=R.data[to-i];
		R.data[to-i]=temp;
	}
}
void Exchange(int R[],int m,int n){
	Reverse(R,0,p-1);
	Reverse(R,p,n-1);
	Reverse(R,0,n-1);
}

DAY9

在这里插入图片描述
最小值指针min,假设第一个最小，p指针遍历，找到最小的，找到后把pre的next指向min的下一个

void Delete_Min(LinkList &L){
	LNode *p=L->next;
	LNode *pre=L;
	LNode *min=p;
	LNode *minpre=L;
	while(p!=NULL){
		if(p->next->data>min->data){
			pre=p;
			p=p->next;
		}else{
			min=p;
			minpre=pre;
			pre=p;
			p=p->next;
		}
	}
	minpre->next=min->next;
	free(min);
}

DAY10

在这里插入图片描述
传入一个头结点，头指针，新建一个结点s,头插入头结点后面

LinkList Create_Head(LinkList &L){
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	x=scanf("%d",&x);
	while(x!=-1){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
	}
	return L;
}

DAY11

在这里插入图片描述

LinkList Create_Head(LinkList &L){
	LNode *s,*p=L;//p为末尾指针
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	x=scanf("%d",&x);
	while(x!=-1){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		s->next=p->next;
		p->next=s;
		p=s;
		p->next=NULL;
	}
	return L;
}

DAY12

在这里插入图片描述

LinkList Reverse(LinkList &L){
	LNode *p=L->next;
	LNode *q;
	while(p!=NULL){
		p=p->next;
		if(p->next==NULL){
			q=L->next;
			L->next=q->next;
			q->next=p->next;
			p->next=q;
			p=q;
		}
	}
	return L;
}

DAY13

在这里插入图片描述

LinkList Delete(LinkList &L,ElemType s,ElemType t){
	LNode *p=L->next;
	LNode *pre=L;
	while(p!=NULL){
		if(p->data>=s&&p->data<=t){
			pre->next=p->next;
			free(p);
			p=pre->next;//这句自己写的时候忘记了，要纠错！！
		}
		pre=p;
		p=p->next;
	}
}

DAY14在这里插入图片描述

方法一：暴力法（p指针不动，让q指针多次遍历）

LinkList Find_Same(LinkList &LA,LinkList &LB){
	LNode *p = LA->next;
	LNode *q = LB->next;
	while(p!=NULL){
		while(q!=NULL){
			if(q!=p){
				q=q->next;
			}
		}
		p=p->next;
		q=LB->next;//这句忘了，要纠错！！
	}
	return p;
}

方法二：有共同结点的两个链表，一定会有共同的表尾结点。所以让两个链表的指针在长度一样的地方同时出发，看表尾结点是否相同（默认表长已知）新思路记下来

LinkList Find_Same(LinkList &LA,LinkList &LB){
	LNode *p=LA->next;
	LNode *q=LB->next;
	int lenA=length(LA);
	int lenB=length(LB);
	if(lenA>lenB){	//让p始终指向较长的单链表
		int k=lenA-lenB;
		p=LA->next;
		q=LB->next;
	}else{
		int k=lenB-lenA;
		q=LA->next;
		p=LB->next;
	}
	while(k--){//让p指针后移（先走）K个单位，这个很牛！要记下来！
		p=p->next;
	}
	while（p!=NULL){
		if(p=q){
			return p;
		}else{
		p=p->next;
		q=q->next;
		}
	}
}

DAY15

在这里插入图片描述
算法思想：注意奇偶性指的是序号，不是元素，

LinkList Creat(LinkList &A){
	int i=0;
	LNode *LB=(LNode *)malloc(sizeof(LNode));
	LB->next=NULL;
	LNode *rb=LB;
	LNode *ra=LA;
	LNode *p=LA->next;
	LA->next=NULL;
	while(p!=NULL){
		i++;
		if(i%2==0){
			rb->next=p;
			rb=p;
			}else{
			ra->next=p;
			ra=p
			}
			p=p->next;
		}
	ra->next=NULL;
	rb->next=NULL;
	return B;
}

DAY16

在这里插入图片描述
算法思想：A表尾插，B表头插

LinkList Create(LinkList &hc){
	LNode *LA=(LNode *)malloc(sizeof(LNode));
	LNode *LB=(LNode *)malloc(sizeof(LNode));
	LA->next=NULL;
	LB->next=NULL;
	LNode *ra=LA;
	LNode *q;
	LNode *p=hc->next;
	hc->next=NULL;
	while(p!=NULL){
		i++;
		if(i%2!=0){
			ra->next=p;
			ra=p;
		}else{
			q=p;
			q->next=LB->next;
			LB->next=q;
		}
		p=p->next;
	}
	ra->next=NULL;
	
	
}

DAY17

在这里插入图片描述

LinkList Delete_Sane(LinkList &A){
	LNode *p=L->next;
	LNode *pre=L;
	while(p!=NULL){
	if(pre->data==p->data){
		pre->next=p->next;
		free(p);
		p=pre->next;
	}else{
		pre=p;
		p=p->next;
		}
	}
	return A;
}

DAY18

在这里插入图片描述
算法思想：依次比较两个单链表A、B中元素的大小，把较小的元素头插入链表A，最后判断是否有剩余的元素，依次头插入A即可

LinkList Creat(LinkList &A,LinkList &B){
	LNode *p=LA->next;
	LNode *q=LB->next;
	LNode *ra,*rb;
	while(p&&q){
		if(q->data<=p->data){
			rb=q->next;
			q->next=LA->next;
			LA->next=q;
			q=rb;
		}else{
			ra=p->next;
			p->next=LA->next;
			LA->next=p;
			p=ra;
		}
	}
	if(p){
		ra=p->next;
		p->next=LA->next;
		LA->next=p;
		p=ra;
	}
	if(q){
		rb=q->next;
		q->next=LB->next;
		LB->next=q;
		q=rb;
		}
		free(B)
		return A;
	
}

DAY19

在这里插入图片描述
算法思想：先找到公共结点，再给A、B的尾指针置空，C表的头结点指向公共结点。

LinkList Create(LinkList &A,LinkList &B){
	int lenA=Len(A);
	int lenB=Len(B);
	LNode *p=LA->next;
	LNode *q=LB->next;
	LNode *preA=LA;
	LNode *preB=LB;
	if(lenA>lenB)
		i=lenA-lenB;
		while(i--){
			preA=p;
			p=p->next;
	}
	else
		i=lenB-lenA;
		while(i--){
			preB=q;
			q=q->next;
	}
	while(p!=q){
		pre
	}
}

DAY25

在这里插入图片描述

Locate(L,x){
	DNode *p=L->next;
	DNode *q;
	while(p!=NULL){
		if(p->data==x){
			p->freq++;
			q=p->pred;
			//指针q从p往前寻找，找打大于p的freq或者走到表头，就把p插入后面
			if(q->freq>p->freq||q==L){
				//把p从表中取下
				p->pred->next=p->next;
				p->next->pred=p->pred;
				//再把p插入到q后面
				p-next=q->next;
				q->next->pred=p;
				p->pred=q;
				q->next=p;}
		}else{
			p=p->next;
			}
	
}

DAY26

在这里插入图片描述
（1）算法思想：查找倒数第K个结点，也就是正数第length-K+1个结点，从第一个结点往后遍历，找到第length-K+1个结点后，返回结点值和1，若查找失败则返回0。
（2）算法思想：设置两个指针pq，让p先走k个单位，然后pq一起移动，知道p指向空结点，则q即为所求结点。

方法一：

int Find_K(LinkList &L,int k){
	int k;
	LNode *p=list;
	LNode *q;
	int count=0;
	int length=0;
	int Length(L){//求链表长度
		while(p!=NULL){
		p=p->next;
		length++;
		}
		return length;
	}
	if(L->length<k) return 0;//如果链表长度小于k，则查找失败
	p=list->next;
	while(p!=NULL){//判断是否是倒数第k个元素
		if(count==L->length-k+1){
			return p->data;
		}else{
			p=p->next;
			count++;
			} //if
	}//while
	return 1;
}//int

方法二：

int Find_K(LinkList &L,int k){
	LNode *p=list;
	LNode *q=list;
	while(k>1){//让p先走k个单位
		p=p->next;
		k--;
	}//while
	while(p!=NULL){
		p=p->next;
		q=q->next;
	}
	printf("倒数第k个元素的值为"%d"",q->data);
	return 1;
}

DAY27

在这里插入图片描述
算法思想：先求出两个单链表的长度差k，让较长的链表的遍历指针先走k个单位后，再一起移动指针，直到两个指针的next域指向同一个结点并返回该节点。

LNode Find_Common(LinkList &LA,LinkList &LB){
	LNode *str1=LA;
	LNode *str2=LB;
	int lenA=length(LA,str1);
	int lenB=length(LB,str2);
	int length=1;
	int i;//长度差
	int length(L,p){
		while(p!=NULL){
			length++;
			p-p->next;
		}
}
	if(lenA>lenB){
		i=lenA-lenB;
		str1=LA->next;
		str2=LB->next;
	}else{
		i=lenB-lenA;
		str1=LB->next;
		str2=LA->next;
	}//if
	while(str1!=NULL){
		if(i>0)
			i--;
			str1=str1->next;
	}//while
	while(str1->next!=str2->next){
		str1=str1->next;
		str2=str2->next;	
	}//while
	return str1->next;
}
奶糖study
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
大师兄手把手教你写考研数据结构代码题（50天代码整理合集）f
Senbonzakura_py的博客
10-20 1万+
考研数据结构必会的代码题目
2022年贵州大学计算机考研（初试+复试+实验室经验贴）
qq_34146295的博客
05-26 1万+
初试篇 ​​​ 初试估分英语85，政治75往上，结果差强人意吧。 首先讲一下自己考研经历，属于双非、在职、跨考840，直接三层debuff。 关于是否歧视双非：和同学聊了聊，一致是认为贵大计院是很公平的，不存在歧视情况，但是双非肯定是有优势的。所以别给自己那么多焦虑吧，好好备考。 关于跨考：是信工跨考计算机专业，本科期间进过实验室，做过挺多项目，所以对专业课并没有抵触心理，专业课学起来也比较轻松。只要你本科进过实验室、真正有过计算机竞赛经历、认真做过计算机项目，跨考应该是不难的。至于没有学过C语言
手把手教你考研《数据结构》代码题
m0_59990639的博客
08-20 4914
手把手教你写考研数据结构代码题 计算机考研，一旦达到了后半程，那么数据结构的代码题，就会成为很多学生的拦路虎，让很多学生都痛苦不堪，为了帮助大家更好的学习代码题，所以整理了考研数据结构一些必考的代码题的讲解，希望可以帮助到你！ 有问题随时来问我：B站/微信公众号：计算机考研大师兄 欢迎大家一起来讨论22计算机考研！ 加油，冲！ ...
考研数据结构算法学习笔记整理-1
qq_51219960的博客
09-22 488
考研数据结构算法学习笔记整理
上海电力大学计算机考研（840数据结构）经验分享
m0_73693599的博客
04-11 1357
我是23年上岸上海电力大学计算机专硕，由于有不少朋友都私信我问上岸的经验，想要做的笔记和院校真题，所以我建了一个群，在里面免费回答大家的备考问题，想了解的朋友们可以加群了解一下。学习c语言( 上电专业课编程题较多，所以要必要掌握)，推荐浙大温凯老师，从b站边看视频，边敲代码，尤其注重指针那一块的知识，是重难点。再补充一点个人情况，本人是一名跨考生，本科期间只学过c语言（大学的课程，不用我说什么，大家都懂的），专业课基本上算是零基础。不断默写这道算法题，找到类似的算法题，多总结，多默写，直到掌握为止。
2021-08-20
m0_59990639的博客
08-20 463
高效复习考研数据结构代码题（文字版） 如何高效复习代码题？大师兄独门秘籍给你了！快签收！ 哈喽，大家好，我是大师兄！ 虽然我一直都在讲解《手把手教你写考研数据结构代码题》课程，但是一直都没有系统的给大家讲一讲，到底该如何高效的复习数据结构代码题？然后，最近也一直有小伙伴在问我，所以今天我就大家清楚的讲一讲到底该如何高效的复习数据结构代码题。 对于这个问题，我也反复了问过不下于50个人，有已经上岸的考生，有今年22还在备考的考生。但是也一直没有得到比较系统的回答，或者说一...
大学计算机系最努力的同学都是如何学习的？
热门推荐
启舰
06-21 23万+
经常会被同学们问到这个问题，要怎么努力才能找到好工作？ 学习好就能进好公司？ 屁！ 被学校教育坑的一把鼻涕一把泪的老学长来回答一波。 我上大学时，连续三年得过国家励志奖学金，英语过六级，以为软考有用，还考了个软件设计师证书，以为四级有用，也考了个软件测试工程师证书，看人家用c++写软件，自学MFC写了几个桌面小程序。 自以为很牛逼的去找工作，结果要价2500，都没人收，2011年，一个计算机系top级毕业生，薪资还没流水线的高。 现在工作近十年，也辗转几个大厂，做校招、社招面试也不下于上百场，这
20 杭电计算机考研经验
zyf的博客
06-01 1万+
0.前言 ​ 现在是3.16日，由于新冠肺炎的原因复试遥遥无期。因此打算先写一下初试的经验贴。如果有幸过了复试，那么到时候再来更新。希望下面的经验有助于各位21的hduer。 本次经验贴目录如下： 心路 复习所用资料（数学+英语+政治+专业[附上网盘资源]+其他小提醒） 复习时间安排 我是报的杭州电子科技大学计算机专硕，惯例，先上报一下初试分数： 政治 英语一 数学一 计算...
西南交通大学2006—2014年所有真题
04-08
【数据结构】是计算机科学中的核心课程之一，主要研究如何高效地组织和管理数据，以便在计算机中进行存储、检索和处理。西南交通大学信息科学与技术学院的硕士研究生入学考试中，数据结构是一个重要的考察点，反映了...
2021计算机(科技软件电子信息技术)考研报告总结
zhaoyun198769的博客
12-31 1119
先强调，本篇更多的是个人总结回顾，具体备考过程仅供参考，一定要发挥主观能动性。 决定考研之前# 其实我决定考研的时间挺晚的，大概是去年(2019年)12月初才决定的。决定的过程也是比较仓促，原计划是打算寒假开始准备实习，后来经过几个师兄的洗脑，也见证了几位师兄找工作过程的曲折，加之自觉本科这几年也是确实没有很努力去学习专业知识，对于找工作不是很有信心，最后还是决定备考。 考研本身就是一场豪赌，赌的是报考院校的选择，赌的是自己的努力，赌赢了上岸(就算上岸也不是终点，是新生活、新奋斗的起点)；赌输了，那面临的将
计算机专业考农业工程与信息技术,中国农业大学农业工程与信息技术2021考研经验指导...
weixin_39969881的博客
07-29 982
原标题：中国农业大学农业工程与信息技术2021考研经验指导一、专业信息所属院校：中国农业大学招生类别：全日制研究生所属学院：信息与电气工程学院所属门类代码、名称：[09]农学所属一级学科代码、名称：[51]农业推广硕士二、招生详情研究方向：(00)不区分研究方向招生人数：5考试科目：①(101)思想政治理论②(204)英语二③(341)农业知识综合三④(809)地理信息系统或①(101)思想政治理...
有哪些值得推荐的计算机专业的竞赛？
启舰
08-19 4万+
这篇文章想必会得罪不少竞赛举办方，但事实就是，除了ACM以外的其它竞赛，作用并没有想象的那么大。 如果你想通过一场竞赛奖牌就能找到工作？恐怕只有ACM才有这个实力。 其它竞赛，都只起到锦上添花的作用，只有竞赛奖牌没有实际能力，想找份工作恐怕也并不是那么容易。 对于工作而言，有些证书可能作用不大，但对于考研来说却是有用的。 计算机里的竞赛有很多，官方和非官方的多到数不胜数，现在一些机构打个竞赛的名义招生，也是屡见不鲜。 下面列出来一些常见的官方主办的竞赛供大家参考，如有遗漏，欢迎评论添加： 算法在
【一战成硕】西安电子科技大学833/834上岸经验贴
风口IT猪的成长录
04-08 4728
考研顺利上岸，努力一定会有好的结果！加油!努力!
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 936
Redis 底层数据结构详解
【数据结构】线性表的顺序表示（顺序表的定义和基本操作）
zhousanguhe的博客
08-23 356
线性表的顺序表示（顺序表的定义和基本操作：初始化/插入/删除/查找）
二叉搜索树：数据结构之美
最新发布
wgr050505的博客
08-26 391
本文介绍了二叉搜索树的基本概念、主要操作以及一些高级主题。通过学习这些内容，您不仅能够理解二叉搜索树的工作原理，还能够掌握如何有效地使用它们来解决实际问题。此外，本文还探讨了自平衡二叉搜索树的概念，这是处理大规模数据集时的一个重要工具。
重新理解操作系统（linux）、编程语言和算法与数据结构
crawer
08-23 441
怎样理解操作系统（linux）、编程语言和算法与数据结构
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
业精于勤，荒于嬉
08-22 855
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
清华大学计算机考研数据结构真题精选1800题解析
"清华计算机考研数据结构1800题.pdf，包含了从60多所院校历年考研试卷中精选出的1800道数据结构真题及详细答案，旨在帮助考生备考清华大学计算机专业的研究生考试。" 这篇资料主要涵盖的数据结构知识点包括： 1. *...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值