数据结构c语言版大题

❶ 关于数据结构c语言版的习题问题

树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构，很象自然界中的树那样。树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树形象表示。树在计算机领域中也得到广泛应用，如在编译源程序如下时，可用树表示源源程序如下的语法结构。又如在数据库系统中，树型结构也是信息的重要组织形式之一。一切具有层次关系的问题都可用树来描述。一、树的概述树结构的特点是：它的每一个结点都可以有不止一个直接后继，除根结点外的所有结点都有且只有一个直接前趋。以下具体地给出树的定义及树的数据结构表示。（一）树的定义树是由一个或多个结点组成的有限集合，其中： ⒈必有一个特定的称为根(ROOT)的结点；

⒉剩下的结点被分成n>=0个互不相交的集合T1、T2、......Tn，而且， 这些集合的每一个又都是树。树T1、T2、......Tn被称作根的子树(Subtree)。

树的递归定义如下：（1）至少有一个结点（称为根）（2）其它是互不相交的子树

1.树的度——也即是宽度，简单地说，就是结点的分支数。以组成该树各结点中最大的度作为该树的度，如上图的树，其度为3;树中度为零的结点称为叶结点或终端结点。树中度不为零的结点称为分枝结点或非终端结点。除根结点外的分枝结点统称为内部结点。

2.树的深度——组成该树各结点的最大层次，如上图，其深度为4；

3.森林——指若干棵互不相交的树的集合，如上图，去掉根结点A，其原来的二棵子树T1、T2、T3的集合{T1,T2,T3}就为森林；

4.有序树——指树中同层结点从左到右有次序排列，它们之间的次序不能互换，这样的树称为有序树，否则称为无序树。

5.树的表示

树的表示方法有许多，常用的方法是用括号：先将根结点放入一对圆括号中，然后把它的子树由左至右的顺序放入括号中，而对子树也采用同样的方法处理；同层子树与它的根结点用圆括号括起来，同层子树之间用逗号隔开，最后用闭括号括起来。如上图可写成如下形式：
(A(B(E(K,L),F),C(G),D(H(M),I,J)))

二叉树

1.二叉树的基本形态：

二叉树也是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态：

(1)空二叉树——(a)；

(2)只有一个根结点的二叉树——(b)；

(3)右子树为空的二叉树——(c)；

(4)左子树为空的二叉树——(d)；

(5)完全二叉树——(e)

注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。

2.两个重要的概念：

(1)完全二叉树——只有最下面的两层结点度小于2，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树；

(2)满二叉树——除了叶结点外每一个结点都有左右子女且叶结点都处在最底层的二叉树,。

3.二叉树的性质

(1) 在二叉树中，第i层的结点总数不超过2^(i-1)；

(2) 深度为h的二叉树最多有2h-1个结点(h>=1)，最少有h个结点；

(3) 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，

则N0=N2+1；

(4) 具有n个结点的完全二叉树的深度为int（log2n）+1

(5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：

若I为结点编号则 如果I<>1，则其父结点的编号为I/2；

如果2*I<=N，则其左儿子（即左子树的根结点）的编号为2*I；若2*I>N，则无左儿子；

如果2*I+1<=N，则其右儿子的结点编号为2*I+1；若2*I+1>N，则无右儿子。

4.二叉树的存储结构：

(1）顺序存储方式

type node=record

data:datatype

l,r:integer;

end;

var tr:array[1..n] of node;

(2)链表存储方式，如：

type btree=^node；

node=record

data:datatye;

lchild,rchild:btree;

end;

5.普通树转换成二叉树：凡是兄弟就用线连起来，然后去掉父亲到儿子的连线，只留下父母到其第一个子女的连线。

//////////////////////////////////////////////////////
2.
基于顺序结构的顺序查找算法

(1)类型说明

typedef struct{

KeyType key;

InfoType otherinfo; //此类型依赖于应用

}NodeType;

typedef NodeType SeqList[n+1]; //0号单元用作哨兵

(2)具体算法

int SeqSearch(Seqlist R，KeyType K)

{ //在顺序表R[1..n]中顺序查找关键字为K的结点，

//成功时返回找到的结点位置，失败时返回0

int i;

R[0].key=K; //设置哨兵

for(i=n;R[i].key!=K;i--); //从表后往前找

return i; //若i为0，表示查找失败，否则R[i]是要找的结点

} //SeqSearch

❷ c语言编程 数据结构题

(⊙o⊙)…我昨天看到了，写完代码之后找不到问题了

。一会儿回去把代码贴上来。

给你参考参考:

/*
*Filename:main.c
*/
#include<stdio.h>
#include"queue.h"

intmain(void){

	inti;
	queueque;
	/*
	*创建一个大小为10的队列，对队列进行入队，出队操作
	*/
	que=create_queue(10);
	for(i=0;i<10;i++){
		in_queue(que,i);
	}
	for(i=0;i<5;i++){

		printf("%d	",out_queue(que));
	}
	printf("
队列是否为空?");
	if(is_empty(que)){

		printf("TRUE
");
	}else{

		printf("FALSE
将队列置空
");
		set_queue_empty(que);
	}
	if(is_empty(que)){

		printf("队列为空
");
	}
	
	free_queue(que);
	return0;
}
/*
*Filename:queue.c
*/
#include"queue.h"
#include<stdlib.h>

/*
*创建大小为size的循环队列
*/
queuecreate_queue(size_tsize){

	q_valuetemp=NULL;
	queueque=NULL;
	/*
	*创建队列指针
	*/
	que=(queue)malloc(sizeof(struct_queue));
	que->size=size;
	/*
	*创建队列值，初始化为-1
	*/
	que->rear=(q_value)malloc(sizeof(struct_que_value));
	que->rear->value=-1;
	temp=que->rear;

	while(--size){

		que->front=(q_value)malloc(sizeof(struct_que_value));
		que->front->next=temp;
		que->front->value=-1;
		temp=que->front;
	}
	/*
	*头尾相连成为循环队列
	*/
	que->rear->next=que->front;
	que->rear=que->front;
	returnque;
}
/*
*将队列设置为空
*/
voidset_queue_empty(queueque){

	while(que->front!=que->rear){

		que->rear->value=-1;
		que->rear=que->rear->next;
	}
	que->front->value=-1;
	que->front=que->rear;
}
/*
*判断队列是否为空
*/
_boolis_empty(queueque){

	if(que->front==que->rear&&
		que->front->value==-1)
		returnTRUE;
	returnFALSE;
}
/*
*判断队列是否为满了
*/
_boolis_full(queueque){

	if(que->front==que->rear&&
		que->front->value!=-1)
		returnTRUE;
	returnFALSE;
}
/*
*出队,出队之后的位置用-1标记
*/
intout_queue(queueque){

	intvalue=que->rear->value;
	/*
	*如果队列为空则返回-1
	*/
	/*
	if(is_empty(que)){

		printf("队列为空
");
		return-1;
	}
	*/
	que->rear->value=-1;
	que->rear=que->rear->next;
	returnvalue;
}
/*
*入队
*/
voidin_queue(queueque,intvalue){

	/*
	*如果队列满则不能入队
	*/
	/*
	if(is_full(que)){

		printf("队列已满
");
		return;
	}
	*/
	que->front->value=value;
	que->front=que->front->next;
}
/*
*释放队列
*/
voidfree_queue(queueque){

	q_valuetemp=que->front->next;

	while((que->size)--){

		free(que->front);
		que->front=temp;
		temp=temp->next;
	}
	free(que);
}
/*
*Filename:queue.h
*/
#ifndef_QUEUE_H_
#define_QUEUE_H_

#include<stdio.h>

typedefint_bool;
#defineFALSE(0)
#defineTRUE(1)

typedefstruct_que_value*q_value;
typedefstruct_queue*queue;

struct_que_value{

	intvalue;
	q_valuenext;
};
struct_queue{

	size_tsize;
	q_valuefront;
	q_valuerear;
};

queuecreate_queue(size_tsize);
voidfree_queue(queueque);
voidset_queue_empty(queueque);
_boolis_empty(queueque);
_boolis_full(queueque);
voidin_queue(queueque,intvalue);
intout_queue(queueque);

#endif

❸ 一个大二的数据结构C语言的实验题

就一个栈+一个队列。

停车场就是一个栈，先进后出，

中间的车出栈的话让其前面的车依次入到另一个临时栈，这个要出去的车出栈后，再把另一个临时栈的元素依次入到这个停车场的栈。

等待入停车场的车是一个队列。先进先出（有车来添加到队列尾部，停车场的栈有空位，从队列头部取）。

下面是停车场的类定义

1. struct NODE

2. {

3. unsigned int CarID;

4. unsigned int EnterTime;

5. };

6. 
   

7. class CCarStation

8. {

9. public:

10. CCarStation(int size)

11. :

12. m_Size(size){}

13. 
    

14. void CheckStation()//检查栈中有空位 从queue中取一个car，构造一个NODE 加入栈，

15. {

16. if (m_station.size() < m_Size && m_waitCar.size() > 0)

17. {

18. NODE* carInfo = new NODE;

19. carInfo->CarID = m_waitCar.front();

20. carInfo->EnterTime = time(NULL);

21. m_station.push(carInfo);

22. m_waitCar.pop();

23. }

24. }

25. bool EnterStation(int CarID)

26. {

27. m_waitCar.push(CarID);

28. CheckStation();

29. }

30. void LeaveStation(int CarID)

31. {

32. stack<NODE*> temp;

33. while (!m_station.empty())

34. {

35. NODE* carInfo = m_station.top();

36. m_station.pop();

37. 
    

38. if (carInfo->CarID == CarID)

39. {

40. //根据时长，在这里收费。

41. int stayedTime = time(NULL) - carInfo->EnterTime;

42. 
    

43. delete carInfo;

44. }

45. else

46. {

47. temp.push(carInfo);

48. }

49. }

50. while (!temp.empty())

51. {

52. m_station.push(temp.top());

53. temp.pop();

54. }

55. CheckStation();

56. }

57. private:

58. int m_Size;

59. stack<NODE*> m_station;

60. queue<int> m_waitCar;

61. CCarStation(){};

62. };

❹ 数据结构的一些题目（C语言）

1.
int lenth(LNode * head)
{
LNode *p;
int i
p=head;
while(p)
{
++i;
p=p->next;
}
return i;
}

2.
int max(LNode * head)
{
LNode *p;
LNode *q;
elemtype maxelem;//具体的数据类型我不知道，所以用了elemtype
p=head;
maxelem=p->data;
while(p)
{

p=p->next;
if(p->data > maxekem)
{
maxelem=p->data;
q=p; /*将最大的位置记录下来*/
}
p=head;
while(p!=q)
{
p=p->next;
++i; /*找到最大值的位子，并记录是第几个节点*/
}

return i; /*在一个函数中只能有一个返回值，最大值你可以打印出来，这里我就不写了*/
}
}

3、
int inset_after(LNode *head,x,y)
{
LNode *p;
LNode *q;
p=head;
while(p && p->data!=x)
p=p->next;
if(!p) return 0;//没有找到
q=(LNode *)malloc(sizeof(LNode))
q->data=y;
q->next=p->next;
p->next=q;
return 1;//找到
}
4、int merge(LNode *L)
{
LNode *p;
LNode *q;
int i;
q=L;
p=create();
p->next=p->next->next;//去除头结点
i=5
while(q && i<0) //如果要插入的带头结点的链表的话，是i<=0
{ q=q->next;
i--;
｝
if(!p) return 0;//要插入的链表的结点数小于5，退出，返回0

}

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

第一个问题，分析下要求，可以知道要做的事情是合并两个数组到一个数组里去，数组C的长度是AB之和。表C的第一个字符不是A的第一个字符就是B的第一个字符。因此接下来要做的事情就是做一个长度为AB之和的循环，每一次找出A或B中的最小元素，存到C里面去，循环结束，C就自动有了。

第二个问题，有时间和空间的要求，不太容易，只有更好，没有最好。不过提供一个思路。可以首先扫描整个数列，将奇数偶数的位置和个数标注出来，存在一个数列中。例如数列奇 奇 偶 奇 奇，可以得到奇数个数为4，位置为[0,1,3,4]，偶数为1，位置为[2]，因此要生成的数列中前4个必定为奇数，而题目中没有对大小的要求，因此只用将偶数与最后面的奇数对换位置即可。对换的次数即为偶数的个数。

大概思路如此，不过有很多方法可以高效的存储和计算，具体实现，希望你能亲自琢磨下，还可以巩固一下C技巧。
祝好，有问题可以探讨。

❻ 关于数据结构（C语言）的几个题

1.

voidconverse(intn,intd){
SqStackS;//新建一个栈
InitStack(S);//初始化栈
intk,e;
while(n>0){
k=n%d;
push(S,k);
n=n/d;
}//将余数进栈
while(S.top!=S.base){
pop(S,e);
printf("%1d",e);
}//输出结果
}

8.

先序遍历：ABCDEF

中序遍历：BCDAFE

后序遍历：DCBFEA

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

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

❽ C语言数据结构题

基础定义

如果需要PPT讲解，私信我

❾ 求助数据结构题用C语言做

1: 因为要删除那些即在B表又在C表中的元素，所以A,B，C三个表中都会有这个元素。那么用指针遍历A表，用另外两个指针遍历B,C。查找B,C中同A的元素，因为3个表都是有序的，可以采用些简单的比较。找到后删除。
2：void AE(stack &s)
{
int stack (s); //得到传递过来的栈
push(s,3); // 3进栈
push(s,4); // 4进栈
int x=pop(s)+2*pop(s); // x = 3 + 2 * 4
push(s,x); // x 进栈
int a[5]={2,5,8,22,15};
for(j=0;j<5;j++)
push(s,a[i]) // A数组进栈
while(!stackempty(s)) // 直到栈空
printf("%d",2*pop(s)); //输出 2*栈中每个元素

结果自己想了。