上机作业111

已于 2023-01-31 13:24:58 修改
阅读量1.2k 收藏 10
点赞数 1
分类专栏： 数据结构上机作业(C语言) 文章标签： 算法 数据结构 c++
于 2021-03-24 19:06:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_45678910/article/details/115182809
版权

目录

【线性表】

建立一个静态顺序表（正序），并输出该线性表。

提示：完整的程序包括程序前缀、静态顺序表的结构体类型定义、初始化子函数、表尾插入新元素子函数、输出子函数、主函数等。

#include<iostream>
#include<stdio.h>
using namespace std;

#define LIST_INIT_SIZE 100


//结构体类型定义
struct StaticList {
   
	int elem[LIST_INIT_SIZE]; //表  
	int length; //表长 
	int listsize; //表有可能的最大长度 
} ;


//初始化
void InitList_StaticList(StaticList &L) {
   
	L.length=0;
	L.listsize=LIST_INIT_SIZE;
}


//表尾插入新元素
int Ins_SList(StaticList &L,int x) {
   
	if(L.length>=L.listsize) {
   
		printf ("The list is overflow ! \n");
		return -1;
	} 
	else {
   
		L.elem[L.length]=x;
		L.length++;
		return 1;
	}
}


//输出线性表
void print(StaticList &L) {
   
	for(int i=0; i<=L.length-1 ; i++)
		cout<<L.elem[i]<<" "; //输出
	cout<<endl;
}


int main(int argc,char* argv[]) {
   
	StaticList SL;
	InitList_StaticList(SL);
	cout<<"enter numbers:"<<endl;
	while(1) {
   
		int x;
		cin>>x; //输入
		if(x==9999)
			break; //当输入9999时停止输入 
		else
			Ins_SList(SL, x);
	}
	cout<<"The list elems:"<<endl ;
	print(SL);
	return 0;
}

建立一个静态顺序表（逆序），输出该线性表；再在表的中部添加一个新元素，并输出新的线性表。

提示：完整的程序包括程序前缀、静态顺序表的结构体类型定义、初始化子函数、表头插入新元素子函数、表中插入新元素子函数、输出子函数、主函数等。

#include<iostream>
using namespace std;


#define LIST_INIT_SIZE 100

//结构体类型定义
struct StaticList {
   
	int elem[LIST_INIT_SIZE];
	int length;
	int listsize;
};


//初始化
void InitList_StaticList(StaticList &L) {
   
	L.length=0;
	L.listsize=LIST_INIT_SIZE;
}


//在表头插入新元素x
int Ins_SList1(StaticList &L, int x) {
   
	//顺序表已满(没有多余空间),返回-1，表示插入失败
	if(L.length>=L.listsize) {
   
		printf("The list is overflow ! \n ");
		return -1;
	} else {
   
		for (int i=L.length-1 ; i>=0; i--) {
   
			//下标[0, length-1]的元素逐个后移
			L.elem[i+1]=L.elem[i];
		}
		L.elem[0]=x;
		L.length++;
		return 1 ;
	}
}


//在线性表中下标为i(第i+1个位置)的位置插入数据x
int Ins_SList2(StaticList &L, int i, int x) {
   
	//顺序表已满(没有多余空间),返回-1，表示插入失败
	if(L.length>=L.listsize) {
   
		printf ("The list is overflow ! \n") ;
		return -1;
	} else if (i<0 || i>L.length) {
   
		//当i=L.length时即插入位置为表的最后 
		printf ("The position is error ! \n") ;
		return 0;
	} else {
    // i>=0 && i<=L.length
		for (int j=L.length-1; j>=i; j--) {
   
			//下标[i, length-1]的元素逐个后移
			L.elem[j+1]=L.elem[j];
		}
			
		L.elem[i]=x ;
		L.length++;
		return 1 ;
	}
}


//输出
void print(StaticList &L) {
   
	for(int i=0; i<=L.length-1; i++) {
   
		cout<<L.elem[i]<<" ";
	}
	cout<<endl;
}


int main(int argc, char* argv[]) {
   
	StaticList SL;
	int num, pos;
	
	//初始化函数 
	InitList_StaticList(SL) ;
	cout<<"enter numbers:"<<endl;
	while(1) {
   
		int x;
		cin>>x;
		if(x==9999)
			break;
		else
			Ins_SList1(SL, x);
	}
	
	//输出元素 
	cout<<"The list elems:"<<endl ;
	print(SL);
	
	//输入插入元素 
	cout<<"insert a new element:"<<endl;
	cin>>num;
	
	//输入插入元素下标  
	cout<<"input the inserted position:"<<endl;
	cin>>pos;
	
	//插入元素函数 
	Ins_SList2(SL, pos-1, num);
	
	//输出最终表内元素 
	cout<<"The new list elems:"<<endl ;
	print(SL);
	return 0;
}

建立一个静态顺序表（逆序），输出该线性表；然后依次删除表尾元素、表头元素、表的中部元素，并分别输出新的线性表。

提示：完整的程序包括程序前缀、静态顺序表的结构体类型定义、初始化子函数、表头插入新元素子函数、表尾删除元素子函数、表头删除元素子函数、表中删除元素子函数、输出子函数、主函数等。

#include<iostream>
using namespace std;

#define LIST_INIT_SIZE 100

//结构体类型定义
struct StaticList {
   
	int elem[LIST_INIT_SIZE];
	int length;
	int listsize;
};


//初始化
void InitList_StaticList(StaticList &L) {
   
	L. length=0;
	L.listsize=LIST_INIT_SIZE;
}


//在表头插入新元素x
int Ins_SList1(StaticList &L,int x) {
   
	//顺序表已满(没有多余空间),返回-1，表示插入失败
	if(L.length>=L.listsize) {
   
		printf("The list is overflow ! \n ");
		return -1;
	} else
		for (int i=L.length-1; i>=0; i--) {
   
			L.elem[i+1]=L.elem[i];//下标[0, length-1]的元素逐个后移
		}
	L.elem[0]=x;
	L.length++;
	return 1;
}


//输出
void print(StaticList &L) {
   
	for(int i=0; i<=L.length-1 ; i++) {
   
		cout<<L.elem[i]<<" ";
	}
	cout<<endl;
	cout<<endl;
}


//删除表尾元素
int Del_SList2(StaticList &L) {
   
	//顺序表为空(没有元素可删),返回-1,删除失败
	if(L.length==0) {
   
		printf("The list is empty ! \n");
			return -1 ;
	} else {
   
		L.length--;
		return 1 ;
	}
}


//删除表头元素，第1个元素，下标为0
int Del_SList1(StaticList &L) {
   
	//顺序表为空(没有元素可删),返回-1,删除失败
	if(L.length==0) {
   
		printf("The list is empty ! \n") ;
		return -1;
	} else {
    //数据由后往前移动
		for(int i=1; i<=L.length-1 ; i++) {
   
			L.elem[i-1]=L.elem[i];
		}
		L.length--;
		return 1;
	}
}


//删除表中数组下标为i的元素，第i+1个元素
int Del_SList(StaticList &L, int i) {
   
	//顺序表为空(没有元素可删),返回-1,删除失败
	if(L.length==0) {
   
		printf("The list is empty ! \n") ;
		return -1;
	} else if(i<0 || i>L.length-1) {
   
		printf("The index is error ! \n");
		return 0;
	} else {
    //i>=O && i<=L.length-1
		for(int j=i+1; j<=L.length-1; j++) {
   
			//下标[i+1, length-1]的元素逐个前移
			L.elem[j-1]=L.elem[j];
		}
		L.length--;
		return 1;
	}
}


int main(int argc, char* argv[]) {
   
	StaticList SL;
	int num, pos;
	InitList_StaticList(SL) ;
	cout<<"enter numbers:"<<endl ;
	while(1) {
   
		int x;
		cin>>x;
		if(x==9999)
			break ;
		else
			Ins_SList1 (SL,x) ;
	}
	
	cout<<"The list elems:"<<endl;
	print(SL) ;
	
	//删除表头元素
	cout<<"delete the list_head element:" <<endl ;
	Del_SList1(SL);
	cout<<"The new list elems after deleting list_head element:"<<endl ;
	print(SL);
	
	//删除表尾元素 
	cout<<"delete the list_tail element:" <<endl;
	Del_SList2(SL);
	cout<<"The new list elems after deleting list_tail element:"<<endl ;
	print(SL);
	
	//删除表中间元素
	cout<<"delete the list_middle element:" <<endl;
	//输入删除元素的下标 
	cout<<"input the deleted position:"<<endl;
	cin>>pos;
	Del_SList(SL, pos-1) ;
	cout<<"The new list elems:"<<endl ;
	print(SL);
	
	return 0;
}

建立一个动态顺序表（正序），输出该线性表；再在表的中部添加一个新元素，并输出新的线性表。

提示：完整的程序包括程序前缀、动态顺序表的结构体类型定义、初始化子函数、表头或表尾插入新元素子函数、表中插入新元素子函数、输出子函数、主函数等。

#include<iostream>
using namespace std;

typedef int ElemType;
#define LIST_INIT_SIZE 100

//结构体类型定义
typedef struct {
   
	ElemType *elem;
	int length;
	int listsize;
} SqList; //SqList是结构体类型 


//初始化，构造一个空的线性表
int InitList_Sq(SqList &L) {
   
	/*
	申请动态空间，申请 LIST_INIT_SIZE个 类型为ElemType 的空间。
	L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));是C语言的格式。
	L.elem=new ElemType[LIST_INIT_SIZE];是C＋＋的格式。
	*/
	L.elem = new ElemType[LIST_INIT_SIZE];
	
	//申请动态空间未成功 
	if (L.elem==0) {
   
		printf("failure! \n") ;
		return 0;
	} else {
   
		L.length=0;
		L.listsize=LIST_INIT_SIZE;
		return 1 ;
	}
}


//在表尾插入元素e
int ListEndInsert_Sq(SqList &L, ElemType e) {
   
	if(L.length>=L.listsize) {
   
		printf("overf1ow! \n");
		return -1;
	}
	L.elem[L.length]=e;
	L.length++;
	return 1;
}
/*
L.elem[L.length]=e;为何用数组：
只使用数组的形式访问线性表中的一个元素而已，这点和指针类似。
比如char *p="abcdef",同样可以通过p[i]来访问字符串中的字符。
*/


//在动态顺序表L的第i个位置插入元素e
int ListInsert_Sq(SqList &L, int i, ElemType e) {
   
	ElemType *p, *q;
	
	//插入位置不合法
	if(i<=0 || i>=L.length) {
   
		printf("The position error! Not inserted! \n");
		return 0;
	}
	
	//空间不足
	if(L.length>=L.listsize) {
   
		printf("overflow! \n") ;
		return -1;
	}
	
	q=&(L.elem[i-1]);//第i个元素，下标为i-1
	
	for(p=&(L.elem[L.length-1]); p>=q; --p) {
   
		*(p+1)=*p;
	}
	
	*q=e; //插入新元素
	L.length++; //表长递增
	
	return 1;
}


//输出动态线性表元素
void printSq(SqList &L) {
   
	ElemType *p;
	for (p=&(L.elem[0]); p<=&(L.elem[L.length-1]); p++) {
   
		cout<<*p<<" ";
	}
	cout<<endl;
}


int main(int argc, char* argv[]) {
   
	SqList SSL;
	int pos;
	ElemType x;
	InitList_Sq(SSL) ;
	
	cout<<"enter numbers:"<<endl ;
	while(1) {
   
		cin>>x;
		if(x==9999)
			break ;
		else
			ListEndInsert_Sq(SSL,x);
	}
	
	cout<<"The list elems:"<<endl;
	printSq(SSL);
	
	cout<<"enter the inserted position:" <<endl;
	cin>>pos;
	
	cout<<"enter the inserted number x:"<<endl;
	cin>>x ;
	
	//ListInsert_Sq(SSL, pos,x);
	if (ListInsert_Sq(SSL, pos, x)==1) {
   
		cout<<"The new list elems:"<<endl;
		printSq(SSL) ;
	}
	
	return 0;
}

建立一个动态顺序表，输出该线性表；然后依次删除表头元素、表尾元素、表的中部元素，并分别输出新的线性表。

提示：完整的程序包括程序前缀、动态顺序表的结构体类型定义、初始化子函数、表头或表尾插入新元素子函数、表头删除元素子函数、表尾删除元素子函数、表中删除元素子函数、输出子函数、主函数等。

#include<iostream>
using namespace std;

typedef int ElemType;
#define LIST_INIT_SIZE 100

//结构体类型定义
typedef struct {
   
	ElemType*elem;
	int length;
	int listsize;
} SqList;


//初始化
int InitList_Sq(SqList &L) {
   
	//申请动态空间
	L.elem=new ElemType[LIST_INIT_SIZE];
	
	//申请动态空间未成功
	if (L.elem==0) {
   
		printf ("error \n");
		return 0;
	} else {
   
		L.length=0;
		L.listsize=LIST_INIT_SIZE;
		return 1 ;
	}
}


//在表尾插入数据
int ListEndInsert_Sq(SqList &L, ElemType e) {
   
	if (L.length==L.listsize) {
   
		printf("overflow! \n") ;
		return -1;
	}
	L.elem[L.length]=e;
	L.length++;
	return 1 ;
}


//删除表头数据元素
int DelHeadList_Sq(SqList &L) {
   
	ElemType *p;
	if (L.length==0) {
   
		printf("UNDERFLOW! \n");
		return -1;
	} else {
   
		for(p=&(L.elem[1]); p<=&(L.elem[L.length-1]); p++) {
   
			*(p-1)=*p;
		}
		L.length--;
		return 1 ;
	}
}


//删除表尾数据元素
int DelEndList_Sq(SqList &L) {
   
	if(L.length==0) {
   
		printf("UNDERFLOW! \n");
		return -1 ;
	} else {
   
		L.length--;
		return 1 ;
	}
}


//删除第i个元素
int DelList_Sq(SqList &L, int i) {
   
	ElemType *p;
	//溢出
	if (L.length==0) {
   
		printf("UNDERFLOW! \n");
		return -1;
	}
	//删除位置不合法
	else if (i<=0 || i>L.length) {
   
		printf("The position error! Not deleted! \n");
		return 0;
	} else {
   
		for (p=&(L.elem[i]); p<=&(L.elem[L.length-1]); p++) {
   
			*(p-1)=*p ;
		}
		L.length--;
		return 1 ;
	}
}


//输出动态线性表元素
void printSq(SqList &L) {
   
	ElemType *p;
	for (p=&(L.elem[0]); p<=&(L.elem[L.length-1]); p++) {
   
		cout<<*p<<" ";
	}
	cout<<endl;
}


int main(int argc, char* argv[]) {
   
	SqList SSL;//定义结构体变量SSL
	int pos, x;
	InitList_Sq(SSL); //初始化线性表
	cout<<"enter numbers:"<<endl;
	while(1) {
   
		cin>>x;
		if(x==9999)
			break;
		else {
   
			ListEndInsert_Sq(SSL, x);//构造一个线性表
		}
	}
	cout<<"The list elems:"<<endl;
	printSq(SSL);
	cout<<"delete the head elem:"<<endl;

	//删除表头元素
	DelHeadList_Sq(SSL);
	cout<<"The new deleted list elems:"<<endl;
	printSq(SSL);

	//删除表尾元素
	cout<<"delete the tail elem: "<<endl;
	DelEndList_Sq(SSL);
	cout<<"The new de1eted 1ist elems:"<<endl;
	printSq(SSL);

	cout<<"enter the deleted position: "<<endl;
	cin>>pos;
	
	//De1List_sq(SSL, pos); //删除第i个数据元素
	if (DelList_Sq(SSL, pos)==1) {
   
		cout<<"The new deleted list elems:"<<endl;
		printSq(SSL);
	}
	
	return 0;
}

合并两个有序动态顺序表LA和LB，生成一个新的有序顺序表LC，并输出该顺序表LC。

提示：完整的程序包括程序前缀、动态顺序表的结构体类型定义、初始化子函数（可选）、表尾插入新元素子函数、合并有序顺序表子函数、输出子函数、主函数等。

#include<iostream>
using namespace std;

typedef int ElemType;

//结构体类型定义
struct SqList {
   
	ElemType *elem;
	int listsize;
	int length;
};


void InputData(SqList &LA);
void MergeList_Sq(SqList LA, SqList LB, SqList &LC);
void print(SqList LC);


int main(int argc, char* argv[]) {
   
	SqList LA, LB, LC;

	//初始化顺序表LA
	LA.elem=new ElemType[100];
	LA.length=0;
	LA.listsize=100;

	//初始化顺序表LB
	LB.elem=new ElemType[100];
	LB.length=0;
	LB.listsize=100;

	cout<<"创建LA表，请按升序输入整数，以9999结束:"<<endl;
	InputData(LA) ;
	cout<<"输出LA表:"<<endl;
	print(LA);
	cout<<endl;

	cout<<"创建LB表，请按升序输入整数，以9999结束:"<<endl;
	InputData(LB);
	cout<<"输出LB表:"<<endl;
	print(LB);
	cout<<endl;

	cout<<"合并LA表和LB表，生成LC表:"<<endl;
	MergeList_Sq(LA, LB, LC);
	cout<<"输出LC表:"<<endl;
	print(LC);
	
	return 0;
}


//构造升序排列的顺序表
void InputData(SqList &LA) {
   
	ElemType num;
	for(int i=0; ; i++) {
   
		cin>>num;
		if (num!=9999) {
   
			LA.elem[i]=num;
			LA.length++;
		} else
			break;
	}
}


//输出
void print(SqList LC) {
   
	for(int i=0; i<LC.length; i++)
		cout<<LC.elem[i]<<" ";
	cout<<endl;
}


//LA、LB中的元素为升序,合并后的LC也为升序
void MergeList_Sq(SqList LA, SqList LB, SqList &LC) {
   
	int i, j, k ;
	i=j=k=0;

	//初始化顺序表LC
	LC.length=LA.length + LB.length;
	LC.listsize=LA.listsize + LB.listsize;
	LC.elem=new ElemType[LC.listsize];

	//当LA、LB同时不为空时,进行下面操作
	while(i<=LA.length-1 && j<=LB.length-1) {
   
		//取LA的第i+1个元素，下标为i
		ElemType pa=LA.elem[i];
		//取LB的第j+1个元素，下标为i
		ElemType pb=LB.elem[j];

		if (pa<=pb) {
   
			LC.elem[k]=pa; //pa插入LC尾部
			k++; //LC下标后移
			i++; //LA下标后移
		} else {
    
			LC.elem[k]=pb;
			k++; //LC下标后移
			j++; //LB下标后移
		}
		
		//如果LA中还有元素，则所有元素全部插入LC尾部
		while(i<=LA.length-1) {
   
			ElemType pa=LA.elem[i];
			LC.elem[k]=pa;
			k++;
			i++;
		}
		
		//如果LB中还有元素，则所有元素全部插入LC尾部
		while(j<=LB.length-1) {
   
			ElemType pb=LB.elem[j];
			LC.elem[k]=pb;
			k++;
			j++;
		}
	}
}

构造一个单链表，分别实现在表头、表中插入新元素的操作，并输出该单链表。

提示：完整的程序包括程序前缀、单链表的结构体类型定义、表尾插入新元素子函数、表头插入新元素子函数、表中插入新元素子函数、求链表表长子函数、输出子函数、主函数等。

#include <iostream>
using namespace std;

typedef int ElemType;

//结构体类型定义
struct LinkNode {
   
	ElemType data;
	struct LinkNode *next;
};


//输出
//将链表L中的数据输出到屏幕上,其中L指向头结点
void print(LinkNode* L) {
   
	LinkNode *p; //定义一个指针变量
	p=L->next; //让p指向链表L的第一个数据
	while(p!=0) {
   
		cout<<p->data<<" "; //输出数据到屏幕上
		p=p->next; //指针后移
	}
	cout<<endl;
}


//在以H为头指针的单链表表尾插入一个数据x
//&可以去掉
void Insert_tail(LinkNode*&H, ElemType x) {
   
	LinkNode *t,*p; //定义指针
	t=new LinkNode; //申请新结点空间
	t->data=x; //向新结点中写入数据
	t->next=0; //把空地址写入新结点中
	p=H;
最低0.47元/天 解锁文章
wauyo
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
软件工程上机作业.pptx
11-14
软件工程上机作业 软件工程是一门综合性科学，需要结合实际项目进行实践和应用。本文档对软件工程上机作业进行了详细的阐述，包括概述、项目总体规划、设计思想、建设原则、设计特色等方面的内容。 概述 山东淄博...
大连理工大学优化方法上机作业-2022春上机作业
05-27
大连理工大学优化方法上机作业-2022春上机作业 【1 问题的维数n= 2ab (ab为自己的学号最后两位，例如张三学号为22104135,那么n=235).取 x=0,步长ak为精确线搜索,利用下述方法求二次函数f(x)= xTGx+ bTx的极小点: 。...
第一次上机作业
jennifer_sx的博客
11-13 286
1、输入三个实数，按从大到小的顺序输出 #include<iostream> using namespace std; int main(){ int num1,num2,num3; int max,min; cout<<"请输入三个数字"<<endl; cin>>num1>>num2>>num3; if(num1>num2){ max = num1, min = num2; } else{ max
线性表的实现（一）
zmm0628的博客
04-23 655
我回来了，也变强了！准备更新王道考研课程中实现的代码。欢迎交流！ 第二章线性表 用静态数组实现线性表。 把书上给到的函数给实现一下。 话不多说，直接上代码了。 void InitList(SqList &L)； 初始化表。构造一个空表。 bool List_input(SqList &L,int n)； 键入数据元素，n为你想键入的个数。 bool PrintfList(SqList &L)； 输出操作，按先后顺序输出线性表的所有元素。 int Length(SqList L)； 求
【计算机程序设计必看】线性表
m0_62024760的博客
04-27 2213
线性表 读完本篇文章你能学会什么？（要求） 理解线性表的概念 熟练掌握线性表的基本运算 掌握线性表的顺序存储结构及基本运算 掌握线性表的链式存储结构及基本运算 掌握在顺序表和链表上算法设计的基本技能 理解顺序表和链表的优缺点 线性表的基本概念 线性表（Linear List）是一种线性结构，它是由若干个结点按照“一对一”的逻辑关系组织起来的有穷序列。当线性表的长度为0时我们称它为空表，记为（）。数据元素又称结点，当线性表的长度大于0时，线性表可表示为（a1，a2，a3.........
数据结构：线性表顺序表以及单链表详解
wang_fm的博客
11-06 836
导航????⭐前言⭐线性表线性表的定义及基本表示线性表的定义基本操作顺序表顺序表的定义顺序表的基本操作增删查改线性表的链式表示单链表的定义链表的建立链表的操作插入节点删除结点 ⭐前言⭐ 本文将解析线性表中的顺序表以及链表 线性表 线性表的定义及基本表示 线性表的定义 线性表是具有相同数据类型的n个数据元素的有限集合。 常见的线性表有顺序表、链表、栈和队列。 基本操作 void InitList(&L);//初始化表。构造一个空的线性表。 int Length(L);//求表长。返回线性表L的长度，
python零基础自学第四周 列表List实用详解，满满干货
hahahehe2020的博客
11-23 670
python零基础自学第四周 列表List实用详解，满满干货 自己写的一个针对PDF特别好用（懒人懒得打字使用特别舒畅）的截图识别文字的Pyhon小程序，可以复制截图的文字部分。 自己写的python代码，学以致用，已经会打包.exe。但是默认C盘路径，其他路径无法使用（不知道什么问题，求大佬指点），有兴趣可以交流，有上传了一个小资源 1、截图文字识别.py（QQ已有） 2、截图文字识别并翻译.py 接下来是自学的List表： print('-------%与格式化表达式比较-------------'
东南大学数值上机作业_东南大学上机作业_
10-03
东南大学数值分析课后上机习题，可以直接跑代码
电子商务上机作业.docx
12-17
电子商务上机作业.docx
基于Web的上机作业管理系统
10-26
讨论了Web环境下上机作业管理系统的体系结构、系统功能、数据库设计以及系统的实现技术。
线性表·顺序表
qq_54502707的博客
06-01 792
线性表是最常用且最简单的一种数据结构。一个线性表是n个数据元素的有限序列。在稍复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表you ...
数据结构——线性表 C语言
良猿啊
09-22 544
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MaxSize 20 #define ElemType int typedef struct { ElemType data[MaxSize]; //存放线性表中的元素 int length; ...
C语言 线性表的基本操作
weixin_51528408的博客
10-02 3254
一、线性表的定义 线性表是一种最常用也是最简单的数据结构。简单来讲，一个线性表是n个数据元素的有限排列，在不同情况下，每个数据元素有着不同的含义。 二、线性表的组成 一个线性表的结构体由三部分组成：1.线性表中的元素（Elem）2.线性表的当前长度（Length）3、线性表当前分配的储存空间大小（ListSize，通常情况下ListSize>Length） 三、头文件以及数据的定义 #include<stdio.h> #include<stdlib.h> #include&lt
数据结构 -线性表
weixin_59725429的博客
11-06 971
线性表 定义：线性表（linear list）是具有相同特性的数据元素的一个有限序列。线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) ai（1≤i≤n）表示第i（i表示逻辑位序）个元素。前驱与后继：线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1, ai)，即ai-1是ai的前驱， ai是ai-1的后继；a1 无前驱，an无后继，其它每个元素有且仅有一个前驱和一个后继。线性表长度：线性表中元素的个数。线性表L=（a1,a2,a3……
C++中顺序线性表的基本功能实现
qq_45674520的博客
12-01 772
编写线性表定义及基本操作函数 例如：建立具有5个元素的顺序表。 　L=(a,b,c,d,f) 　 并完成如下操作： (1)输出线性表 (2)求线性表L的长度 (3)获取第3个元素的值 (4)获取元素 a 在线性表中的位置 (5)在第4个元素前，插入元素g (6)删除第5个元素的值 #include <malloc.h> #include <stdio.h> #define MaxSize 50 using namespace std; typedef char ElemType; 定
数据结构——线性表
m0_51743362的博客
04-18 1135
线性表 定义： 线性表是具有相同数据类型的n（n大于等于0）个数据元素的有限序列，其中n为表长，当n=0时线性表时一个空表。若用L命名线性表，则七一般标识为L = （a1，a2，...，ai，ai+1，...an） 概念： ai是线性表中的“第i个”元素线性表中的为序 a1是表头元素；an是表尾元素。 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有有一个直接后续 线性表的基本操作： ...
c语言建立线性表并输出,C++怎样建立一个线性表？
weixin_35275189的博客
05-24 1746
满意答案_婊嬩簨甯漘2019.10.25采纳率：41%等级：8已帮助：364人#include#includeusingnamespacestd;#defineMAXLEN100//定义顺序表的最大长度/**************顺序表的定义部分*****************/structDATA{stringkey;//结点的关键字stringname;intag...
fortran上机作业1
最新发布
09-30
Fortran是一种科学计算语言，经常用于高性能计算和科学工程领域。对于Fortran上机作业1，我们需要了解具体的题目内容才能给出详细解答。在这里，我将提供一些关于Fortran上机作业1的一般性指导。 通常，Fortran上机作业1会涉及到一些基本的程序编写和计算任务。以下是一些可能的题目类型： 1. 简单的数值计算：要求编写一个Fortran程序，实现基本的数学计算任务，如加法、减法、乘法和除法等。学生需要理解Fortran的基本语法和常用数学函数，并根据题目要求编写程序。 2. 循环结构：题目要求学生使用循环结构编写Fortran程序。这可能包括使用DO循环实现数列的计算、累加操作、求平均值等。学生需要熟悉循环结构的语法和用法，并且能够根据题目要求正确编写程序。 3. 条件语句：题目要求学生使用条件语句编写Fortran程序。例如，根据输入的数据，判断某个条件是否成立，并根据条件选择执行不同的操作。学生需要理解条件语句的语法和逻辑，并且能够正确编写满足要求的程序。 4. 输入和输出：题目要求学生编写带有输入和输出的Fortran程序。这可能包括从文件中读取数据、将计算结果写入文件、显示运算过程等。学生需要理解输入和输出操作的语法和用法，并能够正确处理数据的读取和输出。 无论具体的题目类型是什么，完成Fortran上机作业1的关键是理解题目要求，熟悉Fortran的语法和常用函数，并能够正确地将问题转化为程序。此外，良好的编程习惯和代码可读性也是非常重要的，包括合理的命名方式、适当的注释和代码缩进等。最后，测试程序的正确性也是不可忽视的一步，可以通过调试和对比预期结果来验证程序的正确性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值