数据结构导论作业一

1、章节作业

第一章概论

1．设计算法在整型数组A[n]中查找值为K的元素，若找到，则输出其位置i(0≤i≤n-1)，否则输出-1作为标志，并分析算法的时间复杂度。

int search (int A[],int n,int k)

{ int i;

i=0;

while (i<=n-1)

if (A[i]!=k) i++;

else break;

if (i<=n-1) return I;

else return -1；

}

当查找成功时，A[i]与k比较次数≤n；当查找不成功时，A[i]与k比较n次，所以，算法时间复杂度T(n)=O(n)。

2．写出计算方阵A[n][n]与B[n][n]乘积C[n][n]的算法，分析算法的时间复杂度。

void matrixmultiply (int A[][n],int B[][n],int C[][n],int n)

{ int I,j;

for (i=0;i

for (j=0;j

{ C[i][j]=0;

for (k=0;k

C[i][j]+=A[i][j]*B[k][j];

}

}

以方阵阶数n作为输出规模。可知第二层循环中的第一条赋值语句共执行n2次，第三层循环体中的乘法和赋值语句共执行n3次，所以此算法的计算量为n3+n2，算法时间复杂T(n)=O(n3)

第二章线性表

1．设带头结点的单链表的结点结构如下：

struct node { DataType data；

struct node *next；

} Node， *LinkList；

试编写一个函数int count(LinkList head，DataType x)统计单链表中数据域为x的结点个数。

int count(LinkList head,DataType x)

{

LinkList p=head->next;

Int m=0;

while (p!=NULL)

{ if(p->data==x) m++;

p=p->next;

}

return m;

}

2．试分别以顺序表和带头结点的单链表作存储结构，各写一个实现线性表的就地(即使用尽可能少的附加空间)逆置的算法，在原表的存储空间内将线性表

(a

1，a

2

，…，a

n

)逆置为(a

n

，a

n-1

，…，a

1

)。

顺序表逆置算法

void inverse_sqlist(Seqlist L) {

int m,n,k;

DataType temp;

m=0; n=L.length-1;

while (m

{ temp=L.data[m];

L.data[m]=L.data[n];

L.data[n]=temp;

m++;

n--;

}

}

带头结点的单链表的逆置算法reverse_2(LinkList head)

{

LinkList p,q;

p=head->next;

head->next=NULL;

while (p!=NULL)

{

q=p->next;

p->next=head->next;

head->next=p;

p=q;

}

}

第三章栈、队列和数组

1．有一个整数序列，其输入顺序为20，30，90，-10，45，78，试利用栈将其输出序列改变为30，-10，45，90，78，20，试给出该整数序列进栈和出栈的操作步骤。(用push(x)表示x进栈，pop(x)表示x出栈)

push(20),push(30),pop(30),push(90),push(-10),pop(-10),push(45),pop(45 ),pop(90),push(78),pop(78),pop(20)

2．设有编号为1，2，3，4的四辆列车，顺序进入一个栈式结构的站台，试写出这四辆列车开出车站的所有可能的顺序。

一号列车先出站：1234,1243,1324,1342,1432;

二号列车先出站：2134,2143,2314,2341,2431；

三好列车先出站：3214,3241,3421；

四号列车先出站：4321；

但是这里的 4123、4132、4213、4231都不是正解,所以共有14种可能

3．假设以带头结点的循环链表表示队列，并且只设一个指针指向队列尾结点(注意不设头指针)，试编写相应的初始化队列、入队列和出队列算法。

类型定义：

typedef struct linksd_queue

{

DataType data;

struct linked_queue *next;

} LqueueTp;

队列的初始化

void InitQueue(LqueueTp *rear)

{ LqueueTp *p;

p=(LqueueTp *)malloc(sizeof(LqueueTp)); rear=p;

rear->next=rear;

}

入队列

void EnQueue(LqueueTp *rear;DataType x) { LqueueTp *p;

p=(LqueueTp*)malloc(sizeof(LqueueTp)); p->data=x;

p->next=rear->next;

rear->next=p;

rear=p

}

出队列

OutQueue(LqueueTp *rear,DataType *x) { LqueueTp *h,*p ;

if (rear==rear->next)

{ error; return 0; }

else {

h=rear->next;

p=h->next;

*x=p->data;

h->next=p->next;

if (p==rear)rear=h;

free(p);

return 1;

}

}

4．假设以数组cycque[m]存放循环队列的元素，同时设变量rear和quelen分别指示循环队列中队列尾元素位置和内含元素的个数。试给出此循环队列的队列满和队列空的条件，并写出相应的入队列和出队列的算法。

类型定义：

typedef struct cycqueue

{

DataType data[m];

int rear;

int quelen;

} CycqueueTp;

CycqueueTp *cq

队列满条件是：（cq->quelen==m）。

队列空条件是：（cq->quelen==0）

入队列：

int EnCycQueue(CycqueueTp *cq;DataType x)

{

if (cq->quelen==m)

{ error; return 0;}

else {

cq->rear=(cq->rear+1)%m;

cq->data[cq->rear]=x;

cq->quelen=cq->quelen+1;

return 1;

}

}

出队列：

int OutCyQueue(CycqueueTp *cq)

{

if (cq->quelen==0)

{ error; return 0;}

else {

cq->quelen=cq->quelen-1;

*x=cq->data[(cq->rear+m-cq->quelen)% m]; return 1;

}

}

取队列首元素：

DataType GetHead(CycqueueTp *cq)

{ DataType x;

x=cq->data[cq->rear=m-cq->quelen]% m];

return x;

}

第四章树和二叉树

1．算法设计题

(1)以二叉链表作存储结构，试编写求二叉树叶子结点个数的算法。typedef struct btnode

{ DataType data;

struct btnode *lchild,*rchild;

}*BinTree;

int leafnode_num(BinTree bt )

{

if (bt==NULL) return 0 ;

else

if (bt->lchild==NULL) && （bt->rchild==NULL）

return 1;

else

return leafnode_num (bt->lchild)+leafnode_num (bt->rchild); }

(2)设计算法求二叉树的结点的个数。

typedef struct btnode

{DataType data;

struct btnode *lchild,*rchild;

}*BinTree;

int node_num (BinTree bt)

{

if (bt==NULL) return 0;

else

return node_num(bt->lchild)+node_num(bt->rchild)+1;

}

(3)设计算法按先序次序打印二叉树T中叶子结点的值。typedef struct btnode

{ int data;

struct btnode *lchild,*rchild;

}*BinTree;

void preorder (BinTree bt)

{ if (bt!=NULL)

{ if ((bt->lchild==NULL) && （bt->rchild==NULL）)

printf(“%d”,bt->dta);

preorder(bt->lchild);

preorder(bt->rchild);

}

}

2．树的存储结构采用孩子兄弟链表，试编写树的按层次遍历算法typedef struct tnode

{ int data;

struct tnode *son,*brother;

}*Tree;

void tree_travel (Tree root )

{ InitQueue(Q);

if (root1=NULL)

{ EnQueue( q , root );

while (!EmptyQueue(Q))

{ p=GetHead(Q);

OutQueue (Q);

prinf(“%d” , p->data);

p=p->son;

while (p!=NULL)

{ Enqueue (Q , p);

p=p->brother;

}

}

}

}

第五章图

1．求下列有向图中从顶点v o到其余各顶点的最短路径及长度(给出求解的过程)。

2．写出将一个无向图的邻接矩阵转换成邻接表的算法。#define vnum 20

typedef struct graph

{ VertexType vexs[vnum];

int arcs[vnum][vnum];

int vexnum,arcnum;

} GraphTp_Mat;

typedef struct arcnode

{int adjvex;

struct arcnode *nextarc;

} ArcNodeTp;

typedef struct vexnode

{ int vertex;

ArcNodeTp *firstarc;

AdjLis[vnum];

typedef struct graph

{ AdjLis adjlist;

int vexnum,arcnum;

} GraphTp_Adj;

void Matrix_to_Adjlis(GraphTp_Mat *ga,GraphTp_Adj *gp) { int I,j;

ArcNodeTp *p;

gp->vexnum=ga->vexnum;

gp->arcnum=ga->arcnum;

for ( i =0;Ivexnum;i++)

{ gp->adjlis[i].vertex=I;

gp->adjlis[i].firstarc=NULL;

}

for (i=0;Ivexnum;i++)

for (j=0;jvesnum;j++)

if (ga->arcs[i][j]==1)

}

p=(ArcNodeTp *)malloc(sizeof(ArcNodeTp));

p->adjvex=j;

p->nextarc=ga->adjlis[i].firstarc;

ga->adjlis[i].firstarc=p;

}

}

第六章查找

1．假设线性表中结点是按键值递增的顺序排列，试写一顺序查找算法，将岗哨设在高下标端。然后分别求出等概率情况下查找成功和不成功时的平均查找长度。

int search_sqtable(Sqtable R,KeyType k)

{

int i=0;

R. elem [R.n].key=k;

while (R. elem [i].key

if (R. elem [i].key>k‖i==R.n) return -1;

else return i;

}

2．试编写算法求键值为k结点在给定的二叉排序树中所在的层数。

int level_count(BinTree bst,KeyType k)

{

int lev=0;

BSTNode *p=bst;

while (p!=NULL)

{

lev++;

if (p->data==k) return lev;

if (p->data

p=p->rchild;

else

p=p->lchild;

}

return 0;

}

3．试写出从大到小输出二叉排序树中所有不小于x的元素的算法。

void Print_NLT(BinTree T,int x)

{

if (T!=NULL)

{

Print_NLT(T->rchild,x);

If (T->data>=x)

printf(“%d\n”,T->data);

Print_NLT(T->lchild,x);

}

}

第七章排序

1．对于给定的一组键值：83，40，63，13，84，35，96，57，39，79，6l，15，分别画出应用直接插入排序、直接选择排序、冒泡排序、归并排序对上述序列进行排序过程。

直接插入排序序：

[40 83] 63 13 84 35 96 57 39 79 61 15 [40 63 83] 13 84 35 96 57 39 79 61 15 [13 40 63 83] 84 35 96 57 39 79 61 15 [13 40 63 83 84] 35 96 57 39 79 61 15 [13 35 40 63 83 84] 96 57 39 79 61 15 [13 35 40 63 83 84 96] 57 39 79 61 15 [13 35 40 57 63 83 84 96] 39 79 61 15 [13 35 39 40 57 63 83 84 96] 79 61 15 [13 35 39 40 57 63 79 83 84 96] 61 15 [13 35 39 40 57 61 63 79 83 84 96] 15 [13 15 35 39 40 57 61 63 79 83 84 96]

直接选择排序:

[84 40 63 13 84 35 96 57 39 79 61 15] 13 [40 63 83 84 35 96 57 39 79 61 15] 13 15 [63 83 84 35 96 57 39 79 61 40] 13 15 35 [83 84 63 96 57 39 79 61 40] 13 15 35 39 [84 63 96 57 83 79 61 40] 13 15 35 39 40 [63 96 57 83 79 61 84] 13 15 35 39 40 57 [96 63 83 79 61 84] 13 15 35 39 40 57 [61 63 83 79 96 84]

13 15 35 39 40 57 61 63 [83 79 96 84]

13 15 35 39 40 57 61 63 79 [83 96 84]

13 15 35 39 40 57 61 63 79 83 [96 84]

13 15 35 39 40 57 61 63 79 83 84 [96]

冒泡排序：

初始数据：25 11 22 34 5 44 76 61 100 3 14 120

第1趟结果：[11 22 25 5 34 44 61 76 3 14 100] 120

第2趟结果：[11 22 5 25 34 44 61 3 14 76] 100 120

第3趟结果：[5 5 22 25 34 44 3 14 61] 76 100 120

第4趟结果：[5 11 22 25 34 3 14 44] 61 76 100 120

第5趟结果：[5 11 22 25 3 14 34] 44 61 76 100 120

第6趟结果：[5 11 22 3 14 25] 34 44 61 76 100 120

第7趟结果：[5 11 3 14 22] 25 34 44 61 76 100 120

第8趟结果：[5 3 11 14] 22 25 34 44 61 76 100 120

第9趟结果：[3 5 11] 14 22 25 34 44 61 76 100 120

第10趟结果：3 5 11 14 22 25 34 44 61 76 100 120

归并排序：

[83] [40] [63] [13] [84] [35] [96] [57] [39] [79] [61] [15]

[40 83] [13 63] [35 84] [57 96] [39 79] [15 61]

[13 40 63 83] [35 57 84 96] [15 39 61 79]

[13 35 40 57 63 83 84 96] [15 39 61 79]

[13 15 35 39 40 57 61 63 79 83 84 69]

2．若对序列(tang，deng，an，wan，shi，bai，fang，liu)按字典顺序进行排序，分别写出：

①冒泡排序第一趟的结果；

deng an tang shi bai fang liu wan

②以第一个元素为分界的快速排序第一趟的结果；

liu deng an liu bai fang tang wan

③堆排序时的初始堆。

3．对如下关键字序列(3，8，85，12，37，50)按堆排序算法进行从小到大排序，要求画出排序全过程的示意图。

重建堆

输出

8 ，37与8交换

输出12 ，12与

85交换

重建堆

输出37,37与

50交换 重建堆

输出85

输出50,50与85交换

排序结果：3 8 12 37 50 85

4．举例说明排序章介绍的各排序方法中哪些是不稳定的?

不稳定排序：快速排序直接选择排序堆排序

例：快速排序

初始状态40 65 38 49 97 65 13 60

排序后13 38 40 49 60 65 65 97 堆排序

初始状态65 38 75 97 80 13 27 65

排序后13 27 38 65 65 75 80 97 直接排序

初始状态40 65 38 49 97 65 13 60

排序后13 38 40 49 60 65 65 97