数据结构基础代码

最新推荐文章于 2022-12-04 14:10:30 发布
最新推荐文章于 2022-12-04 14:10:30 发布
阅读量253 收藏 2
点赞数 2
分类专栏： 考研 算法 文章标签： 考研 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Anterior_condyle/article/details/117233434
版权

本文章为博主考研为巩固知识所写，有不足帮忙指出！！！加油！必上岸！！！

目录

顺序表

#include<cstdio>
#include<stdlib.h>
#define MaxSize 100
#define test printf("测试\n");
//定义顺序表结构 
typedef struct node{
	int data[MaxSize];
	int length;
}SqList;
//初始化顺序表
SqList InitList(SqList L){
	for(int i=0;i<100;i++){
		L.data[i]=0;
	}
	L.length=0;
} 
//建立顺序表
SqList BuildList(SqList L){
	int x,i=1;
	scanf("%d",&x);
	while(x!=0){
		L.data[i++]=x;
		L.length++;
		scanf("%d",&x);
	}
	return L;
} 
//打印顺序表
void PrintList(SqList L){
	for(int i=1;i<=L.length;i++){
		printf("%d ",L.data[i]);
	}
} 
//插入操作
SqList InsertList(SqList L,int i,int e){
	if(i<1||i>L.length){
		printf("插入失败");
		exit(1);
	}
	//i以及后面的元素后移 
	for(int j=L.length;j>=i;j--){
		L.data[j+1]=L.data[j];
	}
	L.data[i]=e;
	L.length++;
	return L;
} 
//删除操作
SqList DeleteList(SqList L,int i){
	if(i<1||i>L.length){
		printf("删除失败");
		exit(1);
	}
	//删除
	for(int j=i+1;j<=L.length;j++){
		L.data[j-1]=L.data[j];
	} 
	L.length--;
	return L;
} 
//按值查找
int SelectList(SqList L,int e){
	for(int i=0;i<L.length;i++){
		if(L.data[i]==e){
			printf("%d的值在%d位/n",e,i);
			return 0;
		}
	}
} 
int main(){
	SqList L;
	//初始化 
	InitList(L);
	//建立顺序表 
	L = BuildList(L);
	//插入 
	L=InsertList(L,3,10);
	//删除 
	L=DeleteList(L,3);
	//查找
	SelectList(L,3); 
	//打印 
	PrintList(L);
	return 0;
}

单链表

#include<stdio.h>
#include<stdlib.h>
#define test_NULL if(L->next==NULL){printf("链表为空");exit(1);}
//定义结构 
typedef struct node{
	int data;
	struct node *next;
}LNode,*SqList;
//初始化带头节点链表 
SqList InitList(){
	SqList L = (SqList)malloc(sizeof(LNode));//生成一个节点变量 
	if(L==NULL){
		printf("分配空间失败");
		exit(1);
	} 
	L->next=NULL;
	return L;
}  
//头插法建立单链表(打印出来为逆序) 
SqList SequenceCreatList(SqList L){
	int x;
	scanf("%d",&x);//第一个点
	while(x!=0){//输入9999结束
		LNode *NewNode = (LNode*)malloc(sizeof(LNode));//生成一个新节点变量
		if(NewNode==NULL){
			printf("分配空间失败");
			exit(1); 
		} 
		NewNode->data=x;
		NewNode->next=L->next;//将头结点的下一个节点改成新节点的下一个节点 
		L->next=NewNode;//新节点作为头结点的下一个节点 
		scanf("%d",&x); 
	}	
	return L;
} 
//尾插法建立单链表（打印出来为顺序）
SqList inSequenceCreatList(SqList L){
	int x;
	LNode* p=L;//指针指向L的头结点 
	scanf("%d",&x);
	while(x!=0){
		LNode* NewNode = (LNode*)malloc(sizeof(LNode));
		if(NewNode==NULL){
			printf("分配空间失败");
			exit(1);
		}
		NewNode->data=x;
		p->next=NewNode;
		p=NewNode;
		scanf("%d",&x);
	}
	p->next=NULL;
	return L;
}
//打印链表  
void PrintList(SqList L){
	test_NULL;//判空 
	printf("\n链表为："); 
	LNode* p;//指向当前节点指针
	p=L->next;//指针初始指向第一个节点（头结点的下一个节点） 
	while(p!=NULL){//指针非空继续遍历
		printf("%d ",*p);
		p=p->next; 
	}
	printf("\n\n");
}
//求表长操作
int GetLength(SqList L){
	test_NULL;//判空 
	int length=0;
	LNode* p=L->next;
	while(p){
		length++;
		p=p->next;
	}
	return length;
} 
//按序号查找节点值
LNode* GetElem(SqList L,int x){
	test_NULL;//判空 
	int i=0;
	LNode* p = L;
	if(x<1||x>GetLength(L)){
		printf("输入异常");
		return;
	}
	while(i<x){
		p=p->next;
		i++;
	}
	return p;
	
	
} 
//按值查找节点索引
int GetIndex(SqList L,int x){
	test_NULL;//判空 
	int i=0; 
	LNode * p = L->next;
	while(x!=p->data&&p){
		i++;
		p=p->next;	
	}
	return i+1; 
}
//后插法插入节点 
void InsertElem(SqList L,int x,int num){//在第x个位置插入num; 
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	LNode* p=GetElem(L,x-1);//找到插入节点的前驱节点 
	newNode->data=num;
	//往后插 
	newNode->next=p->next;
	p->next=newNode; 
} 
//删除节点
void DeleteElem(SqList L,int x){//删除第i个节点 
	test_NULL;//判空 
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	LNode* p=GetElem(L,x-1);//找到插入节点的前驱节点 
	LNode* q=p->next;//q指向被删除节点
	p->next=q->next; 
} 
int main(){
	//定义结构 
	SqList L;
	L = InitList(L);
	//初始化
	//L = inSequenceCreatList(L);
	 //打印链表 
	PrintList(L);
	//计算表长
	printf("表长为:%d\n\n",GetLength(L)); 
	//查询索引值 
	printf("请输入查询带查询值的索引:");
	int x1;
	scanf("%d",&x1);
	printf("第%d个节点值为：%d\n\n",x1,GetElem(L,x1)->data);
	//按值查找索引
	printf("请输入待查询索引的值:");
	int x2;
	scanf("%d",&x2);
	printf("值为%d的索引为：%d\n\n",x2,GetIndex(L,x2)); 
	//插入节点
	printf("输入插入位置，插入值:");
	int t,x3;
	scanf("%d %d",&t,&x3);
	InsertElem(L,t,x3);
	printf("插入之后链表:");
	PrintList(L);
	//删除节点
	printf("请输入删除位置:");
	int x4;
	scanf("%d",&x4);
	DeleteElem(L,x4); 
	printf("删除之后的链表:");
	PrintList(L);  
	return 0;
}

无头节点单链表

#include<stdio.h>
#include<stdlib.h>
#define test_NULL if(L==NULL){printf("链表为空");exit(1);}
//定义结构
typedef struct node{
	int data;
	struct node *next;
}LNode,*SqList; 
//初始化链表
SqList InitSqList(SqList L){
	L=NULL;//防止脏数据
	return L; 
} 
//头插法建立单链表
SqList headBuildList(SqList L){
	int x;
	scanf("%d",&x);
	while(x!=0){
		LNode* newNode = (LNode*)malloc(sizeof(LNode));//生成一个节点变量
		if(newNode==NULL){
			printf("分配空间失败");
			exit(1); 
		} 
		newNode->data=x;
		newNode->next=L;
		L=newNode;
		scanf("%d",&x);
	}
	return L;
} 
//尾插法建立单链表
SqList behindBuildList(SqList L){
	int x;
	LNode* p=L; 
	scanf("%d",&x);
	while(x!=0){
		LNode* newNode =(LNode*)malloc(sizeof(LNode));//声明一个节点变量
		if(newNode==NULL){
			printf("分配空间失败");
			exit(1); 
		}
		newNode->data=x;
		if(p){//判断插入的是否为第一个点 
			p->next=newNode;//表尾指针指向最后一个点 
		}else{
			L=newNode;//头指针指向第一个节点 
		} 
		p=newNode;
		scanf("%d",&x);
	}
	p->next=NULL;//必须设置尾节点 
	return L;
} 
//打印链表
void PrintList(SqList L){
	test_NULL;
	LNode *q = L;
	while(q){
		printf("%d ",q->data);
		q=q->next;
	}
} 
//求表长
int lengthList(SqList L){
	test_NULL;
	int length=0;
	LNode* p = L;
	while(p){
		p=p->next;
		length++;
	}
	return length;
} 
//查询第i个点
LNode* FindLocate(SqList L,int i){
	test_NULL;
	LNode *p = L;
	int j=1;
	while(j!=i){
		p=p->next;
		j++; 
	}
	return p;//找到查询点节点的地址 
} 
//插入操作
SqList InsertList(SqList L,int i,int e){ 
	test_NULL;
	if(i<1||i>lengthList(L)) {
		printf("输入不合法\n");
		exit(1); 
	}
	LNode* newNode = (LNode*)malloc(sizeof(LNode));//分配一个节点变量 
	if(newNode==NULL){
			printf("分配空间失败");
			exit(1); 
	}
	newNode->data=e;
	if(i==1){//如果在插入到第一个节点，由于没有头节点，所以要处理 
		newNode->next=L;
		L=newNode;
		return L;
	} 
	//插入其他正常位置 
	LNode* frontNode = FindLocate(L,i-1);
	newNode->next=frontNode->next;
	frontNode->next=newNode;
	return L;
} 
//删除节点 
SqList DeleteNode(SqList L,int i){
	test_NULL;
	//由于是无头链表删除第一个点要特殊处理 
	if(i==1){
		LNode* q = L;//q指向第一个节点 
		L = q->next;
		free(q);//释放空间 
		return L;
	}
	//其他位置正常处理 
	LNode* frontNode = FindLocate(L,i-1);//查找删除节点前一个节点地址 
	LNode* q = frontNode->next;
	frontNode->next = frontNode->next->next;
	free(q);//释放内存空间 
	return L;
}
//修改节点值
SqList UpdateNode(SqList L,int i,int x){
	test_NULL;
	LNode* Node = FindLocate(L,i);
	Node->data = x;
	return L;
	
} 
int main(){
	//声明链表 
	SqList L;
	//初始化链表 
	L = InitSqList(L);
	//建立链表 
	L = behindBuildList(L);
	//打印链表 
	//求表长
	printf("表长为：%d\n",lengthList(L)); 
	//插入操作
	//L=InsertList(L,1,100);
	//删除节点 
	//L=DeleteNode(L,3);
	//修改节点值
	UpdateNode(L,1,100); 
	//打印链表 
	PrintList(L);
	return 0;
}

双链表

#include<stdio.h>
#include<stdlib.h>
#define test_NULL if(L->next==NULL){printf("链表为空");exit(1);}
//定义结构
typedef struct Node{
	int data;
	struct Node *prior,*next;
}LNode,*SqList; 
//双链表初始化(带头结点)
SqList InitList(){ 
	LNode* L = (LNode*)malloc(sizeof(LNode));//分配头结点变量 
	if(L==NULL){
		printf("分配空间失败");
		exit(1);
	}
	//头结点两个指针设为空 
	L->next=NULL;
	L->prior=NULL; 
} 
//建立链表 
SqList BuildList(SqList L){
	int x;
	scanf("%d",&x);
	LNode* p = L;//浮动指针 
	while(x!=0){
		LNode* newNode = (LNode*)malloc(sizeof(LNode));//分配新节点变量
		newNode->data = x;//存入值
		//newNode->prior=newNode->next=NULL;
		//后插法插入链表 
		p->next=newNode;
		newNode->prior=p;
		p=newNode; 
		scanf("%d",&x);
	}
	p->next=NULL;
	return L;
}
//打印链表
void PrintfList(SqList L){
	test_NULL;
	LNode* p = L->next;
	while(p){
		printf("%d ",p->data);
		p = p->next;
	}
	 
} 
//求表长
int LengthList(SqList L){
	test_NULL;
	int length = 0;
	LNode* p = L->next;
	while(p){
		length++;
		p = p->next;
	}
	return length;
} 
//返回节点地址
LNode* FindLocate(SqList L,int i){
	test_NULL;
	int j=1;
	LNode* p = L->next;
	while(i!=j){
		p = p->next;
		j++;
	}
	return p;
} 
//插入操作
SqList InsertList(SqList L,int i,int e){
	test_NULL;
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	if(newNode==NULL){
		printf("空间分配失败");
		exit(1);
	} 
	newNode->data=e;
	//修改指针 
	LNode* p = FindLocate(L,i);//找到插入点地址
	newNode->next = p;
	p->prior->next=newNode;
	newNode->prior = p->prior;
	p->prior = newNode;
	return L;
	 
} 
//删除操作
SqList DeleteList(SqList L,int i){
	test_NULL;
	LNode* p = FindLocate(L,i);//找到插入点地址
	//修改指针 
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return L;
} 
int main(){
	//初始化双链表 
	SqList L = InitList();
	//建立双链表
	L = BuildList(L);
	//求表长
	printf("表长为%d\n",LengthList(L));
	//插入节点
	L =  InsertList(L,2,100);
	//删除节点
	L = DeleteList(L,2); 
	//打印链表
	PrintfList(L); 
	return 0;
}

循环双链表

#include<stdio.h>
#include<stdlib.h>
#define test_NULL if(L->next==NULL){printf("链表为空");exit(1);}
//定义结构
typedef struct Node{
	int data;
	struct Node *prior,*next;
}LNode,*SqList; 
//双链表初始化(带头结点)
SqList InitList(){ 
	LNode* L = (LNode*)malloc(sizeof(LNode));//分配头结点变量 
	if(L==NULL){
		printf("分配空间失败");
		exit(1);
	}
	//头结点两个指针指向本身 
	L->next=L;
	L->prior=L; 
} 
//建立链表 
SqList BuildList(SqList L){
	int x;
	scanf("%d",&x);
	LNode* p = L;//浮动指针 
	while(x!=0){
		LNode* newNode = (LNode*)malloc(sizeof(LNode));//分配新节点变量
		newNode->data = x;//存入值
		//newNode->prior=newNode->next=NULL;
		//后插法插入链表 
		p->next=newNode;
		newNode->prior=p;
		p=newNode; 
		scanf("%d",&x);
	}
	//首尾相连 
	p->next=L;
	L->prior=p; 
	return L;
}
//打印链表
void PrintfList(SqList L){
	test_NULL;
	LNode* p = L->next;
	while(p!=L){//不等于头指针为终止条件 
		printf("%d ",p->data);
		p = p->next;
	}
	 
} 
//求表长
int LengthList(SqList L){
	test_NULL;
	int length = 0;
	LNode* p = L->next;
	while(p!=L){//不等于头指针为终止条件 
		length++;
		p = p->next;
	}
	return length;
} 
//返回节点地址
LNode* FindLocate(SqList L,int i){
	test_NULL;
	int j=1;
	LNode* p = L->next;
	while(i!=j){
		p = p->next;
		j++;
	}
	return p;
} 
//插入操作
SqList InsertList(SqList L,int i,int e){
	test_NULL;
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	if(newNode==NULL){
		printf("空间分配失败");
		exit(1);
	} 
	newNode->data=e;
	//修改指针 
	LNode* p = FindLocate(L,i);//找到插入点地址
	newNode->next = p;
	p->prior->next=newNode;
	newNode->prior = p->prior;
	p->prior = newNode;
	return L;
	 
} 
//删除操作
SqList DeleteList(SqList L,int i){
	test_NULL;
	LNode* p = FindLocate(L,i);//找到插入点地址
	//修改指针 
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return L;
} 
int main(){
	//初始化双链表 
	SqList L = InitList();
	//建立双链表
	L = BuildList(L);
	//求表长
	printf("表长为%d\n",LengthList(L));
	//插入节点
	L =  InsertList(L,2,100);
	//删除节点
	L = DeleteList(L,2); 
	//打印链表
	PrintfList(L); 
	return 0;
}

顺序栈

#include<cstdio>
#include<stdlib.h>
#define MaxSize 100
#define test_NULL if(S.top==-1){printf("栈空");exit(1);} 
typedef struct{
	int data[MaxSize];
	int top;
}SqStack;
//初始化栈 
SqStack InitStack(SqStack S){
	S.top = -1;//初始化栈顶指针 
}
//判断栈空 
int StackEmpty(SqStack S){
	return S.top=-1?1:0; 
} 
//进栈
SqStack PushStack(SqStack S,int x){
	if(S.top==MaxSize-1){//判断栈满 
		printf("栈满\n");
		exit(1);
	}
	S.data[++S.top]=x;
	return S;
} 
//出栈
SqStack popStack(SqStack S){
	test_NULL;
	 S.top--;
	 return S;
} 
//读取栈顶元素
int GetTop(SqStack S){	
	test_NULL;
	return S.data[S.top];
} 
int main(){
	//定义一个栈
	SqStack S;
	//初始栈 
	S = InitStack(S); 
	//进栈
	int x; 
	scanf("%d",&x);
	while(x!=0){
		S=PushStack(S,x); 
		scanf("%d",&x);
	}
	//读取栈顶元素 

	printf("栈顶元素为:%d\n",GetTop(S));
	//出栈
	S=popStack(S);
	//读取栈顶元素 
	printf("栈顶元素为:%d\n",GetTop(S));
	return 0;
}

链栈

#include<stdio.h>
#include<stdlib.h>
typedef struct LinkNode{
	int data;
	struct LinkNode *next;
}LNode,*LiStack;
///初始化链栈 
LiStack InitTsack(){
	LiStack S = (LiStack)malloc(sizeof(LNode));//初始化一个带头结点的链栈
	 if(S==NULL){
	 	printf("内存分配失败\n");
	 	exit(1);
	 }
	 S->next = NULL;
}
//判断栈空
int EmptyStack(LiStack S){
	return S->next==NULL?1:0;
} 
//进栈
LiStack PushStack(LiStack S,int x){
	LNode* newNode = (LNode*)malloc(sizeof(LNode)); 
	if(S==NULL){
	 	printf("内存分配失败\n");
	 	exit(1);
	 }
	 newNode->data = x;
	 newNode->next=S->next; 
	 S->next=newNode;
	 return S;
} 
//出栈
LiStack PopStack(LiStack S){
	if(EmptyStack(S)){
		printf("栈空\n");
		exit(1);
	}
	LNode* p = S->next;
	S->next=S->next->next;
	free(p);
	return S; 
} 
//获取栈顶元素 
int GetTop(LiStack S){
	if(EmptyStack(S)){
		printf("栈空\n");
		exit(1);
	}
	return S->next->data;
}
//链栈大小
int LengthSTack(LiStack S){
	LNode* p = S->next;
	int length = 0;
	while(p){
		length++;
		p = p->next;
	}
	return length;
} 
int main(){
	LiStack S;
	//初始化栈 
	S = InitTsack();
	//进栈
	int x; 
	scanf("%d",&x);
	while(x!=0){
		S=PushStack(S,x); 
		scanf("%d",&x);
	}
	
	printf("栈的大小:%d\n",LengthSTack(S));
	//出栈
	PopStack(S); 
	//获取栈顶元素
	printf("栈顶元素为:%d\n",GetTop(S)); 
	return 0;
}

循环队列

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
//定义结构
typedef struct{
	int data[MaxSize];
	int front,rear;
}SqQueue;
//初始化队列
SqQueue InitQueue(SqQueue Q){
	Q.front=Q.rear=0;
} 
//入队
SqQueue EnQueue(SqQueue Q,int x){
		if((Q.rear+1)%MaxSize==Q.front){
			printf("队满");
			exit(1);
		}
		Q.data[Q.rear]=x;
		Q.rear = (Q.rear+1)%MaxSize;
		return Q;
} 
//判空 
int IsEmpty(SqQueue Q){
	return Q.front==Q.rear?1:0;
} 
//出队
SqQueue Dequeue(SqQueue Q){
	if(IsEmpty(Q)){
		printf("队空\n");
		exit(1); 
	}
	Q.front=(Q.front+1)%MaxSize;
	return Q;
} 
//获取队首元素
int GetFront(SqQueue Q){
	if(IsEmpty(Q)){
		printf("队空\n");
		exit(1); 
	}
	return Q.data[Q.front];
} 
//获取队长
int LengthQueue(SqQueue Q){
	if(IsEmpty(Q)){
		printf("队空\n");
		exit(1); 
	}
	return (Q.rear-Q.front+MaxSize)%MaxSize;
} 
int main(){
	SqQueue Q;
	//初始化队列 
	Q = InitQueue(Q);
	//入队
	int x; 
	scanf("%d",&x);
	while(x!=0){
		Q=EnQueue(Q,x); 
		scanf("%d",&x);
	}
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q));
	Q = Dequeue(Q);
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q));
	
	
	return 0;
}

链式队列

#include<stdio.h>
#include<stdlib.h>
//链式队列节点 
typedef struct LinkNode{
	int data;
	struct LinkNode *next;
}LinkNode;
//队列头指针和尾部指针
typedef struct{
	LinkNode *front,*rear;
}LinkQueue;
//初始化
LinkQueue InitQueue(LinkQueue Q){
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));//建立头结点
	Q.front->next=NULL; 
	return Q;
} 
//判空
int IsEmpty(LinkQueue Q){
	return Q.front == Q.rear?1:0;
} 
//入队
LinkQueue EnQueue(LinkQueue Q,int x){
	LinkNode*s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data=x;s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
	return Q;
} 
//出队
LinkQueue DeQueue(LinkQueue Q){
	if(IsEmpty(Q)){
		printf("队空");
		exit(1);
	}
	LinkNode* p = Q.front->next;
	Q.front->next=p->next;
	free(p);
	return Q;
} 
//获取队列长度
int LengthQueue(LinkQueue Q){
	if(IsEmpty(Q)){
		printf("队空");
		exit(1);
	}
	int length = 0;
	LinkNode* p=Q.front->next;
	while(p){
		length++;
		p=p->next;
	}
	return length;
}
//获取队列首元素
int  GetFront(LinkQueue Q){
	if(IsEmpty(Q)){
		printf("队空");
		exit(1);
	}
	return Q.front->next->data;
}

 
int main(){
	LinkQueue Q;
	//初始化 
	Q = InitQueue(Q);
	//入队
	int x; 
	scanf("%d",&x);
	while(x!=0){
		Q=EnQueue(Q,x); 
		scanf("%d",&x);
	}
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q)); 
	Q = DeQueue(Q);
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q));
	return 0;
}
Knock man
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构基础代码C++版本
08-05
数据结构的线性表，栈队列，树，串还有排序查找的基本代码，手敲的
数据结构基本代码汇总
qq_45803851的博客
11-21 1万+
常用数据结构代码（c语言版本），适合考研or期末复习
数据结构-链表基础详解(超详细代码)
mayu_xuan的博客
12-04 3137
链表的定义及代码包含顺序表和单链表 目录一、线性表 1.线性表定义2.线性表特点二、线性表的顺序表示（顺序表）1、顺序表的优缺点2.插入操作3.删除操作4.练习三、线性表的链式表示（单链表）1.单链表定义2.单链表优缺点3.插入操作4.删除操作 5.查找操作5.1按序号查找结点 5.2按值查找结点 6.练习 1、顺序表的优缺点 1.优点：最好情况：在表尾插入元素，不需要移动元素，时间复杂度
【结构与算法】—— 数据结构代码总结 | 数据结构代码大全
热门推荐
看世界，也找自己
10-17 1万+
数据结构是计算机科学与技术专业、计算机信息管理与应用专业，电子商务等专业的基础课，是十分重要的核心课程。所有的计算机系统软件和应用软件都要用到各种类型的数据结构。
数据结构代码汇总
廿四画生的博客
05-03 600
1.C++编程能力评估（指针）：链表中删除数据元素实现链表的输入（已实现）、输出和删除成员函数。输入时，根据endtag确定是否结束输入；删除时，根据下标（从0开始）。注意，输入的顺序跟存放的顺序以及输出的顺序是相反的。#include "stdlib.h" #include "iostream" using namespace std ; class List; //前视定义,否则友元无法定义...
考研数据结构基础代码C语言实现.zip
最新发布
06-14
考研数据结构基础代码C语言实现
数据结构基础算法代码.zip
07-19
数据结构基础算法C++代码，二叉树遍历、拓扑排序、哈夫曼树。
零基础学数据结构源代码
07-21
零基础学数据结构的源代码和ppt
数据结构_基础理论+代码
qq_38757779的博客
03-16 429
顺序表 顺序表的定义 静态 #define MaxSize 100 typedef struct { ElemType data[MaxSize] //用静态的“数组”存放数据元素 int length; }SqList //顺序表类型的定义（静态分配方式） 动态 #define InitSize 10 typedef struct { ElemType *data; //指示动态分配数组的指针 int MaxSize; int length; }SeqList //顺序
数据结构入门代码
06-23
各种数据结构的声明和实现及测试，所有代码都可运行
C#数据结构基础源程序.zip
08-14
内含线性表、栈和队列、串、数组和广义表、树和二叉树、图、查找、内排序源程序以及讲解课件
数据结构上机题基础代码
05-14
数据结构课上机题代码，基础部分，初学者可以使用。是我们学校老师的上机题的代码，不是书上课后题的代码。
数据结构C/C++代码实现（可运行）2021.12.1
qq_46304931的博客
12-01 5951
数据结构与算法，代码全注释，手打可运行。
数据结构C语言基础代码7：顺序栈、链栈、队列（完）
xiuhhhua的博客
08-02 588
顺序栈、链栈、队列顺序栈基础操作：初始化栈、判断栈是否为空、进栈、出栈、获得栈顶元素，队列：初始化队、判断队是否为空、进队、出队。2.1链栈内容包括：入栈，出栈 入栈、出栈：入栈的思维其实和线性链表思维一样，因为他的结构体如下。......
数据结构 线性表的基础操作 C/C++代码实现 #1
Haneee的博客
01-13 2072
线性表的基础操作 1.创建线性表 2.销毁线性表 3.清空线性表 4.检查线性表是否为空 5.返回线性表的数据元素个数 6.返回线性表中指定位置的元素的值 7.找到符合条件的元素，返回其位置 8.返回线性表中指定元素的前一个元素的位置 9.返回线性表中指定元素的后一个元素的位置 10.在线性表指定位置插入一个元素 11.删除线性表中指定位置的元素 12.遍历线性表 线性表的两种存储结构 1.顺序存...
数据结构-树的基础代码
IT1995的博客
12-17 6523
数据结构-树的基础代码
数据结构八种基本序列代码-----快速排序
qq_42866384的博客
08-03 305
package sorting; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class QuickSort {//快速排序 //时间复杂度：O(nlog(n)) //空间复杂...
C/C++语言数据结构快速入门（一）（代码解析+内容解析）数据结构基本内容和线性表
程序员猫爪
06-15 2186
一、什么是数据结构 1、什么是程序 程序=数据结构+算法 数据结构：如何把现实世界的问题信息化，将信息存储到计算机当中。同时要实现对数据结构的基本操作。 算法：如何处理这些信息 2、什么是算法 如何处理信息的方式，解决问题的方法 （1）算法的特性 a、有穷性：一个算法必须总在执行有穷步骤之后结束，且每一步都可以在有穷时间内完成。 注意：算法必须是有穷的，而程序可以是无穷的 设计一个算法，解决一个特定的问题（在有限的步骤和有限的时间内完成） b、确定性： 算法中每条指令必须要有确切的含义，对于相同的输入只能得
数据结构中c语言的基础代码
05-18
以下是一些常见的数据结构在C语言中的基础代码实现： ## 数组 ### 声明一个数组 ```c int array[10]; // 声明一个包含10个整数的数组 ``` ### 给数组赋值 ```c array[0] = 1; array[1] = 2; // ... array[9] = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值