数据结构编译题库

⑴ C语言数据结构上机题

#include "stdafx.h"
#include<iostream>
using namespace std;
typedef struct LNode
{
char data;
struct LNode * next;
}LNode,* LinkList;
void CreateList(LinkList &L)//创建链表存放26个字母组成的线性表
{
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
char c='z';
for(int i=26;i>0;i--)
{
LNode *p;
p=(LinkList)malloc(sizeof(LNode));
p->data=c--;
p->next=L->next;
L->next=p;
}
}
bool ListInsert(LinkList &L,int i,char c)//在第i个位置插入字母c
{
LNode * p=L;int j=0;
while(p&&j<i-1)
{
p=p->next;
++j;
}
if(!p||j>i-1)
return false;
LinkList s=(LinkList)malloc(sizeof(LNode));
s->data=c;
s->next=p->next;
p->next=s;
return true;
}
void main()
{
LinkList L;
CreateList(L);//1.创建链表存放26个字母组成的线性表
char c;int i;
cout<<"输入插入的字母"<<endl;
cin>>c;
cout<<"输入插入的位置（整数）"<<endl;
cin>>i;
if(ListInsert(L,i,c))//在第i个位置插入字母c
{
while(L->next!=NULL)//将插入后的线性表输出
{
cout<<L->next->data;
L=L->next;
}
}
}

//辛苦写完．．．刚调试通过．．．加分啊．．
调试是在C++环境下调试的，如果你要在C环境下．．把
cout<<L->next->data; 改为：
printf("%d",L->next->data);
cin>>c;改为：scanf("%c",c);
就ok了．．．．．．

ps: o_o一般上机都是C++吧．．．．．．

⑵ 两道C++数据结构题~!

以下所有程序均通过编译与调试，应该没问题

第一题是经典的广度优先搜索问题，如果想要效率更高一点可以采用双向广度优先搜索，不过总共才9!=362880种状态，没太大必要，偷懒不写了

#include <iostream>
#define MAXN 362880
const int ftl[]={40320,5040,720,120,24,6,2,1,1};//阶乘
const int dir[4][2]={{-1,0},{1,0},{0,1},{0,-1}};
//约定用三行三列的二维数组表示一种状态，其中用0表示空位

int Code(int a[3][3])//特定状态转化为编号
{
int A[9];
int i,j;
int ans;
ans=0;
for (i=0;i<9;i++) A[i]=a[i/3][i%3];
for (i=0;i<9;i++)
{
ans+=A[i]*ftl[i];
for (j=i+1;j<9;j++)
if (A[j]>A[i]) A[j]--;
}
return ans;
}

int head,tail;
int queue[MAXN][3][3];
int tar[3][3],tarid;
int pi[MAXN];//记录队列中各节点的前趋节点
bool hash[MAXN];

int length;
int path[MAXN];//记录操作步骤

void Print(int i)//输出步骤
{
int j,k;
length=0;
while (i!=-1)
{
path[length++]=i;
i=pi[i];
}
std::cout<<"Total steps: "<<length-1<<std::endl;
for (k=length-1;k>=0;k--)
{
std::cout<<"Step "<<length-k-1<<":"<<std::endl;
for (i=0;i<3;i++)
{
for (j=0;j<3;j++) std::cout<<queue[path[k]][i][j]<<' ';
std::cout<<std::endl;
}
}
return;
}

int main()
{
int i,j,k;
for (i=0;i<9;i++) std::cin>>queue[0][i/3][i%3];//约定输入时用0表示空格，读取初始状态
for (i=0;i<9;i++) std::cin>>tar[i/3][i%3];//读取目标状态
tarid=Code(tar);
pi[0]=-1;
memset(hash,true,sizeof(hash));
hash[Code(queue[0])]=false;
head=0;
tail=1;

while (head<tail && hash[tarid])
{
int x,y;//当前节点中空格的位置
for (i=0;i<9;i++)
if (queue[head][i/3][i%3]==0)
{
x=i/3;
y=i%3;
break;
}
for (i=0;i<4;i++)
{
int x2,y2,id;//新生成节点的空格位置以及编号
x2=x+dir[i][0];
y2=y+dir[i][1];
if (x2>=0 && x2<3 && y2>=0 && y2<3)
{
for (j=0;j<9;j++) queue[tail][j/3][j%3]=queue[head][j/3][j%3];
queue[tail][x][y]=queue[tail][x2][y2];
queue[tail][x2][y2]=0;
id=Code(queue[tail]);
if (hash[id])
{
hash[id]=false;
pi[tail]=head;
if (id==tarid) Print(tail);
tail++;
}
}
}
head++;
}

if (hash[tarid]) puts("No Solution!");
return 0;
}

第二题楼主的说明不是太明确，姑且做一些这样的约定吧：
输入数据的时候，不是直接输入多项式，而是多项式的项数，之后跟着一组一组的（系数，指数）组，并且为了方便，所有的系数、指数都是整数
输出按照多项式格式降幂输出

比如这样的输入

4
1 5 3 6 -2 2 4 0
2
1 1 1 0

#include <iostream>
struct Node//链表节点，也就是多项式的项
{
int c;//系数
int e;//指数
Node *next;//下一项
Node()
{
next=0;
}
};

void Insert(Node *p,int c,int e)//按降幂插入一项到多项式中
{
Node *q;
if (c==0) return;
while (p->e>e)
{
q=p;
p=p->next;
}
if (p->e==e)
{
p->c+=c;
if (p->c==0)//删除系数为0的项
{
q->next=p->next;
p->next=0;
delete p;
}
}
else
{
q->next=new Node;
q=q->next;
q->c=c;
q->e=e;
q->next=p;
}
return;
}

void Print(Node *p,bool first)//first为真表示p是多项式的第一项
{
if (p->e==0x80000000)
{
if (first) std::cout<<0;
std::cout<<std::endl;
}
else
{
if (!first && p->c>0) std::cout<<'+';
if (p->c!=1 && p->c!=-1) std::cout<<p->c;
else if (p->c==-1) std::cout<<'-';
if (p->e<0) std::cout<<'/';
if (p->e!=0)
{
std::cout<<'x';
if (abs(p->e)!=1) std::cout<<'^'<<abs(p->e);
}
Print(p->next,false);
}
return;
}

Node *p;//存放结果的链表

int main()
{
int n,c,e;
p=new Node;
p->c=1;
p->e=0x7FFFFFFF;
p->next=new Node;
p->next->c=1;
p->next->e=0x80000000;//设置指数很大和很小的两项作哨

std::cin>>n;//读取多项式1
while (n--)
{
std::cin>>c>>e;
Insert(p,c,e);
}
std::cin>>n;//读取多项式2
while (n--)
{
std::cin>>c>>e;
Insert(p,c,e);
}
Print(p->next,true);
return 0;
}

⑶ 数据结构试题 求解 在线等 谢谢

1,CD 2,A 3,D 4,B 5,A, 6,A 7,B 8,C 怎么全是栈和队列的题啊

⑷ 3道数据结构编程题~~~

我只给你下思路,
1.你意思就是元素是按升序排的,可以先一个变量得到你顺序表的首地址,之后一直和你要插入的元素比较大小,找到适当的位置后,就可插入
(1)
#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100//表初始大小
typedef struct
{
int *elem;
int length;
}SqList; //顺序表的结构

int main()
{
int i,j,k;
SqList sheet; //这里为了简便直接赋值
sheet.elem = (int*)malloc(LIST_INIT_SIZE*sizeof(int));
sheet.elem[0] = 1;//赋值
sheet.elem[1] = 2;
sheet.elem[2] = 4;
sheet.length = 3;
//如现在要插入一个3的元素
i = 3;
for(j=0;j<sheet.length;++j)
if(sheet.elem[j]>=i)
break; //找到了便退出
for(k=sheet.length-1;k>=j;--k) //将元素向后移一位
{
sheet.elem[k+1] = sheet.elem[k];
}
sheet.elem[j] = i; //插入元素
for(k=0;k<4;++k)
printf("%d ",sheet.elem[k]);
return 0;
}

(2)这里是写个大概,具体要自己修改
#include<stdio.h>
#include<stdlib.h>

typedef struct LNode //单链结构
{
int elem;
struct LNode *next;
}LinkList;

int main()
{
int i;
LinkList *link,*link2,*link3,*temp,*temp2,*temp3;//为简便这也直接赋值
link = (LinkList*)malloc(sizeof(LinkList));
link2 = (LinkList*)malloc(sizeof(LinkList));
link3 = (LinkList*)malloc(sizeof(LinkList));

link->elem = 1; //链接起来
link->next = link2;
link2->elem = 2;
link2->next = link3;
link3->elem = 3;
link3->next = NULL;

//倒置
temp = link;
temp2 = link2;
temp3 = link3;
temp->next = NULL;

//这部分可放到循环中
while(1)
{
temp2->next = temp; //改变各结点的指向
temp = temp2;
if(temp3==NULL) break; //若这里temp3为空则要退出，具体为什么自己想想
temp2 = temp3;
temp3 = temp3->next;
}

for(i=0;i<3;++i)
{
printf("%d ",temp2->elem);
temp2 = temp2->next;
}

return 0;
}

第三题其实也差不多，时间关系我不能再写了，具体请你多看数据结构这本书，上面都有详细说明的。

⑸ 数据结构题求答案

题号:1 题型:是非题 本题分数:5
内容:
链表是一种采用链式存储结构存储的线性表。
1、 错
2、 对

标准答案:2
本题得分:5

题号:2 题型:是非题 本题分数:5
内容:
子串是主串中任意个连续字符组成的序列。
1、 错
2、 对

标准答案:1
学员答案:2
本题得分:0

题号:3 题型:是非题 本题分数:5
内容:
顺序存储是一种随机存取的数据结构。
1、 错
2、 对

标准答案:2
本题得分:0

题号:4 题型:是非题 本题分数:5
内容:
两个串相等的充要条件是串的长度相等和对应的字符相等。
1、 错
2、 对

标准答案:2
本题得分:5

题号:5 题型:是非题 本题分数:5
内容:
栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型的数据结构。
1、 错
2、 对

标准答案:2
本题得分:5

题号:6 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:D
本题得分:5

题号:7 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
设有两个串p和q，求q在p中首次出现的位置的运算称作()
A、求子串
B、串的复制
C、串的定位
D、串的比较

标准答案:C
本题得分:5

题号:8 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
以下哪一个不是队列的基本运算？
A、从队尾插入一个新元素
B、从队列中删除第i个元素
C、判断一个队列是否为空
D、读取队头元素的值

标准答案:D
本题得分:0

题号:9 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
队列中存取数据元素的原则是 ()
A、后进先出
B、先进先出
C、先进后出
D、随意进出

标准答案:B
本题得分:5

题号:10 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:D
本题得分:5

题号:11 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:D
本题得分:5

题号:12 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
若进栈序列为a, b, c，则通过入出栈操作可能得到的a, b, c的可能的出栈序列有()种。
A、4
B、5
C、6
D、7

标准答案:A
本题得分:5

题号:13 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:D
本题得分:0

题号:14 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:B
学员答案:B本题得分:5

题号:15 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:C
本题得分:0

题号:16 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
向一个有115个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动()个元素。
A、15
B、57.5
C、115
D、116

标准答案:B
本题得分:5

题号:17 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
以下对循环链表的叙述错误的是()
A、单链表和双向链表经首尾相接都可以形成循环链表
B、循环链表可以用头指针表示，也可以用尾指针表示
C、从循环链表的任何一个结点出发都能访问到表中的其他结点
D、构成循环链表需要增加存储空间

标准答案:D
本题得分:0

题号:18 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:D
本题得分:0

题号:19 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:

图形:

A、
B、
C、
D、

标准答案:D
本题得分:0

题号:20 题型:单选题（请在以下几个选项中选择唯一正确答案） 本题分数:5
内容:
对于只在表的首、尾进行插入操作的线性表，宜采用的存储结构为：()
A、顺序表
B、用头指针表示的单循环链表
C、用尾指针表示的单循环链表
D、单链表

标准答案:C
本题得分:0

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

⑺ 数据结构编程题

void quickpass(int r[], int s,int t)
{
int i=s, j=t, x=r[s];
while(i<j){
while (i<j &&r[j]>x) j=j-1; if (i<j) {r[i]=r[j];i=i+1;}
while (i<j && r[i]<x) i=i+1;if (i<j) {r[j]=r[i];j=j-1;}
}
r[i]=x;
}

⑻ 数据结构试题库

网络文库有好多呢，只要些积分就行了啊。
豆丁上面有更多，更专业的东西，但是需要掏钱，你自己选择着看看吧。
豆瓣有讨论组可以为你找到所有你想要的东西，但是得耐心的找相关的小组和人