数据结构复习.docx

资源描述

数据结构复习.docx

《数据结构复习.docx》由会员分享，可在线阅读，更多相关《数据结构复习.docx（40页珍藏版）》请在冰豆网上搜索。

数据结构复习.docx

数据结构复习

第一章绪论

1.数据结构：

研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等等的学科。

2.数据——信息的一种符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

如：

整数、实数、字符串、图像、声音等

3.数据元素——数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

如：

整数“5”,字符“N”等

4.数据记录（DataRecord）——数据元素被组织成结构。

一个数据记录可由若干个数据项组成，数据项是数据的不可分割的最小单位。

5.数据对象（DataObject）——是性质相同的数据元素的集合。

是数据的一个子集

例：

集合N={0,1,-1,2,-2,…}是整型数据对象、C={‘A’,‘B’,‘C’,…‘Z’}是字符型数据对象

数据类型（DataType）——是一个值的集合和定义在这个值集上的一组操作的总称

例：

原子类型有：

整型、实型、字符型、布尔型、枚举类型、子界类型、指针类型

结构类型有：

数组、记录、文件。

6.数据结构——有一个特性相同的数据元素的集合，如果在数据元素之间存在一种或多种特定的关系，则称为一个数据结构。

7.数据结构的类型

集合结构

线性结构

树形结构

图型结构

8.数据结构包括逻辑结构和物理结构两方面

⏹逻辑结构是对数据元素之间的逻辑关系的描述，可以用一个数据元素的集合和定义在此集合上的若干关系来表示，如：

图形表示、二元组表示、语言描述；

⏹物理结构是逻辑结构在计算机中的表示和实现，故又称“存储结构”

9.数据元素的映象方法

a）用二进制位（bit）的位串表示数据元素

10.关系的映象方法：

a）顺序映象——以物理位置的相邻反映逻辑上的相邻

b）链式映象——以附加信息（指针）表示后继关系需要用一个和x在一起的附加信息指示y的存储位置

11.算法——为了解决某类问题而规定的一个有限长的操作序列。

五个重要特性：

有穷性、确定性、可行性、

有输入、有输出

算法设计的原则：

1．正确性

2.可读性

3．健壮性

4．高效率与低存储量需求

第二章线性表

顺序表操作：

#defineOK1

#defineERROR0

#include

typedefintstatus;

#defineMAXSIZE100

typedefstruct{

intdata[MAXSIZE];

intlength;

}sqlist;

statusInitList（sqlist&sl）

{

sl.length=0;

returnOK;

}

statusCreatList（sqlist&sl）

{

printf（"开a始º?

创ä¡ä建¡§顺3序¨°表À¨ª，ê?

请?

输º?

入¨?

表À¨ª长¡è（ê¡§正y整?

数ºy）ê?

：

êo"）;

intn=0;

scanf（"%d",&n）;

while（n>100）

{

printf（"超?

出?

最Á?

大ä¨®长¡è度¨¨限T制?

，ê?

请?

重?

新?

输º?

入¨?

：

êo"）;

scanf（"%d",n）;

}

sl.length=n;

printf（"请?

输º?

入¨?

数ºy据Y：

êo"）;

for（inti=0;i

{

scanf（"%d",&sl.data[i]）;

}

returnOK;

}

//按ã¡ä顺3序¨°查¨¦找¨°

statusFindPosElem（sqlistsl,intpos）

{

if（pos<1||pos>sl.length）

{

returnERROR;

}

returnsl.data[pos-1];

}

//按ã¡ä值¦Ì查¨¦找¨°

statusFindElem（sqlistsl,intelem）

{

inti;

for（i=0;i

{

if（sl.data[i]==elem）

returni+1;

}

if（i>=sl.length）

returnERROR;

}

//在¨²指?

定¡§位?

置?

之?

前¡ã插?

入¨?

statusInsertList（sqlist&sl,intelem,intpos）

{

if（pos<1||pos>sl.length+1||sl.length+1>MAXSIZE）

returnERROR;

else

{

for（inti=sl.length+1;i>pos-1;i--）

sl.data[i]=sl.data[i-1];

sl.data[pos-1]=elem;

sl.length++;

}

returnOK;

}

//按ã¡ä序¨°号?

删¦?

除y

statusDelePosElem（sqlist&sl,intpos,int*elem）

{

if（pos<1||pos>sl.length）

returnERROR;

*elem=sl.data[pos-1];

if（pos==sl.length）

{

sl.length--;

returnOK;

}

else

for（inti=pos-1;i

{

sl.data[i]=sl.data[i+1];

}

sl.length--;

returnOK;

}

//按ã¡ä值¦Ì删¦?

除y

voidDeleElem（sqlist&sl,ints,int&elem）

{

for（inti=0;i

{

if（sl.data[i]==s）

{

DelePosElem（sl,i+1,&elem）;

i=i-1;

}

statusMergeList（sqlistLa,sqlistLb,sqlist&Lc）

{

inti,j;

i=j=1;

intk=0;

while（i<=La.length&&j<=Lb.length）

{

if（La.data[i-1]<=Lb.data[j-1]）

{

InsertList（Lc,La.data[i-1],++k）;

i++;

}

else

{

InsertList（Lc,Lb.data[j-1],++k）;j++;

}

while（i<=La.length）

{

InsertList（Lc,La.data[i-1],++k）;

i++;

}

while（j<=Lb.length）

{

InsertList（Lc,Lb.data[j-1],++k）;

j++;

}

returnOK;

}

//输º?

出?

statusOutList（sqlistsl）

{

for（inti=0;i

{

printf（"%d",sl.data[i]）;

}

returnOK;

}

voidmain（）

{

sqlistsl;

sqlistla,lb,lc;

intpos=0;

intelem=0;

intelem1=0;

ints=0;

printf（"**************顺3序¨°表À¨ª的Ì?

实º¦Ì现?

**************\n"）;

printf（"1--初?

始º?

化¡¥\n2--创ä¡ä建¡§表À¨ª\n3--按ã¡ä序¨°号?

查¨¦找¨°\n4--按ã¡ä值¦Ì查¨¦找¨°\n5--插?

入¨?

\n6--按ã¡ä序¨°号?

删¦?

除y\n7--按ã¡ä值¦Ì删¦?

除y\n8--输º?

出?

\n9--合?

并¡é\n"）;

intn=1;

while（n）

{

printf（"请?

输º?

入¨?

操¨´作Á¡Â序¨°号?

：

êo"）;

scanf（"%d",&n）;

switch（n）

{

case1:

if（InitList（sl））

printf（"初?

始º?

化¡¥成¨¦功|！

ê?

"）;

else

printf（"初?

始º?

化¡¥失º¡ì败ã¨¹！

ê?

"）;

break;

case2:

if（CreatList（sl））

printf（"创ä¡ä建¡§成¨¦功|！

ê?

"）;

else

printf（"创ä¡ä建¡§失º¡ì败ã¨¹！

ê?

"）;

break;

case3:

printf（"请?

输º?

入¨?

要°a查¨¦找¨°的Ì?

位?

置?

"）;

scanf（"%d",&pos）;

if（!

FindPosElem（sl,pos））

printf（"输º?

入¨?

错ä¨ª误¨®！

ê?

"）;

else

printf（"%d",FindPosElem（sl,pos））;

break;

case4:

printf（"请?

输º?

入¨?

要°a查¨¦找¨°的Ì?

值¦Ì"）;

scanf（"%d",&elem）;

if（!

FindElem（sl,elem））

printf（"没?

有®D该?

数ºy据Y记?

录?

！

ê?

"）;

else

printf（"%d",FindElem（sl,elem））;

break;

case5:

printf（"请?

输º?

入¨?

要°a插?

入¨?

的Ì?

位?

置?

：

êo"）;

scanf（"%d",&pos）;

printf（"请?

输º?

入¨?

要°a插?

入¨?

的Ì?

数ºy：

êo"）;

scanf（"%d",&elem）;

if（InsertList（sl,elem,pos））

printf（"插?

入¨?

成¨¦功|！

ê?

"）;

else

printf（"插?

入¨?

失º¡ì败ã¨¹！

ê?

"）;

break;

case6:

printf（"输º?

入¨?

要°a删¦?

除y数ºy据Y的Ì?

序¨°号?

：

êo"）;

scanf（"%d",&pos）;

if（DelePosElem（sl,pos,&elem））

printf（"%d已°?

经-删¦?

除y成¨¦功|！

ê?

",elem）;

else

printf（"ERROR"）;

break;

case7:

printf（"输º?

入¨?

要°a删¦?

除y的Ì?

数ºy值¦Ì：

êo"）;

scanf（"%d",&s）;

DeleElem（sl,s,elem1）;

printf（"%d已°?

经-删¦?

除y成¨¦功|！

ê?

",elem1）;

break;

case8:

if（OutList（sl））

printf（"输º?

出?

完ª¨º毕À?

！

ê?

"）;

break;

case9:

if（CreatList（la））

printf（"OK\n"）;

if（CreatList（lb））

printf（"Ok\n"）;

if（InitList（lc））

printf（"OK\n"）;

if（MergeList（la,lb,lc））

OutList（lc）;

break;

default:

break;

}

单链表操作：

#include

#defineERROR0

typedeftructNode{

intdata;

structLNode*next;

}LNode,*LinkList;

LinkListInitLinkList（）

{

LinkLists;

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

s->next=NULL;

returns;

}

//头ª¡¤插?

法¤¡§创ä¡ä建¡§

LinkListCreatLinkList（intn）

{

LinkListL=InitLinkList（）;

LinkListp;

for（inti=0;i

{

printf（"请?

输º?

入¨?

第Ì¨²%d个?

数ºy",i+1）;

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

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

p->next=L->next;

L->next=p;

}

returnL;

}

//尾2插?

法¤¡§创ä¡ä建¡§

LinkListCreatLinkListTail（intn）

{

LinkListL=InitLinkList（）;

LinkListp;

LinkListq=L;

for（inti=0;i

{

printf（"请?

输º?

入¨?

第Ì¨²%d个?

数ºy",i+1）;

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

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

q->next=p;

p->next=NULL;

q=p;

}

returnL;

}

intGet（LinkListhead,inti）

{

LinkListp;

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

p=head->next;

intj=1;

while（p&&j

{

p=p->next;

j++;

}

if（!

p||j>i）

returnERROR;

else

returnp->data;

}

voidInsertLinkList（LinkListhead,inti,intelem）

{

LinkListp;

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

p=head->next;

intj=1;

while（p&&j

{

p=p->next;

j++;

}

if（!

p||j>i-1）

printf（"ERROR"）;

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

s->data=elem;

s->next=p->next;

p->next=s;

printf（"OK!

"）;

}

//intDeleteLinkList（LinkListhead,inti）

//{

//LinkListp;

//inte=0;

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

//p=head->next;

//intj=1;

//while（p&&j

//{

//p=p->next;

//j++;

//}

//LinkListq=（LinkList）malloc（sizeof（LNode））;

//q=p->next;

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

//e=q->data;

//free（q）;

//returne;

//}

intLength（LinkListhead）

{

inti=0;

LinkListp;

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

p=head;

while（p）

{

p=p->next;

++i;

}

returni;

}

voidMerge_L（LinkListLa,LinkListLb,LinkList&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;

}

if（pa）

pc->next=pa;

else

pc->next=pb;

free（Lb）;

}

voidOutPrint（LinkListL）

{

while（L->next）

{

L=L->next;

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

}

voidmain（）

{

printf（"***************单Ì£¤链¢¡ä表À¨ª实º¦Ì现?

****************\n"）;

printf（"1--头ª¡¤插?

法¤¡§创ä¡ä建¡§\n2--尾2插?

法¤¡§创ä¡ä建¡§\n3--按ã¡ä序¨°号?

查¨¦找¨°\n4--插?

入¨?

\n5--删¦?

除y\n6--求¨®表À¨ª长¡è\n7--输º?

出?

\n8--合?

并¡é\n"）;

inti=1;

intn=0;

intpos=0;

intelem=0;

LinkListL;

LinkListla,lb,lc;

while

（1）

{

scanf（"%d",&i）;

switch（i）

{

case1:

printf（"Entern:

\n"）;

scanf（"%d",&n）;

L=CreatLinkList（n）;

break;

case2:

printf（"Entern:

\n"）;

scanf（"%d",&n）;

L=CreatLinkListTail（n）;

break;

case3:

printf（"输º?

入¨?

序¨°号?

：

êo"）;

scanf（"%d",&pos）;

printf（"%d\n",Get（L,pos））;

break;

case4:

printf（"输º?

入¨?

位?

置?

\n"）;

scanf（"%d",&pos）;

printf（"输º?

入¨?

数ºy据Y\n"）;

scanf（"%d",&elem）;

InsertLinkList（L,pos,elem）;

case5:

printf（"输º?

入¨?

位?

置?

\n"）;

scanf（"%d",&pos）;

//printf（"%d已°?

经-删¦?

除y！

ê?

",DeleteLinkList（L,pos））;

case6:

printf（"表À¨ª长¡è：

êo%d",Length（L））;

case7:

OutPrint（L）;

break;

case8:

printf（"输º?

入¨?

La的Ì?

元a素?

个?

数ºy"）;

scanf（"%d",&n）;

la=CreatLinkListTail（n）;

printf（"输º?

入¨?

Lb的Ì?

元a素?

个?

数ºy"）;

scanf（"%d",&n）;

lb=CreatLinkListTail（n）;

lc=InitLinkList（）;

Merge_L（la,lb,lc）;

OutPrint（lc）;

break;

}

第三章栈和队列

栈的基本操作（链栈）：

#defineMAXLEN100

#defineOK1

#defineERROR0

typedefstructStackNode

{

intdata;

structStackNode*next;

}StackNode,*LinkStack;

voidInitStack（LinkStack&ls）

{

ls=NULL;

}

//判D断?

栈?

空?

intStackEmpty（LinkStackls）

{

returnls==NULL;

}

//进?

栈?

（ê¡§不?

带ä?

头ª¡¤结¨¢点Ì?

头ª¡¤插?

法¤¡§）ê?

voidPush（LinkStack&ls,intelem）

{

LinkStackp;

p=（LinkStack）malloc（sizeof（StackNode））;

p->data=elem;

p->next=ls;

ls=p;

}

//出?

栈?

intPop（LinkStack&ls）

{

//LinkStackp;

//intx;

if（ls==NULL）

returnERROR;

else

{

intelem=ls->data;

ls=ls->next;

returnelem;

}

//读¨¢栈?

顶£¤元a素?

intTop（LinkStackls）

{

if（!

StackEmpty）

{

returnls->data;

}

//清?

空?

voidClearStack（LinkStack&ls）

{

LinkStackcp,np;

cp=ls;

while（cp!

=NULL）

{

np=cp->next;

deletecp;

cp=np;

}

ls=NULL;

}

数制转换：

voidconversion（intN,intd）{

/*将?

整?

数ºyN转Áa换?

成¨¦d进?

制?

LinkStackS;

InitStack（S）;

while（N）{

Push（S,N%d）;

N=N/d;

}

inte=0;

while（!

StackEmpty（S））{

e=Pop（S）;

展开阅读全文