大学教程(零起点)数据结构--概论
大学数据结构教案第一章
教学目标：1. 理解数据结构的基本概念和重要性。
2. 掌握数据结构的逻辑结构和物理结构。
3. 了解数据结构的学习方法和应用领域。
教学重点：1. 数据结构的概念和重要性。
2. 逻辑结构和物理结构的基本概念。
教学难点：1. 数据结构的逻辑结构和物理结构的理解。
2. 数据结构的学习方法和应用领域的掌握。
教学准备：1. 教学课件。
2. 相关教材和参考资料。
3. 实例分析。
教学过程：一、导入1. 通过一个简单的例子（如学生信息管理系统），引出数据结构的概念。
2. 提问：在学生信息管理系统中，我们如何存储和操作学生信息？二、讲授新课1. 数据结构的概念- 数据结构是计算机存储、组织数据的方式。
- 数据结构是计算机科学中的重要基础，是解决复杂问题的有力工具。
2. 数据结构的重要性- 提高数据存储和处理的效率。
- 优化算法设计和分析。
- 促进软件开发和工程实践。
3. 逻辑结构和物理结构- 逻辑结构：描述数据之间的逻辑关系，如线性结构、非线性结构等。
- 物理结构：描述数据在计算机中的存储方式，如数组、链表、树等。
4. 数据结构的学习方法- 理论与实践相结合。
- 注重算法设计和分析。
- 学习经典数据结构及其应用。
5. 数据结构的应用领域- 软件开发。
- 数据库系统。
- 网络通信。
- 图像处理。
三、实例分析1. 以学生信息管理系统为例，分析数据结构的实际应用。
2. 引导学生思考：如何设计合适的数据结构来存储和操作学生信息？四、课堂小结1. 总结本章内容，强调数据结构的基本概念和重要性。
2. 鼓励学生课后继续学习，掌握数据结构的逻辑结构和物理结构。
五、作业布置1. 阅读教材相关内容，理解数据结构的逻辑结构和物理结构。
2. 完成课后习题，巩固所学知识。
教学反思：1. 本节课通过实例分析，使学生更加直观地理解数据结构的概念和应用。
2. 在教学过程中，注重启发式教学，引导学生主动思考。
3. 在课后作业布置中，注重理论与实践相结合，提高学生的动手能力。
数据结构自学总结(1)线性结构
数据结构自学总结--第一阶段线性结构一．数据结构概论1.1 时间复杂度：程序执行的次数T = O(n);1.2 空间复杂度:出现执行时所占用的内存空间；1.3数据结构的定义：狭义：是专门研究数据存储的问题数据的存储包含两方面：个体的存储+个体关系的存储广义：数据结构即包含数据的存储也包含数据的操作对存储数据的操作就是算法1.4算法的定义：是对存储数据的操作狭义的算法是与数据的存储方式密切相关广义的算法是与数据的存储方式无关泛型：利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的。
1.5 利用结构体定义自己的数据类型typedef struct Student{int sid;char name[100];char sex;}* PST,STU; //PST 等于struct student * ,STU代表了struct Student二．线性结构2.1连续存储（顺序表，数组）：元素类型相同，大小相等优点：存取速度很快缺点：实现必须知道数组的长度需要大块连续的内存快插入删除元素的效率极低空间通常是有限的2.2离散存储（链表）优点：空间没有限制插入删除元素很快缺点：存取速度很慢定义：n个节点离散分配彼此通过指针相连每个节点只有一个前驱节点，每个节点只有一个后续节点首节点没有前驱节点尾节点没有后续节点专业术语：首节点：第一个有效节点尾节点：最后一个有效节点头结点：第一个有效节点之前的那个节点，头结点并不存放有效数据，加头节点是为了方便对链表的操作，头结点的数据类型和首节点的数据类型一样头指针：指向头结点的指针变量尾指针：指向尾节点的指针变量如何确定一个链表需要几个参数？如果希望通过一个函数来对链表进行处理，我们至少要接受链表的哪些参数的问题只需要一个参数：头指针，因为通过头指针可以推算出链表的所有信息一个节点的生成：struct Node{int data;//数据域struct Node * pNext; //指针域}Node,*PNode; //Node等价于Struct Node,PNode等价于Struct NOde *类型2.3链表的分类：单链表：双链表：每一个节点有两个指针域循环链表：能通过任何一个节点找到其他所有的结点非循环链表：算法：遍历查找清空销毁求长度排序删除节点：r=p->pNext ; p->pNext = q; q->pNext = r;或者是q->pNext = p->pNext; p->pNext = q注意：p->pNext 表示p指向的那个节点的pNext成员插入节点3 各种数据结构的实现算法以及相关操作方法的实现3.1 实现顺序表的各种基本运算/*2012年2月20日22:32:41目的：实现顺序表中常用的9个操作方法，并实现测试之*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;extern void InitList(SqList *&L); //形参的改变映射给实参extern void DestroyList(SqList *L);extern int ListEmpty(SqList *L);extern int ListLength(SqList *L);extern void DispList(SqList *L);extern int GetElem(SqList *L,int i,ElemType &e);extern int LocateElem(SqList *L, ElemType e);extern int ListInsert(SqList *&L,int i,ElemType e);extern int ListDelete(SqList *&L,int i,ElemType &e);int main(void){SqList *L;ElemType e;printf("\n=============顺序表中所有方法的实现===================\n"); printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);printf(" (7)元素a的位置=%d\n",LocateElem(L,'a'));printf(" (8)在第4个元素位置上插入f元素\n");ListInsert(L,4,'f');printf(" (9)输出顺序表L:");DispList(L);printf(" (10)删除L的第3个元素\n");ListDelete(L,3,e);printf(" (11)输出顺序表L:");DispList(L);printf(" (12)释放顺序表L\n");DestroyList(L);return 0;}void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf(" %c ",L->data[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) {if (i<1 || i>L->length)return 0;e=L->data[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->data[i]!=e) i++; if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e)int j;if (i<1 || i>L->length+1)return 0;i--; //将顺序表位序转化为elem下标*/ for (j=L->length;j>i;j--) //将data[i]及后面元素后移一个位置*/ L->data[j]=L->data[j-1];L->data[i]=e;L->length++; //顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; //将顺序表位序转化为elem下标*/ e=L->data[i];for (j=i;j<L->length-1;j++)L->data[j]=L->data[j+1];L->length--;return 1;}/*在VC++6.0中的输出结果为:=============顺序表中所有方法的实现===================(1)初始化顺序表L(2)依次采用尾插法插入a,b,c,d,e元素(3)输出顺序表L: a b c d e(4)顺序表L长度=5(5)顺序表L为非空(6)顺序表L的第3个元素=c(7)元素a的位置=1(8)在第4个元素位置上插入f元素(9)输出顺序表L: a b c f d e(10)删除L的第3个元素(11)输出顺序表L: a b f d e(12)释放顺序表LPress any key to continue总结：当调用DestroyList(L)后，free释放的事L指向的内存空间，但是此时，指针变量L仍然存在3.2 实现单链表的各种基本运算/*2012年2月22日19:05:12 作者：陈金林目的：实现单链表的基本方法，并实现之*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct LNode{ElemType data;struct LNode * next;}LinkList;void InitList(LinkList * &L);int ListInsert(LinkList * &L,int i,ElemType e);void DispList(LinkList * L);int ListLength(LinkList * L);int ListEmpty(LinkList * L);int GetElem(LinkList * L,int i,ElemType &e);int LocateElem(LinkList * L,ElemType e);int ListDelete(LinkList * &L,int i,ElemType &e);void DestroyList(LinkList * &L);int main(void){LinkList * h;ElemType e;printf("\n================实现单链表的常用操作============\n");printf("(1)初始化单链表h\n");InitList(h);printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(h,1,'a');ListInsert(h,2,'b');ListInsert(h,3,'c');ListInsert(h,4,'d');ListInsert(h,5,'e');printf("(3)输出单链表h");DispList(h);printf("(4)输出单链表h长度%d\n",ListLength(h));printf("(5)判断单链表h是否为空%s\n",(ListEmpty(h)==0)?"空":"非空"); GetElem(h,3,e);printf("(6)输出单链表h的第三个元素%d\n",e);printf("(7)输出元素'a'的位置%d\n",LocateElem(h,'a'));printf("(8)在第四个元素位置上插入'f'元素\n");ListInsert(h,4,'f');printf("(9)输出单链表h");DispList(h);printf("(10)删除h的第3个元素\n");ListDelete(h,3,e);printf("(11)输出单链表h :");DispList(h);printf("(12)释放单链表h\n");DestroyList(h);return 0;}void InitList(LinkList * &L){L = (LinkList *)malloc(sizeof(LinkList));L->next = NULL;}int ListInsert(LinkList * &L,int i,ElemType e){int j = 0;LinkList * p = L,* s;while(j<i-1 && p!=NULL){j++;p = p->next;}if(p == NULL)return 0;else{s = (LinkList *)malloc(sizeof(LinkList));s->data = e;s->next = p->next;p->next = s;return 1;}}void DispList(LinkList * L){LinkList * p = L->next;while(p!=NULL){printf(" %c ",p->data);p = p->next;}printf("\n");}int ListLength(LinkList * L){LinkList * p = L;int n = 0;while(p->next!=NULL){n++;p = p->next;}return(n);}int ListEmpty(LinkList * L){return (L->next == NULL);}int GetElem(LinkList * L,int i,ElemType &e) {int j = 0;LinkList * p = L;while(j<i && p!=NULL){j++;p = p->next;}if(p == NULL)return 0;else{e = p->data;return 1;}}int LocateElem(LinkList * L,ElemType e){LinkList * p = L->next;int i = 1;while(p!=NULL && p->data!=e){p = p->next;i++;}if(p == NULL)return (0);elsereturn (i);}int ListDelete(LinkList * &L,int i,ElemType &e) {int j= 0;LinkList * p = L,*q;while(j<i-1 && p!=NULL){j++;p = p->next;}if(p == NULL)return 0;else{q = p->next;if(q==NULL)return 0;e = q->data;p->next = q->next;free(q);return 1;}}void DestroyList(LinkList * &L){LinkList * p =L,* q=p->next;while(q!=NULL){free(p);p = q;q = p->next;}free(q);}/*在VC++6.0中的输出结果为:=======================实现单链表的常用操作=================(1)初始化单链表h(2)依次采用尾插法插入a,b,c,d,e元素(3)输出单链表h a b c d e(4)输出单链表h长度5(5)判断单链表h是否为空空(6)输出单链表h的第三个元素99(7)输出元素'a'的位置1(8)在第四个元素位置上插入'f'元素(9)输出单链表h a b c f d e(10)删除h的第3个元素(11)输出单链表h : a b f d e(12)释放单链表hPress any key to continue*/3.3 实现双链表的各种基本运算#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct DNode{ElemType data;struct DNode * prior;struct DNode * next;} DLinkList;extern void InitList(DLinkList *&L); //以下均为外部函数extern void DestroyList(DLinkList *&L);extern int ListEmpty(DLinkList *L);extern int ListLength(DLinkList *L);extern void DispList(DLinkList *L);extern int GetElem(DLinkList *L,int i,ElemType &e);extern int LocateElem(DLinkList *L,ElemType e);extern int ListInsert(DLinkList *&L,int i,ElemType e);extern int ListDelete(DLinkList *&L,int i,ElemType &e);int main(void){DLinkList * h;ElemType e;printf("\n========双链表所有操作方法的实现====作者：陈金林======\n");printf("(1)初始化双链表h\n");InitList(h);printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(h,1,'a');ListInsert(h,1,'b');ListInsert(h,1,'c');ListInsert(h,1,'d');ListInsert(h,1,'e');printf("(3)输出双链表h :");DispList(h);printf("(4)输出双链表h的长度%d\n",ListLength(h));printf("(5)双链表h为%s\n",(ListEmpty(h)?"空":"非空"));GetElem(h,3,e);printf("(6)输出双链表h的第3个元素%c\n",e);printf("(7)输出元素'a'的位置%d\n",LocateElem(h,'a'));printf("(8)在第4个元素的位置上插入'f'元素\n");printf("(9)输出双链表h:");DispList(h);printf("(10)删除h的第三个元素\n");ListDelete(h,3,e);printf("(11)输出双链表h:");DispList(h);printf("(12)释放双链表h\n");DestroyList(h);return 0;}void InitList(DLinkList *&L){L=(DLinkList *)malloc(sizeof(DLinkList)); //创建头结点L->prior=L->next=NULL;}void DestroyList(DLinkList *&L){DLinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L){return(L->next==NULL);}int ListLength(DLinkList *L){DLinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(DLinkList *L){DLinkList *p=L->next;while (p!=NULL){printf(" %c ",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(DLinkList *L,ElemType e){int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e){int j=0;DLinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) //未找到第i-1个结点return 0;else //找到第i-1个结点*p{s=(DLinkList *)malloc(sizeof(DLinkList)); //创建新结点*ss->data=e;s->next=p->next; //将*s插入到*p之后if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}int ListDelete(DLinkList *&L,int i,ElemType &e){int j=0;DLinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) //未找到第i-1个结点return 0;else //找到第i-1个结点*p{q=p->next; //q指向要删除的结点if (q==NULL) return 0; //不存在第i个结点e=q->data;p->next=q->next; //从单链表中删除*q结点if (p->next!=NULL) p->next->prior=p;free(q); //释放*q结点return 1;}}3.4 实现循环单链表的各种基本运算/*2012年2月24日20:57:59 作者：陈金林目的：循环单链表所有方法的实现*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode //定义循环单链表结点类型{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L);void DestroyList(LinkList *&L);int ListEmpty(LinkList *L);int ListLength(LinkList *L);void DispList(LinkList *L);int GetElem(LinkList *L,int i,ElemType &e);int LocateElem(LinkList *L,ElemType e);int ListInsert(LinkList *&L,int i,ElemType e);int ListDelete(LinkList *&L,int i,ElemType &e);int main(void){LinkList * h;ElemType e;printf("\n==========循环单链表所有方法的实现=====================\n"); printf(" (1)初始化循环单链表h\n");InitList(h);printf(" (2)依次采用头插法插入a,b,c,d,e元素\n");ListInsert(h,1,'a');ListInsert(h,1,'b');ListInsert(h,1,'c');ListInsert(h,1,'d');ListInsert(h,1,'e');printf(" (3)输出循环单链表h:");DispList(h);printf(" (4)输出循环单链表h长度length = %d\n",ListLength(h));printf(" (5)判断循环单链表h是否为空? %s\n",ListEmpty(h)?"空":"非空"); GetElem(h,3,e);printf(" (6)输出循环单链表h的第3个元素%c\n",e);printf(" (7)输出元素'a'的位置:%d\n",LocateElem(h,'a'));printf(" (8)在第四个元素位置上插入'f'元素\n");ListInsert(h,4,'f');printf(" (9)输出循环单链表h :");DispList(h);printf(" (10)删除L的第3个元素\n");ListDelete(h,3,e);printf(" (11)输出循环单链表h :");DispList(h);printf(" (12)释放循环单链表h\n");DestroyList(h);return 0;}void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点L->next=L; //说名此链表为循环单链表}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==L);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=L){printf(" %c ",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e){int j=0;LinkList *p;if (L->next!=L) //单链表不为空表时{if (i==1){e=L->next->data;return 1;}else //i不为1时{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else //单链表为空表时return 0;}int LocateElem(LinkList *L,ElemType e) {LinkList *p=L->next;int n=1;while (p!=L && p->data!=e){p=p->next;n++;}if (p==L)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e) {int j=0;LinkList *p=L,*s;if (p->next==L || i==1) //原单链表为空表或i==1时{s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*ss->data=e;s->next=p->next; //将*s插入到*p之后p->next=s;return 1;}else{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) //未找到第i-1个结点return 0;else //找到第i-1个结点*p{s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*ss->data=e;s->next=p->next; //将*s插入到*p之后p->next=s;return 1;}}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;if (p->next!=L) //原单链表不为空表时{if (i==1) //i==1时{q=L->next; //删除第1个结点e=q->data;L->next=q->next;free(q);return 1;}else //i不为1时{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) //未找到第i-1个结点return 0;else //找到第i-1个结点*p{q=p->next; //q指向要删除的结点e=q->data;p->next=q->next; //从单链表中删除*q结点free(q); //释放*q结点return 1;}}}else return 0;}/*在VC++6.0中的输出结果为:=================循环单链表所有方法的实现=====================(1)初始化循环单链表h(2)依次采用头插法插入a,b,c,d,e元素(3)输出循环单链表h: e d c b a(4)输出循环单链表h长度length = 5(5)判断循环单链表h是否为空? 非空(6)输出循环单链表h的第3个元素c(7)输出元素'a'的位置:5(8)在第四个元素位置上插入'f'元素(9)输出循环单链表h : e d c f b a(10)删除L的第3个元素(11)输出循环单链表h : e d f b a(12)释放循环单链表hPress any key to continue*/3.5 实现循环双链表的各种基本运算/*2012年2月24日21:01:46 作者：陈金林目的：循环双链表所有方法的实现*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct DNode //定义双链表结点类型{ElemType data;struct DNode *prior; //指向前驱结点struct DNode *next; //指向后继结点} DLinkList;void InitList(DLinkList *&L);void DestroyList(DLinkList *&L);int ListEmpty(DLinkList *L);int ListLength(DLinkList *L);void DispList(DLinkList *L);int GetElem(DLinkList *L,int i,ElemType &e);int LocateElem(DLinkList *L,ElemType e);int ListInsert(DLinkList *&L,int i,ElemType e);int ListDelete(DLinkList *&L,int i,ElemType &e);int main(void){DLinkList * h;ElemType e;printf("\n=================循环双链表所有方法的实现=====================\n");printf(" (1)初始化循环双链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(h,1,'a');ListInsert(h,1,'b');ListInsert(h,1,'c');ListInsert(h,1,'d');ListInsert(h,1,'e');printf(" (3)输出循环双链表h:");DispList(h);printf(" (4)输出循环双链表h长度length = %d\n",ListLength(h));printf(" (5)判断循环双链表h是否为空? %s\n",ListEmpty(h)?"空":"非空");GetElem(h,3,e);printf(" (6)输出循环双链表h的第3个元素%c\n",e);printf(" (7)输出元素'a'的位置:%d\n",LocateElem(h,'a'));printf(" (8)在第四个元素位置上插入'f'元素\n");ListInsert(h,4,'f');printf(" (9)输出循环双链表h :");DispList(h);printf(" (10)删除L的第3个元素\n");ListDelete(h,3,e);printf(" (11)输出循环双链表h :");DispList(h);printf(" (12)释放循环双链表h\n");DestroyList(h);return 0;}void InitList(DLinkList *&L){L=(DLinkList *)malloc(sizeof(DLinkList)); //创建头结点L->prior=L->next=L;}void DestroyList(DLinkList *&L){DLinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L){return(L->next==L);}int ListLength(DLinkList *L){DLinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(DLinkList *L){DLinkList *p=L->next;while (p!=L){printf(" %c ",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p;if (L->next!=L) //双链表不为空表时{if (i==1){e=L->next->data;return 1;}else //i不为1时{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else //双链表为空表时return 0;}int LocateElem(DLinkList *L,ElemType e) {int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e){int j=0;DLinkList *p=L,*s;if (p->next==L) //原双链表为空表时{s=(DLinkList *)malloc(sizeof(DLinkList)); //创建新结点*ss->data=e;p->next=s;s->next=p;p->prior=s;s->prior=p;return 1;}else if (i==1) //原双链表不为空表但i=1时{s=(DLinkList *)malloc(sizeof(DLinkList)); //创建新结点*ss->data=e;s->next=p->next;p->next=s; //将*s插入到*p之后s->next->prior=s;s->prior=p;return 1;}else{p=L->next;while (j<i-2 && p!=L){ j++;p=p->next;}if (p==L) //未找到第i-1个结点return 0;else //找到第i-1个结点*p{s=(DLinkList *)malloc(sizeof(DLinkList)); //创建新结点*ss->data=e;s->next=p->next; //将*s插入到*p之后if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}}int ListDelete(DLinkList *&L,int i,ElemType &e){int j=0;DLinkList *p=L,*q;if (p->next!=L) //原双链表不为空表时{if (i==1) //i==1时{q=L->next; //删除第1个结点e=q->data;L->next=q->next;q->next->prior=L;free(q);return 1;}else //i不为1时{p=L->next;while (j<i-2 && p!=NULL){j++;p=p->next;}if (p==NULL) //未找到第i-1个结点return 0;else //找到第i-1个结点*p{q=p->next; //q指向要删除的结点if (q==NULL) return 0; //不存在第i个结点e=q->data;p->next=q->next; //从单链表中删除*q结点if (p->next!=NULL) p->next->prior=p;free(q); //释放*q结点return 1;}}}else return 0; //原双链表为空表时}/*在VC++6.0中的输出结果为:=================循环双链表所有方法的实现=====================(1)初始化循环双链表h(2)依次采用尾插法插入a,b,c,d,e元素(3)输出循环双链表h: e d c b a(4)输出循环双链表h长度length = 5(5)判断循环双链表h是否为空? 非空(6)输出循环双链表h的第3个元素c(7)输出元素'a'的位置:5(8)在第四个元素位置上插入'f'元素(9)输出循环双链表h : e d c f b a(10)删除L的第3个元素(11)输出循环双链表h : e d f b a(12)释放循环双链表hPress any key to continue*/三．线性结构的常见应用之一------------------栈定义:一种可以实现'先进后出' 的存储结构。
数据结构第01章概论.ppt
（第2版）
李云清 杨庆红 揭安全
人民邮电出版社
1
第一章 概述
什么是数据结构 数据类型和抽象数据类型
算法和算法分析
退出
第一章 概述
瑞士著名的计算机科学家Nicklaus Wirth在1976 年出版了一本书，书名为《算法+数据结构 = 程序设 计》，它正说明了数据结构在程序设计中的作用。程序 设计的实质即为计算机处理问题编制一组"指令"，首先 需要解决两个问题：即算法和数据结构。算法即处理问 题的策略，而数据结构即为问题的数学模型。
退出
1.1.4数据的运算集合
对于一批数据，数据的运算是定义在数据的逻 辑结构之上的，而运算的具体实现就依赖于数据的 存储结构。
数据的运算集合要视情况而定，一般而言，数据的 运算包括插入、删除、检索、输出、排序等。
插入：在一个结构中增加一个新的结点。
删除：在一个结构删除一个结点。
检索：在一个结构中查找满足条件的结点。
98
I 79
F
（a）城市距离图
A
34
12
B
H9
8
C
G
31
21
E 10
D
I 79
F
（b）联通各城市最小生成树
退出
以上所举例子中的数学模型正是数据结构要讨论 的问题。因此，简单地说，数据结构是一门讨论"描述 现实世界实体的数学模型(非数值计算)及其上的操作 在计算机中如何表示和实现"的学科。
退出
综上所述
对于一个数据结构B=（K，R），必须建立从结点 集合到计算机某个存储区域M的一个映象，这个映象 要直接或间接地表达结点之间的关系R。数据在计算 机中的存储方式称为数据的存储结构。
第1章 绪论
朱昌杰 肖建于 编著
清华大学出版社
1.4.2 C语言描述算法的注意事项
6.循环语句： while（条件） 循环体语句； do { 循环体语句； }while（条件）； 或者 For（赋初值表达式1；条件表达式2；步长表达式3） 循环体语句； 7.结束语句： return(返回表达式)； break; exit;
朱昌杰 肖建于 编著 清华大学出版社
1.4.2 C语言描述算法的注意事项
2.算法的空间复杂度 如果输入数据所占用空间只取决于问题本身， 则只需要分析除输入和程序之外的额外空间， 否则应同时考虑输入本身所需空间。若额外空 间相对于输入数据量来说是常数，则称此算法 为原地工作，本书第9章讨论的有些排序算法 就属于这一类。若所占空间量依赖于特定的输 入，则除特别指明外，均按最坏情况来分析。
朱昌杰 肖建于 编著 清华大学出版社
1.4.2 C语言描述算法的注意事项
8.函数的定义语句： 函数类型 函数名（类型名 形参1，类型名 形参2，…） { //算法功能说明 函数语句； } 其中函数类型是指函数的返回值的类型，当返回值为整型时，函数类 型可以省略。形参如果是引用参数，则以&打头。
9.函数调用语句： 函数名（实参1，实参2，…）； 因为函数调用是一条语句，所以在括号后要有分号。
朱昌杰 肖建于 编著
清华大学出版社
1.4.2 C语言描述算法的注意事项
10.基本函数： max（表达式1，表达式2，…，表达式n） min（表达式1，表达式2，…，表达式n） abs（表达式） eof（文件变量） eoln（文件变量）
朱昌杰 肖建于 编著
清华大学出版社
1.4.2 C语言描述算法的注意事项
1.1.2 数据的物理结构
第一章概论(2015)
10
1.1 什么是数据结构
是相互之间存在一种或多种特定关系的数据元素的 集合，表示为：
Data_Structure=（D, R）
（数值或非数值）
元素有限集 关系有限集
——是指同一数据元素类型中各元素之间存在的关系
11
术语简介： 数据、数据元素和数据项
数据(data)——所有能被计算机识别、存储和处理的符号的集合
算机存储器内的表示（或映像）。它依赖于计算机。
存储结构可分为4大类：
顺序、链式、索引、散列
例：复数3.0－2.3i 的两种存储方式：
法1：地址 内容
0300
0302
3.0
－2.3
法2：地址 0300
内容 3.0
0302
0415
0415
－2.3
19
解释3：什么是数据的运算？ 答：在数据的逻辑结构上定义的操作算法。 它在数据的存储结构上实现。
例1：分析以下程序段的时间复杂度。
i=1; while(i<=n) i=i*2; ① ②
解： 该算法的运行时间由程序中所有语句的频度（即该语
句重复执行的次数）之和构成。
算法的时间复杂度由嵌套最深层语句的频度决定
分析：显然，语句①的频度是1。设语句2的频度是f(n)，则有：
2
f (n)
n
即f(n)≤log2n，取最大值f(n)=log2n
31
备注：
算法的时间复杂度除了与问题的规模 n有关外，有时还与 特定的输入数据集不同而不同。例如，在一个长度为n的一维 数组中按顺序查找某个数x。如果第1个数正好是该数x，则只 需查找一次，其时间复杂度为 O(1) ，把这种情况下的时间复 杂度称为最好时间复杂度； 如果最后一个是该数x或不存在该数，则需查找n次，其时 间复杂度为 O(n) ，同理把这种情况下的时间复杂度称为最坏 时间复杂度。多数情况下则考虑所有可能输入数据集的期望 值，由此得到的时间复杂度称为平均时间复杂度。
(完整word版)数据结构,清华大学出版社,严蔚敏吴伟民编著
第一章绪论1、数据结构是计算机中存储、组织数据的方式。
精心选择的数据结构可以带来最优效率的算法。
2、程序设计= 算法+数据结构3、解决问题方法的效率：跟数据的组织方式有关跟空间的利用效率有关跟算法的巧妙程度有关4、数据：所有能输入到计算机中,且被计算机处理的符号的集合，是计算机操作对象的总称；是计算机处理的信息的某种特定的符号表示形式。
5、数据元素：数据中的一个“个体” ,数据结构中讨论的基本单位。
相当于“记录” ,在计算机程序中通常作为一个整体考虑和处理。
6、数据项: 相当于记录的“域”, 是数据的不可分割的最小单位如学号。
数据元素是数据项的集合。
7、数据对象：性质相同的数据元素的集合.例如: 所有运动员的记录集合8、数据结构：是相互间存在某种关系的数据元素集合。
9、数据结构是带结构的数据元素的集合。
10、不同的关系构成不同的结构。
11、次序关系：{vai,ai+1>|i=1,2,3,4,5,6}12、 对每种数据结构，主要讨论如下两方面的问题：1） 数据的逻辑结构，数据结构的基本操作；2） 数据的存储结构，数据结构基本操作的实现；13、 数据的逻辑结构：数据之间的结构关系，是具体关系的抽象。
数据结构的基本操作：指对数据结构的加工处理。
14、 数据的存储结构（物理结构）:数据结构在计算机内存中的表示。
数据结构基本操作的实现：基本操作在计算机上的实现（方法）。
15、数据结构的有关概念|线性表「上线性结构!栈［队（仁数据的逻辑结构=i B.非彌結构I 树形结构 J I 图形结构木数据的存储结枸I A 噸序行储 B 链式存储 < 3、数据的运算：檢索.插入.删除*烽改等16、数据元素的 4 类的基本结构 ：① 集合； 数£结构的三个方廁②线性结构：结构中数据元素之间存在一对一的关系；③树形结构：结构中数据元素之间存在一对多的关系；②4 图状结构或网状结构：结构中数据元素之间存在多对多的关系。
数据结构教案
数据结构教案第一章概论教学时间：3学时教学目的：1、理解数据结构的基本概念和术语；2、理解抽象数据类型的表示与实现；3、掌握算法和算法分析。
教学内容：什么是数据、数据元素、数据对象、数据结构、逻辑结构和存储结构、数据类型、抽象数据类型、算法的定义、算法的特性、算法的时空代价1.1基本概念和术语数据(data)：是对客观事物的符号表示，在计算机科学中是指所有能输入计算机中并被计算机程序处理的符号的总称。
它是计算机程序加工的“原料”。
例如，一个利用数值分析方法解代数方程的程序，其处理对象是整数和实数；一个编译程序或文字处理程序的对象是字符串。
因此，对计算机而言，数据的含义极为广泛，如图象，声音等都可以通过编码而归数据的范畴数据元素(data element)：是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。
有时，一个数据元素可由若干个数据项组成。
数据项是不可分割的最小单位。
数据对象(data object)：是性质相同的数据元素的集合，是数据的一个子集。
数据结构(data structure)：是相互之间存在一种或多种特定关系的数据元素的集合。
数据元素都不是孤立存在的，而是在它们之间存在着某种关系，这种数据元素相互之间的关系称为结构(structure)。
包括三方面内容：(1)数据元素之间的逻辑关系，也称为数据的逻辑结构；(2)数据元素及其关系在计算机存储器内的表示，称为数据的存储结构；(3)数据的运算，即对数据施加的操作。
数据的逻辑结构：是从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机，包括两大类：(1)线性结构：特征是有且仅有一个开始结点和一个终端结点，其余的结点有且仅有一个直接前趋和一个直接后继。
如：线性表、栈、队列。
(2)非线性结构：特征是一个结点可能有多个直接前趋和直接后继。
如：广义表、树、图。
数据的存储结构：是逻辑结构用计算机语言的实现。
有四种存储方式：(1)顺序存储方法：是用一组连续的存储单元把逻辑上相邻的结点存储在物理位置上相邻的存储单元里；(2)链式存储方法：是用一组不一定连续的存储单元存储逻辑上相邻的结点，结点间的逻辑关系是由附加的指针域表示的。
第1章概论-1
• 数据结构（C语言版），王晓东编著，电 数据结构（ 语言版），王晓东编著， ），王晓东编著 子工业出版社 • 数据结构题型、题集、题解，刘坤起等 数据结构题型、题集、题解， 著，清华大学出版社 • 数据结构习题与解析，李春葆著，清华 数据结构习题与解析，李春葆著， 大学出版社
考核方法
卷面成绩 平时成绩 课程设计
抽象数据类型可以通过固有的数据类型（如整型、 实型、字符型等）来表示和实现。 例:求两个复数的和。 ADT Complex{ 数据对象：D={e1,e2|e1,e2属于Realset} 数据关系：R={<e1,e2>|e1是复数的实数部分,e2是 复数的虚数部分} 基本操作： InitComplex(&Z,v1,v2) 操作结果：构造复数Ｚ，其实部和虚部分别被赋以 参数v1和v2的值。
20
a2 a5
a3 a6
通常，数据元素之间的关系有 类 通常，数据元素之间的关系有4类：
集合结构： 集合结构： 仅同属一个集合 线性结构: 一对一（ 线性结构 一对一（1:1) 树 结 构: 一对多（ 一对多（1:n)
非线性 线性
图 结 构: 多对多 (m:n)
21
数据结构的形式定义为： 数据结构的形式定义为：
NEW={ }; for 每个顶点 ∈ V1 do 每个顶点v if v与NEW中所有结点间都没有边 与 中所有结点间都没有边 { 从V1中去掉 ; 中去掉v NEW=NEW∪{v} ; ∪ }
15
概括地说,数据结构的主要研究内容： 概括地说 数据结构的主要研究内容：P3 数据结构的主要研究内容
• 1、非数值计算的程序设计问题中的数学模型； 、非数值计算的程序设计问题中的数学模型 数学模型； • 2、数学模型在计算机中的表示方法； 、数学模型在计算机中的表示方法； • 3、对数学模型进行的操作如何在计算机中实现。 、对数学模型进行的操作如何在计算机中实现。
本章主要介绍以下内容
第1 章绪论本章主要介绍以下内容1、数据结构中涉及的基本概念、术语及所研究的主要内容2、本教材使用的描述工具本章重点和难点：1、数据结构、数据类型、ADT、算法等重要概念。
用计算机求解任何问题都离不开程序设计，而程序设计的实质是数据表示和数据处理。
数据要能被计算机处理，首先必须能够存储在计算机的内存中，这项任务称为数据表示，数据表示的核心任务是数据结构的设计；一个实际问题的求解必须满足各项处理要求，这项任务称为数据处理，数据处理的核心任务是算法设计。
数据结构课程主要讨论数据表示和数据处理的基本问题。
本章将概括地介绍数据结构的基本概念、基本思想和基本方法。
1.1 数据结构的兴起和发展数据结构起源于程序设计。
随着计算机科学与技术的不断发展，计算机的应用领域已不再局限于科学计算，而更多地应用于控制、管理等非数值处理领域。
与此相应，计算机处理的数据也由纯粹的数值发展到字符、表格、图形、图象、声音等具有一定结构的数据，处理的数据量也越来越大，这就给程序设计带来一个问题：应如何组织待处理的数据以及数据之间的关系（结构）。
1968 年克努思教授[1]开创了数据结构的最初体系，他所著的《计算机程序设计艺术》第一卷《基本算法》是第一本较系统地阐述数据的逻辑结构和存储结构及其操作的著作。
70 年代初，数据结构作为一门独立的课程开始进入大学课堂。
数据结构随着程序设计的发展而发展。
程序设计经历了三个阶段：无结构阶段、结构化阶段和面向对象阶段，相应地，数据结构的发展也经历了三个阶段：⑴无结构阶段。
40~60 年代，计算机的应用主要针对科学计算，程序设计技术以机器语言/ 汇编语言为主，程序处理的数据是纯粹的数值，数据之间的关系主要是数学公式或数学模型。
这一阶段，在人类的自然语言与计算机编程语言之间存在着巨大的鸿沟，程序设计属于面向计算机的程序设计，设计人员关注的重心是使程序尽可能地被计算机接受并按指令正确执行，至于程序能否让人理解并不重要。
第一章概论
本课程教学安排
第一章 第二章 第三章 第五章 第六章 第七章 第九章 第八章 概论（4学时） 线性表（10学时） 栈和队列（5学时） 多维数组和广义表（4学时） 树（11学时） 图（12学时） 查找（10学时） 排序（8学时）
数据元素在计算机内的表示：结点集合到物理存储空 间的映射 数据元素间关系在计算机内的表示：关系元组映射为 相应的存储单元间的关系
（3）数据的运算：对数据施加的 操作。
数据结构的分类
按照数据的逻辑结构，可以将数据结构分为 两大类： （1）线性结构：有且仅有一个开始结点和一 个终端结点，其余结点只有一个直接前趋 和一个直接后继。 （2）非线性结构：一个结点可以有多个直接 前趋和直接后继。
数据结构：相互之间存在一种或多种特定关系的 数据元素的集合。包含三方面的内容： （1）数据元素间的逻辑关系（逻辑结构）：从逻 辑关系上描述数据，独立于计算机且与数据的存 储无关。可以看做是从具体问题抽象出来的数学 模型。
（2）数据的存储结构
逻辑结构在计算机中的物理存储表示。在高 级语言层次上讨论。
0
A B
1
0
0
0
1
0
1
1
1
1
1
E
F
0
1
0
0 1 1
0
1 1 1
1
0 0 1
1
0 0 1
1
1 1 0
D
C
1 1
图着色问题
最少着色分组的最优解问题是NP复杂性问题 穷举法或回溯法来解决地图着色问题。对于 小型图可以使用 对于大型模式，由于时间的指数上升，不可 接受 指数级或NP问题往往通过一些逼近方法来求 近似最优解
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
练习题
1. 下列程序段的时间复杂度为________________。 product = 1; 一个算法的时间复杂度 for (i = n;i>0; i--) for (j = 1; j<=n; j++) 是算法输入规模的函数 product *=j; • 时间复杂度量级为 O(n2)
38
2. 下列程序段的时间复杂度为________________。 product = 1; for (i = n;i>0; i--) for (j = i; j<=n; j++) product *=j; • 基本操作执行次数 T(n)=1+2+…+n= (n+1)n/2 • 时间复杂度量级为 t(n)=O(n2)
2
3.课程重要性 1，学习计算机程序设计的基础科目 2，硕士研究生入学考试必考科目
3
4.教学内容 线性表：顺序表，链表，顺序栈，链栈 顺序队，链队，串 数组和广义表: 树：二叉树，线索二叉树，树和森林，哈夫曼树 图：存储，遍历，生成树，最短路径，拓扑排序 排序：插入排序，交换排序，选择排序，归并排序 查找：线性表查找，树形查找，散列技术 文件：顺序文件，索引文件，散列文件
算法必须使用某种语言描述： 程序（计算机语言） 伪语言算法 非形式算法（自然语言）
本教材中使用了类C语言描述算法
27
算法五大特性： 1. 有穷性 2. 确定性 3. 有零个或多个输入 4. 有一个或多个输出 5. 有效性
算法设计的目标： 正确性 可读性 健壮性 高效率 低存储量需求
41
作业：
P40
13 14 15 16 17
请将作业写在作业本上，下次上课前上交办公室B4028
42
习题
1.数据结构是一门研究非数值计算的程序设计问题 计算 机的 以及它们之间的 和运算等的学科。 1）A.数据元素 B.计算方法 C.逻辑存储 D.数据映像 2）A.结构 B.关系 C.运算 D.算法
}
30
}
问题的规模： 算法求解问题的输入量，一般用n表示 时间复杂度： 问题规模n的函数T(n)=所有语句频度之和 n趋向无穷大时， 把T(n)的数量级称为渐进时间复杂度
n=100； x=0； for(i=1;i<=n; i++) x=x+i
n值为100 T(n)=1 + 1 + n 取渐进时间复杂度为n 记做：O(n)
13
数据特点： 每个学生的信息占据一行，所有学生的信息按学号顺 序依次排列构成一张表格；
表中每个学生的信息依据学号的大小存在着一种前后 关系，这就是我们所说的线性结构； 对它的操作通常是插入某个学生的信息，删除某个 学生的信息，更新某个学生的信息，按条件检索某个 学生的信息等等。
14
基本术语
31
问题的规模： 算法求解问题的输入量，一般用n表示 时间复杂度： 问题规模n的函数T(n)=所有语句频度之和 n趋向无穷大时， 把T(n)的数量级称为渐进时间复杂度
n=100；x=0； for(i=1;i<=n; i++) for(j=1;j<=n; j++) x=x+1;
n值为100 T(n)=1 + 1 + n2 取渐进时间复杂度为n2 记做：O(n2)
数据结构
课程代码02331
1
1.课程类别： 本课程是计算机专业的专业基础课，主要介绍如何 合理地组织数据、有效地存储和处理数据，正确地 设计算法以及对算法的分析和评价。
2．教学目的： 通过本课程的学习，使学生深透地理解数据结构的 逻辑结构和物理结构的基本概念以及有关算法，培 养基本的、良好的程序设计技能，编制高效可靠的 程序，为学习操作系统、编译原理和数据库等课程 奠定基础。 程序 = 算法 + 数据结构
24
数据结构主要研究：
25
常用运算
加工型运算：其操作改变原逻辑结构的值 如：结点个数，结点内容等 引用型运算：其操作不改变原逻辑结构的值
• 查找 • 读取 • 插入 • 删除 • 更新 以上操作哪些是加工型操作，那些是引用型操作？
26
1.3算法的描述与分析
算法 规定求解给定类型问题所需的所有“处理步骤”及执 行顺序，使给定类型问题能在有限时间内被机械的求 解
n=10; for(i=0;i<=n-1; i++) 12 if( a[i] == 10 ) return i; 找12时，比较执行了1次 找10时，比较执行了10次
33
算法的时空性 是指算法的时间复杂度和空间复杂度 算法分析主要分析算法的 时间复杂度和空间复杂度，目的是提高算法的效率
34
void max1(int a,b,c,d)
4
5.考核方式 实践性考核（主考院校统考） 主考院校成绩50%，平时成绩50%
5
目录
第1章 概论 第2章 线性表 第3章 栈和队列 第4章 串 第5章 多维数组和广义表 第6章 树 第7章 图 第8章 排序 第9章 查找 第10章 文件
6
第1章 概论
1.1基本概念和术语 1.2学习数据结构的意义 1.3算法的描述与分析
36
此算法的最坏时间复杂度和平均时间复杂度均为n的 函数：T(n)= n2 + n3 T(n)与 n3的数量级相同 称此算法的时间复杂度量级为O(n3)，记作T(n)= O(n3) 一般我们将O(n3)称作时间复杂度 常见时间复杂度量级大小比较： O(1) < O(log2n) < O(n) < O(nlog2n) < O(n2) < O(n3) < O(2n) 我们将时间复杂度记为数据规模n的函数， 若求解问题需要执行n2次操作则，记作O(n2)
数据逻辑结构两大类：
线性结构： 仅有一个开始结点和一个终端结点 其余结点仅有一个直接前趋和一个直接后继 非线性结构 每个结点可有多个直接前趋和多个直接后继 逻辑结构与数据元素本身形式、内容无关 逻辑结构与数据元素的相对位置无关 逻辑结构与所含结点个数无关
15
数据的逻辑结构可归结为以下四类: 线性结构
28
一个算法首先应是正确的，此外考虑： 1. 执行算法所需时间 2. 执行算法所耗费存储空间（辅助空间） 3. 算法易于理解，易于编码，易于调试
算法所耗时间： 算法中每条语句执行时间之和 每条语句执行时间： 每条语句执行次数与该语句执行一次时间的乘积
语句执行的次数称为频度
29
例1-2
设变量a、b、c、d中各含一个整数。求a、 b、c中的最大值与d的乘积
索引存储： 建立索引 借助索引表中的索引指示各存储节点的存储位置
19
基本术语
数据存储结构
四种基本存储方法：
散列存储： 利用散列函数 用散列函数指示各节点的存储位置
20
1.2 学习数据结构的意义
算法 + 数据结构 = 程序
21
应用举例1——学籍档案管理
学号 99070101 姓名 李军 性别 男 出生年月 80.12 …… 学号 99070104 姓名 单晓宏 性别 男 出生年月 81.3
32
以算法在所有输入下的计算量的最大值作为算法的 计算量，称为算法的最坏情况时间复杂度
以算法在所有输入下的计算量的加权平均值作为算 法的计算量，称为算法的平均情况时间复杂度
最坏情况时间复杂度和平均情况时间复杂度通称为 时间复杂度
a={12,23,34,22,43,45,65,32,90,10};
2.数据结构被形式地定义为 (K, R)，其中K是__的有限 集，R是K上的__有限集。 1 A.算法 B.数据元素 C.数据操作 D.逻辑结构 2 A.操作 B.映像 C.存储 D.关系
3.在数据结构中，从逻辑上可以把数据结构分（ ）。 A.动态结构和静态结构 B.紧凑结构和非紧凑结构 C.线性结构和非线性结构 D.内部结构和外部结构
39
3. 下列程序段的时间复杂性量级是_____________。 for (i=1;i<n; i++) for (j=1; j<i; j++) t=t+1; • 基本操作执行次数 T(n)=0+1+2+…+(n-2)= (n-1)(n-2)/2
• 时间复杂度量级为
t(n)=O(n2)
40
4. 算法分析的目的是（ ） A、找出数据结构的合理性 B、研究算法中的输入和输出的关系 C、分析算法的效率以求改进 D、分析算法的易懂性和文档特点
算法max1和max2的最坏情况时间复杂度分别为5和3
35
例矩阵运算—矩阵乘法 Void matrixmlt ( ……) { for(i=0;i<n;i++) for(j=0;j<n;j++) { C[i][j]=0; for(k=0;k<n;k++) C[i][j]+=A[i][k]*B[k][j] ; } } 此程序基本操作执行多少次？？数据规模是多少？
22
应用举例2——制定教学计划 在制定教学计划时，需要考虑：
各门课程的开设顺序，即有些课程需要先导课
程，有些课程则不需要，而有些课程又是其他课
程的先导课程。
23
应用举例2——制定教学计划
计算机专业学生的必修课程 课程编号 C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12 课程名称 程序设计基础 离散数学 数据结构 汇编语言 算法分析与设计 计算机组成原理 编译原理 操作系统 高等数学 线性代数 普通物理 数值分析 需要的先导课程 编号 无 C1 C1，C2 C1 C3，C4 C11 C5，C3 C3，C6 无 C9 C9 C9，C10，C1