當前位置：首頁 » 編程語言 » 數據結構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