数据结构考研代码

最新推荐文章于 2023-06-02 00:09:21 发布
最新推荐文章于 2023-06-02 00:09:21 发布
阅读量1.5k 收藏 32
点赞数 3
分类专栏： 考研 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43629361/article/details/119815996
版权
本文档详尽地列举了数据结构考研中的关键代码实现，包括线性表、栈、队列、数组、矩阵、广义表、串、树与二叉树、图、查找以及内部排序等章节，涵盖了各种数据结构的基本操作和算法应用。
摘要由CSDN通过智能技术生成

数据结构考研代码

第一章：线性表

1.一维数组静态分配

#define MaxSize 50           //线性表的最大长度
typedef struct {
   
	ElemType data[MaxSize];  //顺序表的元素
	                         //ElemType是由typedef定义的数组元素的类型
	int length;              //顺序表的当前长度
}SqList;

2.一维数组动态分配

#define InitSize 100         //表长的初始定义
typedef struct {
   
	ElemType *data;          //指示动态分配数组的指针
	int length,              //顺序表的当前长度
	    MaxSize;             //动态数组的最大容量
}SqList;
/*动态分配空间*/
L.data = (ElemType *)malloc(InitSize *sizeof(ElemType));

3.元素e插入到顺序表L中位序i的位置

bool ListInsert(SqList &L. int i, ElemType e){
   
	                               //下标[1,L.length+1]
	if(i<1 || i>L.length+1)
		return false;
	                               //当前存储空间已满，不能插入
	if(L.length >= MaxSize)
		return false;
	                               //移位
	for(int j=L.length;j>=i;j--)
		L.data[j] = L.data[j-1];
	L.data[i-1] = e;               //插入
	L.length++;                    //表长+1
	return true;
}

4.删除顺序表L中第i个位置的元素

bool listDelete(SqList &L; int i; ElemType &e){
   
	                                  //非法判断
	if(i<1 || i>L.length){
   
		return false;
	}
	                                  //去除需要删除的元素的元素
	e = L.data[i-1];
	                                  //移位
	for(int j=i; j<L.length; ++j){
   
		L.data[j-1] = L.data[j];
	}
	                                  //长度-1
	L.length--;
	return true;
}

5.查找顺序表中值为e的元素，如果查找成功，返回元素位序，否则返回0

int LocateElem(SqList L, ElemType e){
   
	int i;
	for(i=0; i<L.length; ++i){
   
		if(L.data[i] == e){
   
			return i+1;  //位序与下标有1的差距
		}
	}
	return 0;            //查找失败
}

6.单链表结点类型描述

typedef struct LNode{
   
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;

7.头插法建立单链表

LinkList creatListByHead(LinkList &L){
   
	LNode *s; //工作指针
	int x;    //存入输入元素
	
	L = (LinkList)malloc(sizeof(LNode));  //创建头节点
	L->next = NULL;                       //初始为空表
	scanf("%d",&x);                       //读取输入值
	
	while(x != 9999){
                        //约定输入9999表示创建结束
		s = (LinkList)malloc(sizeof(LNode));  //创建新节点
		s->data = x;                      //设置数据域
		/*插s到表头*/
		s->next = L->next;                //s后继设置L
		L->next = s;                      //L后继设置s
		scanf("%d",&x);
	}
	return L;                             //返头节点
}

8.尾插法建立单链表

LinkList creatListByTail(LinkList &L){
   
	int x;                                    //存输入元素
	L = (LinkList)malloc(sizeof(LNode));      //创建头节点
	LNode *s,                                 //s为工作指针
	      *r = L;                             //r为表尾元素
	scanf("%d",&x);                           //读取输入值
	while(x != 9999){
   
		s = (LinkList)malloc(sizeof(LNode));  //创建新节点
		s->data = x;
		
		//插入s到表尾
		r->next = s;
		r = s;
		scanf("%d",&x);
	}
	r->next = NULL;                           //尾巴置空
	return L;                                 //返回头结点
}

9.取出单链表L（带头节点）中第i个位置的结点指针（在单链表中按照序号查找结点值）

LNode *getElemByPos(LinkList L, int i){
   
	int j = 1;                  //计数，初始为1
	LNode *p = L->next;
	
	if(i == 0){
                    //i为0，返回头节点
		return L;
	}
	
	if(i < 1)                   //无效的i，返回NULL
		return NULL;
	
	while(p!=NULL               //链表还没有遍历完
		   && j<i){
                // 还没有到达所求的节点
		p = p->next;            //指针后移
		j++;                    //计数++
	}
	return p;                   //i大于表长，NULL；否则返回找到的节点
}

10.在单链表中按值查找结点

/*从头开始遍历，返回其中数据域为给定e的节点的指针，不存在则返回NULL*/
LNode *locateElemByValue(LinkList L, ElemType e){
   
	LNode *p = L->next;
	while(p!=NULL && p->data!=e){
      //表中还有元素，且还没有找到数据域是e的节点
		p = p->next;
	}
	return p;
}

11.将值为x的节点插入到单链表的第i个位置上

void insertNode(LinkList L, int i; ElemType x){
   
	if(i<1 || i>length(L)+1){
                        //非法插入位置
		return;
	}
	LNode *s = (LinkList)malloc(sizeof(LNode))；  //创造一个新的节点
	s->data = x;                                  //数据域赋值
	LNode p = getElem(L,i-1);                     //找到第i个节点的前驱节点
	s->next = p->next;                            //执行插入
	p->next = s;
}

12.将单链表上的第i个节点删除

bool deleteNode(LinkList L; int i; ElemType &e){
   
	if(i<1 || i>length(L)){
              //删除位置非法
		return false;
	}
	LNode *p,                         //被删除节点的前驱节点
	      *q;                         //辅助指针
	p = getElem(L,i-1);
	q = p->next;                      //q指向需要删除的节点
	p->next = p->next;                //将需要删除的节点从链表上取下
	e = q->data;                      //将值交给e
	free(q);                          //释放掉需要删除的节点
	return true;
}

13.双链表的结点类型描述

typedef struct DNode{
   
	ElemType data;         //数据域
	struct DNode *prior,   //前驱指针域
	             *next;    //后继指针域
}DNode,*DLinkList;

14.双链表在p之后插入s

s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;

15.双链表的删除：删除p的后继结点q

p->next = q->next;
q->next->prior = p;
free(q);

16.静态链表结构类型描述

#define MaxSize 50    //静态链表的最大长度
typedef struct{
   
	ElemType data;    //数据域
	int next;         //指针域：下一个元素的数组下标
}SLinkList[MaxSize];

第二章：栈和队列

1.栈的顺序存储类型描述

#define MaxSize 50           //栈中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];  //用数组实现对栈中元素的存放
	int top;                 //栈顶指针
}SqStack;

2.顺序栈：初始化栈

void InitStack(SqStack &S){
   
	S.top = -1;
}

3.顺序栈：判断栈空

bool StackEmpty(SqStack S){
   
	if(S.top == -1){
        //栈空
		return true;
	}else{
                  //栈非空
		return false;
	}
}

4.顺序栈：进栈

bool Push(SqStack &S, ElemType x){
   
	if(S.top == MaxSize-1){
     //栈满
		return false;
	}
	S.data[++S.top] = x;     //先+1，再送元素进栈
	return true;
}

5.顺序栈：出栈

bool Pop(SqStack &S, ElemType &x){
   
	if(S.top == -1){
            //栈空
		return false;
	}
	x = S.data[S.top--];     //先取栈顶元素，再栈顶指针-1
	return true;
}

6.顺序栈：读取栈顶元素

bool GetTop(SqStack &S, ElemType &x){
   
	if(S.top == -1){
            //栈空
		return false;
	}
	x = S.data[S.top];       //读取栈顶元素
	return true;
}

7.栈的链式存储类型描述

typedef struct LNode{
   
	ElemType data;        //数据域
	struct LNode *next;   //指针域
}

8.链栈：初始化

void initStack(LNode *&lst){
                     //因为下面要对lst进行同步修改，所以用*&
	lst = (LNode* )malloc(sizeof(LNode));     //申请头结点
	lst->next = NULL;                         //后继指向空
}

9.链栈：判断栈空

bool isEmpty(LNode *lst){
   
	if(lst->next == NULL){
     //头结点的指针域为NULL，则链表空
		return true;
	}else{
   
		return false;
	}
}

10.链栈：使用头插法将新的结点插入到头结点后

void push(LNode *lst, ElemType x){
   
	LNode *p;
	p = (LNode *)malloc(sizeof(LNode));   //申请一个空间，用于存放进栈元素
	p->data = x;                          //为数据域赋值
	p->next = lst->next                   //新插入的结点指向原来的栈顶结点
	lst->next = p;                        //头结点指向新入栈的结点
}

11.链栈：出栈

bool pop(LNode *lst, ElemType &x){
   
	if(lst->next == NULL)    //栈空
		return false;
	LNode *p ;
	p = lst->next;           //出栈结点
	x = p->data;             //出栈结点的数据域
	lst->next = p->next;     //将栈顶结点摘下
	free(p);
	return true;
}

12.队列的顺序存储类型描述

typedef struct{
   
	ElemType data[MaxSize];  //用一维数组存放队列元素
	int front,               //队头指针
	    rear;                //队尾指针
}SqQueue;

13.循环队列：初始化

void InitQueue(SqQueue &Q){
   
	Q.rear = Q.front = 0;
}

14.循环队列：判断队列是否为空

bool isEmpty(SqQueue Q){
   
	return Q.rear = Q.front;
}

15.循环队列：入队

bool EnQueue(SqQueue &Q, ElemType x){
   
	if((Q.rear+1) % MaxSize == Q.front){
     //队满
		return false;
	}
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;      //队尾指针加一环
	return true;
}

16.循环队列：出队

bool DeQueue(SqQueue &Q, ElemType &X){
       //队空
	if(Q.rear == Q.front){
   
		return false；
	}
	X = Q.data[Q.front];                  //获取队首元素
	Q.front = (Q.front+1) % MaxSize;      //队头指针加一环
	return true;
}

17.队列的链式存储类型描述

/*链式队列的结点*/
typedef struct LinkNode{
   
	ElemType data;            //数据域
	struct LinkNode * next;   //指针域，指向下一个结点
}LinkNode;
/*链式队列*/
typedef struct LinkNode{
   
	LinkNode *front,          //队列的队头指针
	         *rear;           //队列的队尾指针
}LinkQueue;

18.链式队列【有头结点】：初始化

void InitQueue(LinkQueue &Q){
   
	//申请头结点
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next = NULL;
}

19.链式队列【有头结点】：判断队空

bool isEmpty(LinkQueue Q){
   
	if(Q.front = Q.rear){
   
		return true;
	}else{
   
		return false;
	}
}

20.链式队列【有头结点】：入队

void EnQueue(LinkQueue &Q, ElemType X){
   
	LinkNode *s = (LinkNode*)malloc(sizeof(LinkNode)); //申请头结点
	s->data = x;
	s->next = NULL;
	Q
最低0.47元/天 解锁文章
halfelf520
关注
专栏目录
考研数据结构
qq_23009153的博客
10-14 1222
一步一脚印…. 我是一个注重基础的男银… （一）考研中的变量类型： 1 基本类型：int 、float 、 char 2 指针类型 3 结构体型：数组，结构体 4 void型：考研中 定义无返回值函数。 （二）控制语句 1：判断语句if （做决策） 2：循环语句 （做重复的事） for
考研数据结构代码总结
mengxianglong123的博客
10-30 4785
数据结构所有代码总结
考研数据结构代码大全
10-26
考研期间总结的数据结构代码大全，包括列表，栈，队列，树，图，查找，字符串，排序等数据结构的实现C语言实现版本，需要的朋友可以参考一下。
数据结构重点代码总结（考研）
热门推荐
weixin_44520088的博客
09-07 1万+
线性表 顺序表的定义 #define MaxSize 50 typedef struct{ ElemType data[MaxSize]； int length; }SqList; 顺序表插入 在下标为i的位置插入元素e： bool ListInsert(SqList &L, int i, ElemType e){ if(i<0||i>L.length||L.length==MaxSize) //i取0到length return false; for(int j
手撕考研数据结构（代码汇总篇）
Jiawen9的博客
06-02 4218
手撕考研数据结构（线性表、树、图、查找排序、算法），全部由c++实现
考研数据结构代码实现
01-16
int Creat(Sqlist &L, int a[], int n)//顺序表的创建 { int i; if (n <= maxSize) { for (i = 0; i<n ; i++) { L.data[i] = a[i]; L.length++; } return 1; } else return 0; } int Show(Sqlist a)//顺序表的遍历 { int i; for (i = 0; i<a.length; i++) { cout << a.data[i] << " "; } cout << endl; return 0; }
考研数据结构代码整理
qq_40694323的博客
06-19 952
特别推荐：https://blog.csdn.net/out_of_memory_error/article/details/102332332
考研数据结构算法代码总结.pdf
05-12
数据结构作为计算机科学的重要基础课程，在考研科目中占有重要地位，尤其在算法设计和程序编写方面有着广泛的应用。根据提供的文件内容，我们可以总结出以下几个重要的数据结构知识点： 1. 顺序表的插入和删除操作 ...
考研王道数据结构代码.zip
11-26
"考研王道数据结构代码.zip"这个压缩包包含了2020年王道数据结构课程的课后习题代码，对于考生来说是一个宝贵的参考资料。 王道数据结构教材以其清晰易懂的讲解和丰富的例题著称，其配套的可执行代码可以帮助学生更...
数据结构代码大全
11-12
数据结构代码大全。 代码简单且符注释，配套书籍为《数据结构（C语言版）--严蔚敏》 代码和光盘上的不一样，全部是可以直接运行检测的代码，上手快，可以自己调试。
考研数据结构代码.pdf
01-04
数据结构常见的代码
数据结构代码
07-02
数据结数据结构构4次课程设计实现代码数据结构数据结构
数据结构考研代码汇总
最新发布
09-19
数据结构考研代码汇总的博客中，作者将自己考研期间所写的数据结构代码汇总到一起。整个博客从线性表、树、图、查找排序四部分来列举考研数据结构中重要的内容。其中包括数组、Dijkstra算法、Floyd算法、Kruskal算法...
数据结构 考研 代码题
20岁爱吃必胜客
01-18 345
pointer指针==地址 空指针 零值 n 变量名 int i=2; int *p=&i; int *p; *p=&i; int **q=&p;间接间接 指针的指针 第二讲 malloc（） char *p; p=(char )malloc(10sizeof(char)); strcpy() 数组名 和 指针指向一段连续空间一样 数组名 指针 地址 一样的 struct teacher{ int no； char name[6]; int age; }; 考边界对齐 struc
考研数据结构（代码篇）
weixin_47020721的博客
07-10 6942
数据结构考研算法题
数据结构的代码
HPU_FRDHR的博客
10-16 437
注：如果在你的脑上运行出错，请改一下头文件，你的电脑可能不支持万能头文件。 修改成：#include&lt;iostream&gt;     #include&lt;cstdio&gt; 1.普通的a+b #include &lt;bits/stdc++.h&gt; using namespace std; int main() { int a,b; char c; cin&gt;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值