南审《数据结构课程教学设计》个人说明任务题目一览度版.docx

南审《数据结构课程教学设计》个人说明任务题目一览度版.docx

《南审《数据结构课程教学设计》个人说明任务题目一览度版.docx》由会员分享，可在线阅读，更多相关《南审《数据结构课程教学设计》个人说明任务题目一览度版.docx（19页珍藏版）》请在冰豆网上搜索。

南审《数据结构课程教学设计》个人说明任务题目一览度版

第二章线性表

顺序表的操作

1、顺序表的建立（从键盘或者数组中导入数据）

StatusInitList（SqList&L）

{//构造一个空的顺序表

L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;

if（!

L.elem）

exit（OVERFLOW）;

L.length=0;

L.listsize=LIST_INIT_SIZE;

returnOK;

}

2、顺序表按照值查找位置

intLocateElem（SqListL,ElemTypee）

{//根据数据元素的值，返回它在线性表L中的位置

inti=0;

while（（i<=L.length）&&（*（L.elem+i-1）!

=e））

i++;

if（i<=L.length）

returni;

else

return（-1）;

}

3、顺序表按照序号查找元素的值

StatusGetElem（SqListL,inti,ElemType&e）

{//根据数据元素在线性表L中的位置，返回它的值

if（i<1||i>L.length）

returnERROR;

e=*（L.elem+i-1）;

returnOK;

}

4、顺序表数据元素的插入

StatusListInsert（SqList&L,inti,ElemTypee）

{//在L中第i个位置之前插入新的数据元素e，L的长度加1

ElemType*p,*q,*newbase;

if（i<1||i>L.length+1）

returnERROR;

if（L.length>=L.listsize）

{newbase=（ElemType*）realloc（L.elem,

（L.listsize+LISTINCREMENT）*sizeof（ElemType））;

if（!

newbase）exit（OVERFLOW）;

L.elem=newbase;

L.listsize+=LISTINCREMENT;

}

q=&（L.elem[i-1]）;

for（p=&（L.elem[L.length-1]）;p>=q;--p）

*（p+1）=*p;

*q=e;

++L.length;

returnOK;

}

5、顺序表数据元素的删除

StatusListDelete（SqList&L,inti,ElemType&e）

{//删除L的第i个数据元素，并用e返回其值，L的长度减1

ElemType*q,*p;

if（i<1||i>L.length）

returnERROR;

p=&（L.elem[i-1]）;

e=*p;

q=L.elem+L.length-1;

for（++p;p<=q;++p）*（p-1）=*p;

--L.length;

returnOK;

}

6、顺序表数据元素的输出

Statusvisit（SqListL）

{//按序输出顺序表的各个元素值

inti;

for（i=1;i<=L.length;i++）

printf（"%d",*（L.elem+i-1））;

cout<

printf（"L.elem=%uL.length=%dL.listsize=%d\n",L.elem,L.length,L.listsize）;

returnOK;

}

单链表的操作

1、单链表的建立

voidCreateList（LinkList&L,intn）

{//逆位序输入n个元素的值，建立带表头结构的单链线性表L

inti;

LinkListp;

L=（LinkList）malloc（sizeof（LNode））;

L->next=NULL;

printf（"请输入%d个数据\n",n）;

for（i=n;i>0;--i）

{

p=（LinkList）malloc（sizeof（LNode））;

scanf（"%d",&p->data）;

p->next=L->next;

L->next=p;

}

}

voidCreateList2（LinkList&L,intn）

{//正位序输入n个元素的值，建立带表头结构的单链线性表

inti;

LinkListp,q;

L=（LinkList）malloc（sizeof（LNode））;

L->next=NULL;

q=L;

printf（"请输入%d个数据\n",n）;

for（i=1;i<=n;i++）

{

p=（LinkList）malloc（sizeof（LNode））;

scanf（"%d",&p->data）;

q->next=p;

q=q->next;

}

p->next=NULL;

}

2、单链表的输出

Statusvisit（LinkListL）

{//按序输出单链表的各个元素值

LinkListp=L->next;

while（p）

{

printf（"%d",p->data）;

p=p->next;

}

printf（"\n"）;

returnOK;

}

3、单链表结点的插入

StatusListInsert（LinkList&L,inti,ElemTypee）

{

LinkListp,s;p=L;intj=0;

while（p&&j

{p=p->next;

++j;

}

if（!

p||j>i-1）returnERROR;

s=（LinkList）malloc（sizeof（LNode））;

s->data=e;s->next=p->next;

p->next=s;

returnOK;

}

4、单链表结点的删除

StatusListDelete（LinkList&L,inti,ElemTypee）

{

LinkListp,q;p=L;

intj=0;

while（p->next&&j

{p=p->next;

++j;

}

if（!

（p->next）||j>i-1）returnERROR;

q=p->next;p->next=q->next;

e=q->data;free（q）;

returnOK;

}

5、单链表中按照结点的值查找结点的位序

intLocateElem（LinkListL,ElemTypee）

{//返回L中第1个值为e的数据元素的位序，若这样的数据元素不存在,则返回值为0

inti=0;

LinkListp=L->next;

while（p）

{i++;

if（p->data==e）

returni;

p=p->next;

}

return0;

}

6、单链表中按照结点的位序返回结点的值

StatusGetElem（LinkListL,inti,ElemType&e）

{//L为带头结点的单链表的头指针。

当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR

intj=1;

LinkListp=L->next;

while（p&&j

{

p=p->next;

j++;

}

if（!

p||j>i）

returnERROR;

e=p->data;

returnOK;

}

7、单链表的初始化（新建一个只含头结点的单链表）

StatusInitList（LinkList&L）

{//构造一个空的单链表L

L=（LinkList）malloc（sizeof（LNode））;

if（!

L）

exit（OVERFLOW）;

L->next=NULL;

returnOK;

}

8、单链表的销毁（所有结点都要销毁）

StatusDestroyList（LinkList&L）

{//销毁单链表L

LinkListq;

while（L）{

q=L->next;

free（L）;

L=q;

}

returnOK;

}

9、求单链表的长度

intListLength（LinkListL）

{//返回L中数据元素个数

if（L==0）

return0;

inti=0;

LinkListp=L->next;

while（p）

{i++;

p=p->next;

}

returni;

}

10、两个单链表的归并

voidMergeList（LinkList&La,LinkList&Lb,LinkList&Lc）

{//已知线性表La和Lb中的数据元素按值非递减排列

//归并La和Lb得到新的线性表Lc,Lc的数据元素也按值非递减排列

LinkListpa,pb,pc;

pa=La->next;pb=Lb->next;

Lc=pc=La;

while（pa&&pb）

{

if（pa->data<=pb->data）

{pc->next=pa;

pc=pa;

pa=pa->next;

}

else{pc->next=pb;

pc=pb;

pb=pb->next;}

}

pc->next=pa?

pa:

pb;

free（Lb）;

}

第三章栈和队列

栈的操作

1、初始化一个顺序栈（从键盘或者数组中导入数据）

StatusInitStack（SqStack&S）

{

S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;

if（!

S.base）exit（OVERFLOW）;

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

returnOK;

}

2、判断栈是否为空

StatusStackEmpty（SqStackS）

{//若栈S为空栈，则返回TRUE；否则返回FALSE

if（S.top==S.base）returnTRUE;

elsereturnFALSE;

}

3、取栈顶元素

StatusGetTop（SqStackS,SElemType&e）//在教科书第47页

{//若栈S不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR

if（S.top==S.base）returnERROR;

e=*（S.top-1）;

returnOK;

}

4、元素进栈

StatusPush（SqStack&S,SElemTypee）

{//插入元素e为栈S新的栈顶元素。

if（S.top-S.base>=S.stacksize）

{S.base=（SElemType*）realloc（S.base,

（S.stacksize+STACK_INCREMENT）*sizeof（SElemType））;

if（!

S.base）exit（OVERFLOW）;

S.top=S.base+S.stacksize;

}S.stacksize+=STACK_INCREMENT;

*S.top++=e;

returnOK;

}

5、元素出栈

StatusPop（SqStack&S,SElemType&e）//在教科书第47页

{//若栈S不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

if（S.top==S.base）returnERROR;

e=*--S.top;

returnOK;

}

6、计算栈中数据元素的个数

intStackLength（SqStackS）

{//返回栈S的元素个数，即栈的长度

returnS.top-S.base;

}

递归

1、递归实现阶乘

intf（intn）

{

if（n==0）return1;

elsereturn（n*f（n-1））;

}

2、递归实现链表的输出（正序、逆序）

voidRevPrint（LNode*head）

{

if（NULL!

=head）

{

if（NULL!

=head->next）

{

RevPrint（head->next）;

}

printf（"%d\t",head->data）;

}

}//逆序后输出

voidPrintList_L（LinkListL）

{

if（L!

=NULL）

{

printf（"%d\t",L->data）;

PrintList_L（L->next）;

}

}//正序输出

3、递归实现链表的逆序

LinkListreverse（LinkListp）

{

LinkListq,h;

if（p->next==NULL）returnp;

else

{

q=p->next;

h=reverse（q）;

q->next=p;

p->next=NULL;

returnh;

}

}

4、递归求链表的长度

intListLength（LinkListL）

{intlen;

if（!

L）return0;

len=1+ListLength（L->next）;

returnlen;

}

第六章树和二叉树

二叉树的操作（采用二叉链式存储）

1、二叉树的建立

StatusCreateBiTree（BiTree&T）

{//算法6.4：

按先序次序输入二叉树中结点的值（可为字符型或整型，在主程中定义），

charch;

scanf（"%c",&ch）;

if（ch==''）T=NULL;

else

{

if（!

（T=（BiTNode*）malloc（sizeof（BiTNode））））exit（OVERFLOW）;

T->data=ch;

CreateBiTree（T->lchild）;

CreateBiTree（T->rchild）;

}

returnOK;

}

2、二叉树的遍历（四种）

StatusPreOrderTraverse（BiTreeT,void（*Visit）（TElemType））

{//初始条件：

二叉树T存在，Visit是对结点操作的应用函数。

修改算法6.1

//操作结果：

先序递归遍历T，对每个结点调用函数Visit一次且仅一次

if（T）

{

Visit（T->data）;

if（PreOrderTraverse（T->lchild,Visit））

if（PreOrderTraverse（T->rchild,Visit））

returnOK;

}

elsereturnOK;

}

StatusInOrderTraverse（BiTreeT,void（*Visit）（TElemType））

{//初始条件：

二叉树T存在，Visit是对结点操作的应用函数

//操作结果：

中序递归遍历T，对每个结点调用函数Visit一次且仅一次

if（T）

{

InOrderTraverse（T->lchild,Visit）;

Visit（T->data）;

if（InOrderTraverse（T->rchild,Visit））

returnOK;

}

elsereturnOK;

}

StatusPostOrderTraverse（BiTreeT,void（*Visit）（TElemType））

{//初始条件：

二叉树T存在，Visit是对结点操作的应用函数

//操作结果：

后序递归遍历T，对每个结点调用函数Visit一次且仅一次

if（T）

{

PostOrderTraverse（T->lchild,Visit）;

if（PostOrderTraverse（T->rchild,Visit））

Visit（T->data）;

returnOK;

}

elsereturnOK;

}

StatusLevelOrderTraverse（BiTreeT,void（*Visit）（TElemType））

{//初始条件：

二叉树T存在，Visit是对结点操作的应用函数

//操作结果：

层序递归遍历T（利用队列），对每个结点调用函数Visit一次且仅一次

LinkQueueq;

QElemTypea;

if（T）

{InitQueue（q）;

EnQueue（q,T）;

while（!

QueueEmpty（q））

{DeQueue（q,a）;

Visit（a->data）;

if（a->lchild!

=NULL）

EnQueue（q,a->lchild）;

if（a->rchild!

=NULL）

EnQueue（q,a->rchild）;

}

printf（"\n"）;

}

returnOK;

}

3、求二叉树高度

intTreeDepth（BiTreeT）

{

intdepth,depthleft,depthright;

if（!

T）depth=0;

else

{

depthleft=TreeDepth（T->lchild）;

depthright=TreeDepth（T->rchild）;

depth=1+（depthleft>depthright?

depthleft:

depthright）;

}

returndepth;

}

4、交换二叉树的左右子树

Statusexchange（BiTreeT）//先序遍历

{

if（T!

=NULL）

if（T->lchild!

=NULL||T->rchild!

=NULL）

{

BiTree*p,*q;

p=exchange（T->lchild）;

q=exchange（T->rchild）;

T->lchild=q;

T->rchild=p;

}

returnT;

}

voidexchanget（BiTreeT）//后序遍历

{

if（T!

=NULL）

if（T->lchild!

=NULL||T->rchild!

=NULL）

{

BiTree*p,*q;

q=T->rchild;

p=T->lchild;

T->lchild=q;

T->rchild=p;

exchange（T->lchild）;

exchange（T->rchild）;

}

returnT;

}

5、求二叉树的结点个数

StatusNodeNum（BiTreeT,int*num）

{

if（T）

{

if（T->data）num++;

if（NodeNum（T->lchild,num））

if（NodeNum（T->rchild,num））returnOK;

returnERROR;

}

elsereturnOK;

}

6、求二叉树的叶子数

voidCountLeaf（BiTreeT,int&count）

{

if（T）

{

if（T->lchild==NULL&&T->rchild==NULL）

count++;

else

{

CountLeaf（T->lchild,count）;

CountLeaf（T->rchild,count）;

}

}

}

7、按照目录形式输出二叉树

StatusPrintTree（BiTreebt,intnLayer）/*按竖向树状打印的二叉树*/

{

if（bt!

=NULL）

{

PrintTree（bt->lchild,nLayer+1）;

for（inti=0;i

printf（"-"）;

printf（"%c\n",bt->data）;

PrintTree（bt->rchild,nLayer+1）;

}

returnOK;

}

树的操作（采用左孩子右兄弟存储结构）

1、求树的深度

intTreeDepth（CSTreeT）

{//初始条件：

树T存在。

操作结果：

返回T的深度

intmaxd,d;

CSTreep;

if（!

T）return0;

else

{

for（maxd=0,p=T->firstchild;p;p=p->nextsibling）

if（（d=TreeDepth（p））>maxd）maxd=d;

returnmaxd+1;

}

}

2、求树中给定结点的右兄弟

TElemTypeRightSibling（CSTreeT,TElemTypecur_e）

{//初始条件：

树T存在，cur_e是T中某个结点

//操作结果：

若cur_e有右兄弟，则返回它的右兄弟；否则返回“空”

CSTreef;

f=Point（T,cur_e）;

if（f&&f->nextsibling）

returnf->nextsibling->data;

else

return'';

}

3、树的后根遍历

voidPostOrderTraverse（CSTreeT,void（*Visit）（TElemType））

{

CSTreep;

if（T）

{

if（T->firstchild）

{

PostOrderTraverse（T->firstchild,Visit）;

p=T->firstchild->nextsibling;

while（p）

{

PostOrderTraverse（p,Visit）;

p=p->nextsibling;

}

}

Visit（T->data）;

}

第九章查找

1、顺序查找法

intSearch_Seq（SSTableST,KeyTypekey）

{//在顺序表ST中顺序查找其关键字等于key的数据元素。

若找到，则函数值为