王道《数据结构考研复习指导》代码

最新推荐文章于 2024-05-25 07:58:00 发布
最新推荐文章于 2024-05-25 07:58:00 发布
阅读量8.9k 收藏 141
点赞数 22
分类专栏： 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a524633094/article/details/82746536
版权

线性表__顺序表示

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

//静态分配 
#define MaxSize 50
typedef int ElemType;
typedef struct{
	ElemType data[MaxSize];
	int length;
}SqList;
//动态分配
#define InitSize 100
typedef struct{
	ElemType *data;
	int capacity;
	int length;
}SeqList; 

bool ListInsert(SqList &L,int i,ElemType e){
	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++;
	return true;
} 

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];
	L.length--;
	return true;
}

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

void PrintList(SqList &L){
	for(int i=0;i<L.length;i++){
		printf("%4d",L.data[i]);
	}
	printf("\n");
}
int main(){
	SqList L;
	bool ret;
	ElemType del;
	L.data[0]=1;
	L.data[1]=2;
	L.data[2]=3;
	L.length=3;
	ret=ListInsert(L,2,60);
	if(ret){
		printf("插入成功\n");
		PrintList(L); 
	}else{
		printf("插入失败\n");
	}
	ret=ListDelete(L,1,del);
	if(ret){
		printf("删除成功\n");
		printf("删除元素值为%d\n",del);
		PrintList(L);
	}else{
		printf("删除失败\n");
	}
	ret=LocateElem(L,60);
	if(ret){
		printf("查找成功\n");
		printf("元素位置为%d\n",ret);
		PrintList(L);
	}else{
		printf("查找失败\n");
	}
	system("pause");
	
return 0;
}

运行结果

线性表__链式表示

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

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

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

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

LNode *GetElem(LinkList L,int i){
	int j=1;
	LNode *p=L->next;
	if(i==0)
		return L;
	if(i<1)
		return NULL;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	return p;
}

LNode *LocateElem(LinkList L,ElemType e){
	LNode *p=L->next;
	while(p!=NULL&&p->data!=e)
		p=p->next;
	return p;
}

bool ListFrontInsert(LinkList L,int i,ElemType e){
	LinkList p=GetElem(L,i-1);
	if(NULL==p){
		return false;
	}
	LinkList s=(LNode*)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}

bool ListDelete(LinkList L,int i){
	LinkList p=GetElem(L,i-1);
	if(NULL==p){
		return false;
	}
	LinkList q;
	q=p->next;
	p->next=q->next;
	free(q);
	return true;
}

void PrintList(LinkList L){
	L=L->next;
	while(L!=NULL){
		printf("%3d",L->data);
		L=L->next;
	}
	printf("\n");
}

int main(){
	LinkList L;
	LinkList search;
	//CreatList1(L);//输入数据为3 4 5 6 7 9999 
	CreatList2(L);//输入数据为3 4 5 6 7 9999 
	PrintList(L);
	search=GetElem(L,2);
	if(search!=NULL){
		printf("按序号查找成功\n");
		printf("%d\n",search->data); 
	}
	search=LocateElem(L,6);
	if(search!=NULL){
		printf("按值查找成功\n"); 
		printf("%d\n",search->data); 
	}
	ListFrontInsert(L,2,99);
	PrintList(L);
	ListDelete(L,4);
	PrintList(L);
	system("pause");
}

List_head_insert（CreatList1）

运行结果

List_tail_insert（CreatList2）

运行结果

双链表

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

typedef int ElemType;
typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

DLinkList Dlist_head_insert(DLinkList &DL){ //List_head_insert
	DNode *s;int x;
	DL=(DLinkList)malloc(sizeof(DNode));
	DL->next=NULL;
	DL->prior=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(DNode*)malloc(sizeof(DNode));
		s->data=x;
		s->next=DL->next;
		if(DL->next!=NULL){
			DL->next->prior=s;
		}
		s->prior=DL;
		DL->next=s;
		scanf("%d",&x);
	}
	return DL;
} 

DLinkList Dlist_tail_insert(DLinkList &DL){//List_tail_insert
	int x;
	DL=(DLinkList)malloc(sizeof(DNode));
	DNode *s,*r=DL;
	DL->prior=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(DNode*)malloc(sizeof(DNode));
		s->data=x;
		r->next=s;
		s->prior=r;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL;
	return DL;
} 

DNode *GetElem(DLinkList DL,int i){
	int j=1;
	DNode *p=DL->next;
	if(i==0)
		return DL;
	if(i<1)
		return NULL;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	return p;
}

bool DListFrontInsert(DLinkList DL,int i,ElemType e){
	DLinkList p=GetElem(DL,i-1);
	if(NULL==p){
		return false;
	}
	DLinkList s=(DNode*)malloc(sizeof(DNode));
	s->data=e;
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
}

bool DListDelete(DLinkList DL,int i){
	DLinkList p=GetElem(DL,i-1);
	if(NULL==p){
		return false;
	}
	DLinkList q;
	q=p->next;
	if(q==NULL)
		return false;
	p->next=q->next;
	if(q->next!=NULL){ //删除最后一个元素，需要的判断 
		q->next->prior=p;
	}
	free(q);
	return true;
}

void PrintDList(DLinkList DL){
	DL=DL->next;
	while(DL!=NULL){
		printf("%3d",DL->data);
		DL=DL->next;
	}
	printf("\n");
}

int main(){
	DLinkList DL;
	DLinkList search;
	//Dlist_head_insert(DL);
	Dlist_tail_insert(DL);//输入数据为3 4 5 6 7 9999 
	PrintDList(DL);
	search=GetElem(DL,2);
	if(search!=NULL){
		printf("按序号查找成功\n");
		printf("%d\n",search->data); 
	}
	DListFrontInsert(DL,3,99);
	PrintDList(DL);
	DListDelete(DL,2);
	PrintDList(DL);
	system("pause");
}

Dlist_tail_insert

这里写图片描述

Dlist_tail_insert

运行结果

栈（数组实现）

#include<stdio.h>
#include<stdlib.h>
//实现栈 可以用数组，也可以用链表 
#define MaxSize 50
typedef int ElemType;
typedef struct DNode{
    ElemType data[MaxSize];
    int top;
}SqStack;

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

bool StackEmpty(SqStack &S){
	if(S.top==-1)
		return true;
	else
		return false;
}

bool Push(SqStack &S,ElemType x){
	if(S.top==MaxSize-1){
		return false;
	}
	S.data[++S.top]=x;
	return true;
}

bool Pop(SqStack &S,ElemType &x){
	if(-1==S.top)
		return false;
	x=S.data[S.top--];
	return true;
}

bool GetTop(SqStack &S,ElemType &x){
	if(-1==S.top)
		return false;
	x=S.data[S.top];
	return true;
}

int main(){
    SqStack S;
    bool flag;
    ElemType m;
    InitStack(S);
    flag=StackEmpty(S);
    if(flag){
    	printf("栈是空的\n");
	}
	Push(S,3);
	Push(S,4);
	Push(S,5);
	flag=GetTop(S,m);
	if(flag){
		printf("获取栈顶元素为%d\n",m);
	}
	flag=Pop(S,m);
	if(flag){
		printf("弹出元素为%d\n",m);
	}
    system("pause");
}

运行结果

循环队列

#include<stdio.h>
#include<stdlib.h>
//队列可以用数组也可用链表实现 
#define MaxSize 5
typedef int ElemType;
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
}SqQueue;

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

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

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;
}

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;
}

int main(){
	SqQueue Q;
	bool ret;
	ElemType element;
	InitQueue(Q);
	ret=isEmpty(Q);
	if(ret){
		printf("队列为空\n"); 
	}else{
		printf("队列不为空\n"); 
	} 
	EnQueue(Q,3);
	EnQueue(Q,4);
	EnQueue(Q,5);
	ret=EnQueue(Q,6);
	//ret=EnQueue(Q,7);
	if(ret){
		printf("入队成功\n"); 
	}else{
		printf("入队失败\n"); 
	}
	ret=DeQueue(Q,element);
	 if(ret){
		printf("出队成功，元素值为%d\n",element); 
	}else{
		printf("出队失败\n"); 
	}
	ret=DeQueue(Q,element);
	 if(ret){
		printf("出队成功，元素值为%d\n",element); 
	}else{
		printf("出队失败\n"); 
	}
	ret=EnQueue(Q,8);
	if(ret){
		printf("入队成功\n"); 
	}else{
		printf("入队失败\n"); 
	}
	system("pause");
}

运行结果

队列_链式

#include<stdio.h>
#include<stdlib.h>
//头部删除法，尾部插入法 
typedef int ElemType;
typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
	LinkNode *front,*rear;
}LinkQueue;
void InitQueue(LinkQueue &Q){
	Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next=NULL; 
}

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

void EnQueue(LinkQueue &Q,ElemType x){
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
}

bool DeQueue(LinkQueue &Q,ElemType &x){
	if(Q.front==Q.rear) return false;
	LinkNode *p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)
		Q.rear=Q.front;
	free(p);
	return true;
}

int main(){
	LinkQueue Q; 
	bool ret;
	ElemType element;
	InitQueue(Q); 
	EnQueue(Q,3);
	EnQueue(Q,4);
	EnQueue(Q,5);
	EnQueue(Q,6);
	EnQueue(Q,7);
	ret=DeQueue(Q,element);
	if(ret){
		printf("出队成功，元素值为%d\n",element); 
	}else{
		printf("出队失败\n"); 
	}
	system("pause");
}

运行结果

斐波那契数列

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

int Fib(int n){
	if(n==0)
		return 0;
	else if(n==1)
		return 1;
	else
		return Fib(n-1)+Fib(n-2);
}
int main(){
	int num;
	while(scanf("%d",&num)!=EOF){
		printf("Fib(%d) = %d\n",num,Fib(num)); 
	}
	system("pause");
}
城尘丶
关注
  • 22
    点赞
  • 踩
  • 141
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
王道数据结构代码笔记
My博客
07-15 3338
数据结构考研代码
顺序栈的实现（基于C语言）
weixin_45148997的博客
09-06 223
#include<stdio.h> #include <stdlib.h> #define MaxSize 50 typedef int Elemtype; typedef struct{ Elemtype data[MaxSize]; int top; }SqStack; void InitStack(SqStack &S); bool StackEmpty(SqStack S); bool Push(SqStack &S,Elemtype x);
王道考研数据结构顺序表代码
05-15
自己写的王道考研数据结构顺序表例题和习题代码，所有函数运行都没问题。
计算机考研｜408开始的晚，怎么入手复习？六个月保姆级规划
最新发布
HapppEveryday的博客
05-25 1460
在专业课方面，我一直在不断地做真题，并反复看王道讲义上的错题。此时，大家也需要回归到课本，
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
19版考研数据结构王道课后习题代码-图【未完】
努力努力再努力0.0的博客
09-18 425
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
王道2019数据结构考研复习指导高清无水印版
09-30
王道2019数据结构考研复习指导无水印版！！！ 考研狗福利。高清无水印版！！！
王道数据结构考研复习指导（2022年）-选择题(CSDN).pdf
12-28
本复习指导聚焦于2022年的考研选择题，涵盖了数据结构的基础概念和算法评估等相关知识。 1. 数据结构的基本概念： - 抽象数据类型（ADT）是定义数据结构的关键，它包括数据元素、数据对象和数据关系。选项D正确，...
王道2019年数据结构考研复习指导
07-31
王道2019年数据结构考研复习指导，考研复习，备战秋招
计算机考研王道2019年数据结构考研复习指导.zip
06-18
"计算机考研王道2019年数据结构考研复习指导"是一份专门为2020年考研学子量身打造的复习资料。这份资料在大纲发布之前，为考生提供了宝贵的复习资源，帮助他们提前准备，抢占先机。 数据结构是研究如何组织和管理...
数据结构 考研复习笔记
09-19
本人的数据结构考研复习笔记，完全原创，系统梳理所有知识点，所有涉算法的C语言实现源码，贡献给大家！！，以天勤考研高分笔记为复习材料，将重点知识点梳理总结形成的。所有重要算法用C语言实现！
计算机考研王道系列之——数据结构
04-10
当年考研时看的书，王道经典，虽说是2016年的，但是历年考研知识点几乎不变，各位可以参考一下。
2019王道数据结构（无水印）
12-25
2019王道数据结构书籍，无水印版本，祝各位考研顺利！！
王道C语言督学OJ代码
热门推荐
m0_49359388的博客
01-11 1万+
王道OJ练习题（更新学习中）初级 初级 1.输入“hello wangduo” #include<stdio.h> int main(){ printf("hello wangdao"); } 2.计算a+b #include<stdio.h> int main(){ int a; int b; scanf("%d %d",&a,&b); printf("%d",a+b); return 0; } 3.读取一个65到122之间的整型数，然后
2023王道数据结构考研习题汇总
Eumenides_Suki的博客
07-23 5127
2023数据结构考研复习
王道考研2021——数据结构学习笔记
DanmoSAMA的博客~
01-03 7298
王道给的代码中，有些用的是c++语言，但是和c的区别不大，不影响理解。 线性表 链表 单链表的定义 目前，只记了带头结点的情况 初始化单链表： typedef struct LNode{ //定义单链表结点类型 ElemType data; //每个结点存放一个数据元素 struct LNode *next; //指针指向下一个结点 }LNode,*LinkList; //初始化一个单链表 bool InitList(LinkList &L){ //&表示间接访问，和c语言使.
【王道数据结构编程题】 - 链表代码题
m0_56051805的博客
06-20 1223
王道代码题具体实现，可运行，1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点。2.在带头节点的单链表L中，删除所有值为x的节点，并释放其空间，假设值为x的节点不唯一，试编写算法以实现上述操作。3.设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。4.试编写在带头节点的单链表L这删除一个最小值节点的高效算法(假设最小值节点是唯一的)。5.试着编写算法将带头节点的单链表就地逆置，所谓“就地”就是辅助空间复杂度为O(1)。6.有一个带头节点的单链表L，设计一个算法使其元素递增有序。
数据结构考研笔记第一、二章（王道）
qq_46354489的博客
05-15 451
考研数据结构 第一章 绪论 数据 信息的载体，是描述客观事物属性的数、字符及所有 能输入到计算机中并被计算机程序识别 和处理的符号集合。数据是计算机程序加工的原料。 数据元素、数据项： 数据元素是数据的基本单位，通常作为一个整体 一个数据元素可以包含多个数据项 eg： 一个顾客就是一个数据元素，属于特定顾客的号数、取号时间、就餐人数等都为数据对象 数据结构、数据对象： 数据结构：相互间存在一种或者多种特定关系的数据元素集合 数据对象：是具有 相同性质的元素集合，是数据的子集 数据结构三要素： 逻辑结

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值