当前位置：首页 » 编程语言 » 数据结构c语言版题目
扩展阅读
提分平台的账号密码是什么 2023-08-31 22:07:10
webinf下怎么引入js 2023-08-31 21:54:13
堡垒机怎么打开web 2023-08-31 21:54:11

数据结构c语言版题目

发布时间: 2022-11-29 01:45:08

❶ 数据结构c语言题目 求大神解一下。

#include<iostream>
usingnamespacestd;
constintMaxSize=200;
classSeqList
{public:
SeqList(inta[],intn);
intLength();
voidInsert(intb[],intlength2);
voidPrintList();
private:
intdata[MaxSize];
intlength;
};
SeqList::SeqList(inta[],intn)
{inti;
if(n>MaxSize)throw"
参数非法
";
for(i=0;i<n;i++)
data[i]=a[i];
length=n;
}
intSeqList::Length()
{
returnlength;
}
voidSeqList::Insert(intb[],intlength2)
{intj,h,i=0;
for(j=0;j<length&&i<length2;++j)
{if(b[i]<data[j])
{for(h=length;h!=j;--h)
data[h]=data[h-1];
data[j]=b[i];
++length;
++i;
}
elseif(j==length-1&&b[i]>data[length-1])
{
data[length]=b[i];
length++;
++i;
}
}
}
voidSeqList::PrintList()
{for(inti=0;i<length;i++)
cout<<data[i]<<"";
cout<<endl;
}
voidmain()
{

inta[6]={1,5,8,10,15,21};

intb[3]={6,13,18};

SeqLists(a,6);

SeqListc(b,3);

cout<<"
合并前的顺序表
A"<<endl;

s.PrintList();

cout<<"
合并前的顺序表
B"<<endl;

c.PrintList();

cout<<"
合并后的顺序表
C"<<endl;

intx=c.Length();

s.Insert(b,x);

s.PrintList();
}

❷ c语言编程 数据结构题

C语言实现链式栈，进行两个栈的进出栈操作，并分别输出栈的内容，参考代码如下:

#include<stdio.h>
#include<stdlib.h>
typedefstructLnode{
intdata;
structLnode*next;
}Lnode,*Linklist;
voidPrint(Linklistlist);
voidPush(Linklistlist,intdata);
intPop(Linklistlist,int*data);
voidDelete(Linklistlist);
intmain(void)
{
Linklists,t;
intdata;
s=(Lnode*)malloc(sizeof(Lnode));
t=(Lnode*)malloc(sizeof(Lnode));
if(s==NULL||t==NULL)
return1;
s->next=NULL;
t->next=NULL;
Push(s,1);
Push(s,2);
Push(s,3);
Push(s,4);
Push(s,5);
printf("链表s=");
Print(s);
printf("链表t=");
Print(t);
Pop(s,&data);
Push(t,data);
Pop(s,&data);
Push(t,data);
Pop(s,&data);
Push(t,data);
Pop(s,&data);
Push(t,data);
Pop(s,&data);
Push(t,data);
printf("链表s=");
Print(s);
printf("链表t=");
Print(t);
Delete(s);
Delete(t);
return0;
}
voidPush(Linklistlist,intdata)
{
Lnode*p=(Lnode*)malloc(sizeof(Lnode));
if(p==NULL)exit(1);
p->data=data;
p->next=list->next;
list->next=p;
}
intPop(Linklistlist,int*data)
{
Lnode*p=list->next;
if(p==NULL)return0;
list->next=p->next;
*data=p->data;
free(p);
return1;
}
voidPrint(Linklistlist)
{
Lnode*p;
for(p=list->next;p!=NULL;p=p->next)
printf("%d",p->data);
printf("
");
}
voidDelete(Linklistlist)
{
Lnode*p=list->next,*q;
while(p!=NULL){
q=p;
p=p->next;
free(q);
}
list->next=NULL;
}

❸ 初学者求解一道数据结构[c语言版]的题目

/***
*
*题目：已知线性表中的元素以值递增有序排列，并以单链表做存储结构。试写一高效的算法，
*
删除表中所有值大于
mink
且小于
maxk
的元素（若表中存在这样的元素）,同时释放
*
被删除节点空间，并分析你的算法的时间复杂度（注意：mink
和
maxk
是给定的两个
*
参变量，它们的值可以和表中的元素相同，也可以不同）
*
****/
#include
<stdio.h>
#include
<stdlib.h>
#include
"DynaLinkList.h"
void
DelMminMax(LinkList
*L,
int
min,
int
max)
{
LinkList
p
=
(*L)->next,
q
=
(*L),
r;
while
(p
&&
p->data
<=
min)
{
q
=
p;
p
=
p->next;
}
while
(
p
&&
p->data
<
max)
{
r
=
p;
p
=
p->next;
q->next
=
p;
free(r);
}
}
//算法的时间复杂度为O(n)
int
main()
{
LinkList
L;
ElemType
e,
min,
max;
InitList(&L);
printf("输入8个元素建立线性表L(元素递增有序):\n");
for
(int
i=1;
i<=8;
i++)
{
scanf("%d",
&e);
ListInsert(&L,
i,
e);
}
printf("表L是：\n");
ListTraverse(L,
visit);
printf("请输入待删除的元素的区间是(min,max):\n");
scanf("%d%d",
&min,
&max);
DelMminMax(&L,min,max);
printf("删除(%d,%d)之间的元素后表L是：\n",min,max);
ListTraverse(L,
visit);
return
0;
}

❹ 数据结构（c语言版）题目求答案

3.28
void InitCiQueue(CiQueue&Q)//初始化循环链表表示的队列Q
{
Q=(CiLNode*)malloc(sizeof(CiLNode));
Q->next=Q;
}//InitCiQueue
voidEnCiQueue(CiQueue&Q,int x)//把元素x插入循环列表表示的队列Q,Q指向队尾元素，Q->next指向头结点，Q->next->next指向队尾元素
{
p=(CiLNode*)malloc(sizeof(CiLNode));
p->data=x;
p->next=Q->next;//直接把p加在Q的后面
Q->next=p;
Q=p;//修改尾指针
}
Status DeCiQueue(CiQueue&Q,int x)//从循环链表表示的队列Q头部删除元素x
{
if(Q==Q->next)return INFEASIBLE;//队列已空
p=Q->next->next;
x=p->data;
Q->next->next=p->next;
free(p);
rturn OK;
}//DeCiqueue

3.31

int Palindrome_Test()
{
InitStack(S);InitQueue(Q);
while((c=getchar())!='@')
{
Push(S,c);EnQueue(Q,c);
}
while(!StackEmpty(S))
{
pop(S,a);DeQueue(Q,b);
if(a!=b)return ERROR;
}
return OK;
}

❺ c语言编程 数据结构题

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

#defineelemTypeint							/*单链表元素数据类型*/
#defineLNODE_SIZEsizeof(structlNode)		/*单链表结点空间大小*/

#definestatusint	/*状态型变量*/
#defineOVERFLOW-1	/*内存溢出状态码*/
#defineERROR0		/*错误状态码*/
#defineOK1		/*正确状态码*/

/*单链表数据结构*/
typedefstructlNode{
	elemTypedata;
	structlNode*next;
}lNode,*linkList;

/*初始化*/
/*操作结果：构造一个空的单链表L*/
voidinitList(linkList*L){
	*L=(linkList)malloc(LNODE_SIZE);/*产生头结点，并使L指向此头结点*/
	if(!*L)/*内存分配失败*/
		exit(OVERFLOW);
	(*L)->next=NULL;/*指针域为空*/
}

/*销毁*/
/*初始条件：单链表L已存在。操作结果：销毁单链表L*/
voiddestroyList(linkListL){
	linkListp,q;
	
	p=L->next;/*p指向第一个结点*/
	while(p){/*没到表尾*/
		q=p->next;
	free(p);
	p=q;
	}
	free(L);
}

/*判断单链表是否为空*/
/*初始条件：单链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE*/
intlistIsEmpty(linkListL){
	returnL->next==NULL;
}

/*寻找指定特征(compare)元素的位序*/
/*初始条件:线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)*/
/*操作结果:返回L中第1个与e满足关系compare()的数据元素的位序*/
/*若这样的数据元素不存在，则返回值为0*/
intlocateElem(linkListL,elemTypee,status(*compare)(elemType,elemType)){
	inti=0;
linkListp=L->next;
while(p){
i++;
if(compare(p->data,e))/*找到这样的数据元素*/
returni;
p=p->next;
}
return0;
}

/*数据元素判定*/
/*满足为1，否则为0*/
intcompare(elemTypedes,elemTypesrc){
	returndes==src;
}

/*单链表指定位置插入新元素*/
/*操作结果：在带头结点的单链表L中第i个位置之前插入元素e*/
statuslistInsertNode(linkListL,inti,elemTypee){
	intj=0;
	linkListp=L,s;
	
	while(p&&j<i-1){/*寻找第i-1个结点*/
		p=p->next;
	j++;
	}
	
	if(!p||j>i-1)/*插入位置不合理：i小于1或者大于表长*/
		returnERROR;
	
	/*生成新结点，并插入L中*/
	s=(linkList)malloc(LNODE_SIZE);
	if(!s)/*内存分配失败*/
		exit(OVERFLOW);
	s->data=e;
	s->next=p->next;
	p->next=s;
	
	returnOK;
}

/*删除单链表指定位置元素*/
/*操作结果：在带头结点的单链线性表L中，删除第i个元素，并由e返回其值*/
statuslistDeleteNode(linkListL,inti,elemType*e){
	intj=0;
	linkListp=L,q;
	
	while(p->next&&j<i-1){/*寻找第i个结点，并令p指向其前驱结点*/
	p=p->next;
		j++;
	}
	
	if(!p->next||j>i-1)/*删除位置不合理：i小于1或者大于表长*/
		returnERROR;
	
	/*删除并释放结点*/
	q=p->next;
	p->next=q->next;
	*e=q->data;
	free(q);
	
	returnOK;
}

/*打印链表内容*/
/*初始条件：单链表L已存在。操作结果：当链表不为空时，打印链表内容并返回OK，否则返回ERROR*/
statusprintList(linkListL){
	linkListp=L->next;/*p指向第一个结点*/
	
	if(listIsEmpty(L)){
		puts("Thelinklistisempty!");
		returnERROR;
	}
	
	while(p){
		printf("%d	",p->data);
		p=p->next;
	}
	putchar('
');
	returnOK;
}

intmain(void){
	linkListL;
	elemTypee;
	intindex;
	
	/*初始化链表*/
	initList(&L);
	/*插入若干元素*/
	listInsertNode(L,1,1);
	listInsertNode(L,2,4);
	listInsertNode(L,3,6);
	listInsertNode(L,4,7);
	listInsertNode(L,5,10);
	
	printf("初始链表内容：
");
	printList(L);
	putchar('
');
	
	/*寻找数据为6的结点位置*/
	index=locateElem(L,6,&compare);
	printf("数据为6的结点位置：
%d
",index);
	putchar('
');
	
	/*在数据为6的结点之前插入数据为5的结点*/
	listInsertNode(L,index,5);
	
	printf("当前链表内容：
");
	printList(L);
	
	destroyList(L);
	
	getch();/*屏幕暂留*/
	return0;
}

❻ 数据结构（C语言版）的题

1）在P结点后插入S结点的语句序列是:(4),(1)
2）在P结点前插入S结点的语句序列是:(7),(8),(1),(4)
3）在表首插入S结点的语句序列是:(5)
4）在表尾插入S结点的语句序列是:(9)(1)(6)

❼ c语言编程 数据结构题

栈先进后出，队列先进先出，队列的顺序等价于栈的出栈顺序。写了个简单的验证程序，初始的出栈顺序必须无误

#include<iostream>
usingstd::cout;

//iStack元素值有序，简化了编程，否则就要借助于下标的有序性
//'g'作为一个额外的标记，取到此值时，表示所有元素都已入栈
chariStack[]={'a','b','c','d','e','f','g'};
charoStack[]={'b','d','f','e','c','a'};

intno=1;

//sp用于指示iStack未入栈的元素
intsp=0;

charTop()
{
returniStack[sp];
}

//ch及之前元素入栈
voidPush(charch)
{
charcc=Top();
while(cc<=ch)
{
printf("(%2d)Push: %c ",no++,cc);
sp++;
cc=Top();
}
}

voidPop(charch)
{
if(ch>=Top()) //当前要出栈的元素未入栈
Push(ch);

printf("(%2d)Pop: %c ",no++,ch);
}

intmain()
{
intcount=0;
intlen=sizeof(oStack);

//1
printf("入栈顺序： ");
for(inti=0;i<len;i++)
printf("%c",iStack[i]);
printf(" ");

//2
printf("出栈顺序： ");
for(inti=0;i<len;i++)
printf("%c",oStack[i]);
printf(" ");

//3
printf("出入栈操作： ");
while(count<len)
{
Pop(oStack[count]);
count++;
}

return0;

}

❽ 数据结构（C语言版）编程题

倒 题目是靠自己想的,如果你基础不好,拿别人的又有什么意思呢

❾ 数据结构c语言版一道题求解

完整代码：

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

structSeqList
{intMAXNUM;/*顺序表中最大元素的个数*/
intn;/*存放线性表中元素的个数n≤MAXNUM*/
DataType*element;/*element[0],element[1]，…，element[n-1]存放线性表中的元素*/
};

typedefstructSeqList*PSeqList;

PSeqListcreateNullList_seq(intm){
/*创建新的顺序表*/
PSeqListpalist=(PSeqList)malloc(sizeof(structSeqList));
if(palist!=NULL){
palist->element=(DataType*)malloc(sizeof(DataType)*m);
if(palist->element){
palist->MAXNUM=m;
palist->n=0;/*空表长度为0*/
return(palist);
}
elsefree(palist);
}
printf("Outofspace!!
");/*存储分配失败*/
returnNULL;
}

intisNullList_seq(PSeqListpalist){
/*判别palist所指顺序表是否为空表。*/
	if((palist==NULL)||(palist->n==0)){
		return1;
	}
	return0;
}

intlocate_seq(PSeqListpalist,DataTypex){
/*求x在palist所指顺序表中的下标*/
	inti,ret=-1;
	if(palist==NULL)returnret;
	ret=palist->n;
	for(i=0;i<palist->n;++i){
		if(palist->element[i]>=x){
			ret=i;
			break;
		}
	}
	returnret;
}

intinsertPre_seq(PSeqListpalist,intp,DataTypex)
/*在palist所指顺序表中下标为p的元素之前插入元素x*/
{
	inti,ret=-1;
	if(palist==NULL||palist->n>=palist->MAXNUM)returnret;
	if(p>=palist->n){
		palist->element[palist->n]=x;
		ret=palist->n;
		++palist->n;
	}
	else{
		for(i=palist->n;i>p;--i){
			palist->element[i]=palist->element[i-1];
		}
		palist->element[i]=x;
		ret=i;
		++palist->n;
	}
	returnret;
}

intdeleteP_seq(PSeqListpalist,intp)
/*在palist所指顺序表中删除下标为p的元素*/
{
	inti;
	if(isNullList_seq(palist)||p>=palist->n)return-1;
	for(i=p-1;i<palist->n-1;++i){
		palist->element[i]=palist->element[i+1];
	}
	--palist->n;
	return1;
}

voidprint(PSeqListpalist){
	inti;
	if(isNullList_seq(palist))return;
	for(i=0;i<palist->n;++i){
		printf("%d	",palist->element[i]);
	}
	if(palist->n>0)	printf("
");
}
/*
LA={1,1,3,3,4,6},LB={2,3,5,7,9},
*/

intmain(){
	inti;
	PSeqListLA,LB,LC;
	inta[]={1,1,3,3,4,6},b[]={2,3,5,7,9};
	LA=createNullList_seq(6);
	LB=createNullList_seq(5);
	for(i=0;i<6;++i){
		insertPre_seq(LA,i,a[i]);
	}
	print(LA);
	for(i=0;i<5;++i){
		insertPre_seq(LB,i,b[i]);
	}
	print(LB);
	LC=createNullList_seq(LA->MAXNUM+LB->MAXNUM);
	for(i=0;i<LA->n;++i){
		insertPre_seq(LC,i,LA->element[i]);
	}
	for(i=0;i<LB->n;++i){
		intp=locate_seq(LC,LB->element[i]);
		insertPre_seq(LC,p,LB->element[i]);
	}
	print(LC);
	return0;
}
阅读全文

与数据结构c语言版题目相关的内容

本站内容整理源于互联网，如有问题请联系解决。
Copyright design: www.gotrillian.com since 2022