阶段小结(一)-线性结构
名词解释 线性结构
名词解释线性结构线性结构又称树型结构，它是一种由若干节点，通过多条边构成的树状结构。
线性结构是对应一个树结构，也就是说一个树只有一个顶点、根节点、每条边都有两个端点。
树的两个结点之间有唯一一条路径相连，无数条边彼此平行且无交叉点。
树中的每条边都可分为左子树与右子树，在树中若将一对子树合称为一个节点，那么合称节点的这对子树则称为“边”。
线性结构最主要的特征是从节点到叶子，所有的边都是互相平行的，即如果某个节点在一条边上，则该节点的所有左子树与所有右子树，必然存在唯一一条路径相连，而其他边则不能。
线性结构简单来说就是无序的，树是线性的，根节点没有上级节点，而且对于根节点本身而言，从左到右没有左右两个端点，因此每一个节点至多有一条子树。
下图是一棵二叉搜索树，一颗普通的二叉树，也是一棵线性结构。
每个节点只能有一条路径和任意一条子树的所有其它节点相连，当从左向右遍历二叉树的时候，一般会先访问根节点，然后再遍历其左右的节点。
叶子上的代码有两种类型，一种是字符串，一种是实体。
字符串代码就是比较简单的数值代码，常用来做为与其它文件的交换。
而实体则需要以代码块的形式出现，它包括两个部分：一个是内部块，表示了其内容；另外一个是外部块，包括了这些代码的路径和返回结果。
如果对于一个字符串来讲，那么外部块必须是由一系列空格所组成的，而内部块是由每个字符串都对应的块组成的。
树和叶子一样，也有线性结构。
这样一来我们就把线性结构分为了树和叶子，其中前者表示自底向上的搜索，而后者表示自顶向下的搜索。
这个问题看似复杂，但其实是有规律可循的，我们先将三种不同的搜索方式展示出来，然后解释了三种方法的基本原理，就比较好理解了。
树可以有很多层，每层的高度与层数成反比。
线性结构，顾名思义，就是一种有层次的结构。
当一个有序集合X满足下列条件时，就可以将X归类为一个线性结构： X包含于一个有限集合R且与X有相同的元素或者有一个不等于0的元素，那么X就是一个线性结构。
数据结构-线性结构
数据结构-线性结构数据结构线性结构在计算机科学的世界里，数据结构就像是搭建高楼大厦的基石，为程序的高效运行提供了坚实的基础。
而线性结构，则是众多数据结构中最为基础和常见的一类。
想象一下，你有一堆物品需要整理，你会怎么做？也许你会把它们排成一排，一个接一个，这就是线性结构的基本概念。
简单来说，线性结构中的数据元素按照顺序依次排列，就像排队的人们，每个元素都有唯一的前驱（除了第一个元素）和唯一的后继（除了最后一个元素）。
线性表是线性结构的典型代表。
它可以分为顺序表和链表两种实现方式。
顺序表就像是一排紧密相连的座位，每个座位上都有一个数据元素。
由于这些元素在内存中是连续存储的，所以读取数据非常方便快捷。
但如果要插入或删除元素，就可能需要移动大量的数据，就像在一排坐满人的座位中插入或移除一个人，后面的人都得跟着挪动位置，这会比较费时。
链表则不同，它更像是用链子把一个个数据元素串起来。
每个元素除了存储自身的数据，还包含指向下一个元素的指针。
这样，插入和删除元素就变得相对简单，只需要调整几个指针的指向就行了。
但要访问链表中的某个元素，就需要顺着指针一个一个地找过去，效率相对较低。
栈和队列也是常见的线性结构。
栈就像是一个只能从一端进出的筒子，先进去的元素会被压在下面，后进去的元素在上面，所以取出元素的时候，是后进去的先出来，这就是所谓的“后进先出”原则。
比如，浏览器的后退功能就可以用栈来实现，每次访问新的页面就把当前页面压入栈中，后退时就从栈顶取出之前的页面。
队列则像是排队买票的队伍，先到的先服务，即“先进先出”。
在操作系统的任务调度中，经常会用到队列，新的任务进入队列等待执行，先进入的任务先被处理。
线性结构在日常生活和计算机程序中都有着广泛的应用。
比如，我们在图书馆排队借书，这就是一个队列的例子；我们把要做的事情列成一个清单，这就是一个线性表。
在计算机程序中，线性结构更是无处不在。
当我们处理一组按照特定顺序排列的数据时，线性结构往往是首选。
线性结构的心得体会
线性结构的心得体会篇一：实验总结报告-栈和队列实验总结报告—栈和队列学号：姓名：时间：一、目的1.做实验的目的加深对线性结构栈和队列的理解，学会定义栈和队列的存储结构，加强对栈和队列操作机制的理解，掌握栈和队列的基本操作，了解栈和队列的一些应用。
2.撰写实验报告的目的对本次实验情况进行总结，加强对实验内容的理解，对实验过程有一个系统的认识，从中获得本次试验的经验，并对实验结果进行适当的分析，加深对栈和队列的理解和认识。
二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容：（1）、编写函数CreatStack_sq(), DestoryStack_sq(), Push_sq(), (转载于: 小龙文档网:线性结构的心得体会)Pop_sq(),StackEmpty_sq() 和StackTraverse_sq(),分别完成创建空栈,销毁栈,入栈,出栈,判断栈是否为空,遍历栈底到栈顶依次打印栈内元素等功能(不要修改原栈),完成后进行测试。
测试要求:在main 中,建立栈；判断栈是否为空；将0~9 入栈；将栈顶两个元素出栈,两元素求和后再入栈；从栈底到栈顶依次打印元素,再从栈顶到栈底打印元素；销毁栈。
void CreatStack_sq(SqStack &S, int msize = STACK_INIT_SIZE) {...}void DestoryStack_sq(SqStack &S){...}void Push_sq(SqStack &S, ElementType e){...}bool Pop_sq(SqStack &S, ElementType &e){...bool StackEmpty_sq(SqStack S){...}bool StackTraverse_sq(SqStack S){...}（2）、编写函数, CreateQueue_L() , DestoryQueue_L() , EnQueue_L() ,DeQueue_L(),分别完成创建队列,销毁队列,入队列,出队列等操作,完成后进行测试。
数据结构之线性结构和非线性结构
数据结构之线性结构和⾮线性结构线性结构：⼀、概念1. 线性结构作为最常⽤的数据结构，其特点是数据元素之间存在⼀对⼀的线性关系。
2. 线性结构拥有两种不同的存储结构，即顺序存储结构和链式存储结构。
顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的，链式存储的线性表称为链表，链表中的存储元素不⼀定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
3. 线性结构中存在两种操作受限的使⽤场景，即队列和栈。
栈的操作只能在线性表的⼀端进⾏，就是我们常说的先进后出（FILO），队列的插⼊操作在线性表的⼀端进⾏⽽其他操作在线性表的另⼀端进⾏，先进先出（FIFO），由于线性结构存在两种存储结构，因此队列和栈各存在两个实现⽅式。
⼆、部分实现1. 顺序表（顺序存储） 按照我们的习惯，存放东西时，⼀般是找⼀块空间，然后将需要存放的东西依次摆放，这就是顺序存储。
计算机中的顺序存储是指在内存中⽤⼀块地址连续的空间依次存放数据元素，⽤这种⽅式存储的线性表叫顺序表其特点是表中相邻的数据元素在内存中存储位置也相邻，如下图：1 // 倒置线性表2 public void Reverse()3 {4 T tmp = default(T);56 int len = GetLength() - 1;7 for (int i = 0; i <= len / 2; i++)8 {9 if (i.Equals(len - i))10 {11 break;12 }1314 tmp = data[i];15 data[i] = data[len - i];16 data[len - i] = tmp;17 }18 }2. 链表（链式存储） 假如我们现在要存放⼀些物品，但是没有⾜够⼤的空间将所有的物品⼀次性放下（电脑中使⽤链式存储不是因为内存不够先事先说明⼀下...，具体原因后续会说到），同时设定我们因为脑容量很⼩，为了节省空间，只能记住⼀件物品位置。
数据结构自学总结(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*/三．线性结构的常见应用之一------------------栈定义:一种可以实现'先进后出' 的存储结构。
线性结构
空表时：L=NIL 空表时：
2.3 线性表的链式存储结构
struct node { elemtype data; struct node* next; }; node为一记录，它由data和next两项组成； 为一记录，它由 为一记录 和 两项组成； next为一指针，指向node记录类型； 为一指针，指向 记录类型； 为一指针 记录类型 为数据域； data为数据域； 为数据域
2.3 线性表的链式存储结构
2． 带头结点的线性链表 ． 在线性链表的第一个元素结点之前附设一个结点 称头结点），它的数据域不存储任何信息， ），它的数据域不存储任何信息 （称头结点），它的数据域不存储任何信息，其指针 域存储第一个元素结点的存储位置。头指针L指向该 域存储第一个元素结点的存储位置。头指针 指向该 头结点。 头结点。 空表时： ↑ 空表时：L↑．next=NIL 带头结点链表的引入是为了使算法判空和处理一致。 带头结点链表的引入是为了使算法判空和处理一致
2.2 线性表的顺序存储结构
插入算法时间复杂度分析: 插入算法时间复杂度分析: 最坏情况是在第1 最坏情况是在第1个元素前插入 (i=1)， (i=1)， 此时,要后移n个元素，因此， 此时,要后移n个元素，因此，
T（n）=O（n） =O（DELETE（ 2. 删除运算DELETE（L,i）
2.3 线性表的链式存储结构
初始化算法：
elemtype initlist(node * * h) { *h=(node *)malloc(sizeof(node)); (*h)->next=null; }
2.3 线性表的链式存储结构
3． 几种基本运算在单链表上的实现 ． （1）GET(L，i)函数
线性结构总结
教学单元一：线性结构一、知识点总结知识点我的总结（可以对课堂相对应的知识点进行总结）（建议图文并茂，标识重难点）掌握程度自评（1-5分）5分表示掌握的非常最好线性表的顺序存储●线性表的顺序存储：线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。
●通常用数组来描述数据结构中的顺序存储结构重点：线性表的顺序存储示意图难点：结构体定义●顺序存储的优点与缺点：线性表的顺序存储结构，在存、读数据时，不管哪个位置，时间复杂都是O(1)；而插入和删除时，时间复杂度都是O(n)优点：可以快速的存取任一位置的元素。
缺点：插入和删除元素时将移动大量元素。
5分线性表的链式存储●线性表的链式存储：线性表的链式存储：是用一组任意的存储单元存储线性表的数据元素，这组数据元素可以是连续的，也可以是不连续的。
●单链表与顺序表优缺点对比：(1)若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构。
若需要频繁插入和删除时，宜采用单链表结构。
(2)当线性表中的元素个数变化较大或者根本不知道多大时，最好采用单链表结构，这样可以不用考虑存储空间大小问题。
而如果事先知道线性表的大致长度，例如一年2个月这种用顺序存储结构效率会高很多。
重点：线性表的链式存储示意图●结构体定义●链表的初始化1.首先为头节点开辟空间使用malloc(sizeof())结构;也可采用无头结点的链表2.采用头插法或者尾插法，此处示例尾插法难点：插入节点和删除节点插入：删除：5分●双向列表●循环链表顺序查找和折半查找●顺序查找的概念：顺序查找也称为线性查找，属于无序查找算法。
从数据结构线性表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。
重点：顺序查找的示意图（请点击播放）●顺序查找时间复杂度：查找成功时的平均查找长度为：（假设每个数据元素的概率相等）ASL=(1/n)∗(1+2+3+…+n)=(n+1)/2ASL=(1/n)∗(1+2+3+…+n)=(n+1)/2 ；当查找不成功时，需要n+1次比较，时间复杂度为O(n)；所以，顺序查找的时间复杂度为O(n)●二分查找的概念：二分查找也称为是折半查找，属于有序查找算法。
名词解释 线性结构
名词解释线性结构线性结构是指一种平衡系统的结构，其特点是各组成要素和子系统之间保持严格的比例关系。
如果该点上具有行政权利的人数少于可容纳的最大人数，则称该结构为线性结构；而反之，则为非线性结构。
其实，很多事物都属于线性结构，它们通过简单的叠加便能产生复杂的功能。
比如说，运动中的个人，整个团队，乃至国家和地区，也可以看作是一个典型的线性结构。
这就是非线性科学最本质的概念，只不过在中国历史上被长期忽略罢了。
有一句谚语是这么说的：铁打的衙门流水的官。
意思是一个衙门前的官员是会换的，但只要有需要就一定会有新的官员来充实这个衙门的人员配置。
为什么呢？因为官员是需要的，而官员的提升更是需要更多的支持的，所以我们经常可以看到一些官员明明在位时很风光，但一旦退下来或是去世了就难免会落得穷困潦倒，甚至惨死街头。
所以每次改朝换代之后，总是会有无数的人削尖脑袋想方设法谋求官职，他们觉得自己随着官职的升高，就会拥有越来越大的权力，到那时候也就可以为所欲为了。
然而正是这种天真的想法才使得封建王朝走向覆灭。
我们又可以从另一个角度来思考这个问题：一些部门实际管理人员与其所应承担的法律责任之间存在矛盾，这就是我们所谓的官僚主义。
这样的情况下，官员们往往并不直接面对公众，只对上负责，久而久之，这种极端的官僚化必将导致整个政府机构的瘫痪。
与此同时，由于没有人民的监督，一些基层公务人员会利用手中的职权贪污受贿，最终祸害百姓。
线性结构相当于一种社会等级体系，掌握了更高权力的官员自然就处在更高的地位，而处在较低等级的官员虽然会羡慕那些位高权重的官员，但却并不敢有太大的想法，否则极有可能引来杀身之祸。
相反，那些地位较低的官员们则往往心怀鬼胎，既希望成为上级官员的手下，又觊觎着他们的职位。
这样一来，他们就有可能发生行贿受贿或滥用职权的现象，而这两者无论哪一条路都会给国家的财政带来巨大的损失。
中国的官僚政治常常通过“权力依附”形成强大的行政权，以便于皇权维护统治阶级的利益。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
• ……
20
【题目及要求】模拟C++标准库中的string容器，实现自定义 的String类，支持下列程序： 【提示】完成String类的 int main( ) 构造函数、拷贝构造函 { 数、析构函数、赋值运 String s1,s2,s3,s4; 算符、比较运算符、加 cin>>s1>>s2>>s4; 法运算符、流操作符、 s3=s1+s2; find函数、length函数、 cout<<s3<<endl; for(int i=0;i<s3.length();i++) 下标运算符等。 cout<<s3[i]; cout<<endl; //比较两个字符串的大小，按字符顺序 if(s1>s2) cout<<s1<<"is more lager than "<<s2<<endl; //输出s4在s3中位置 cout<<s3.find(s4); return 0; 示例代码 21 }
Brute-Force算法分析
设模式pat有m个字符，而串T有n个字符。
• 最好情况： 若T的前m个字符与pat匹配，则在m次比较后就能找到匹 配结果，因此，最好情况下算法的复杂度为O(m)。 • 最坏情况： 假设不进行比较最后一个字符之类的优化，且第一个字符 总能匹配上，但却永远没有匹配上的模式，如下面这种情况： pat=“aab” T=“aaaaaaaa”（m=3，n=8）
此时模式“abc”的m（m=3）个字符必须和T中的每趟比较到最后才出现不等，则要做m次比较，总 比较次数达到m(n-m+1)次。
由于m(n-m+1) ≤m(n-m+m) =mn
所以算法在最坏情况下的复杂度估计值为O(nm)。
其他的模式匹配算法：
• 首尾匹配算法，O(m*n)
• 散列函数的构造方法
• 冲突的解决：线性开型寻址、链表散列
32
四、课堂练习
练习1
1、计算机执行下面的语句时，语句s的执行次数为 for(i=1;i<n-1;i++) for(j=1;j<=i;j++) s; 。
阶段小结（一）
——线性结构
内容
• • • • 一、线性表合并 二、字符串及String类 三、各章重点回顾 四、课堂练习
2
一、线性表合并
1、顺序表的合并
【题目及要求】如果顺序表LA，LB的数据元素按非递减有 序排列，现要求将LA和LB表中的数据元素合并为一个新的 线性表LC，且LC中的数据元素仍按非递减有序排列。
• • • • • 一个workspace中可有多个project； 一个project中只能有一个main( )； 分散编译； 编码规范； 程序调试。
9
二、字符串及String类
字符串定义
字符串简称为串（string），是n（n≥0）字符的一个有限序列。
一般记为：S=“a0a1a2…an-1” • • 其中，S是串名，可以是串变量名，也可以是串常量名。 用双引号 “”作为分界符括起来的叫做串值；
– 将Merge函数设计成为LinearList类的成员函数； – 写main( )函数测试Merge的正确性； – 可以不写成模板类。 算法演示
4
顺序表合并算法思想
• 【思想】 1、设三个指针（实际是整型变量）i，j，k分别指向LA，LB 和LC中某个元素，初值：i，j为1，k为0； 2、分别从LA和LB中取得i，j所指向的两个元素； 3、比较两元素的大小，谁小就把谁先插入到LC中k所指的位 置； 4、LA或LB中剩余部分直接插入LC中即可。
12
主串和子串
串中任意多个连续的字符组成的子序列称为该串的子串， 包括该子串的串称为主串。一般称子串的首字符（第0个字符） 在主串的中的位置为子串在主串中的位置。 例如：如果S=“software”，P=“war”， 则P是S的子串，P在S中的位置为4 • 空串是任意串的子串，任一串是它自身的子串，除它本身 外，一个串的其他子串都是它的真子串。 例如：串S=“car”，其子串有“”、“c” 、“a” 、“r”、 【结论】如果串长为n，则其子串个数为n(n+1)/2+1个，真子串 “ca”、 “ar”、 个数为n(n+1)/2个。 “car”，共7个，其中真子串6个。
• KMP算法：一种改进的模式匹配算法，其时间复 杂度仅为O(m+n)。
25
三、各章重点回顾
第2章 程序性能
•1、简单搜索（查找）算法 –顺序查找 –折半查找
•2、简单排序算法
–计数排序 –选择排序 –冒泡排序 –插入排序
•3、程序时间复杂性分析 •4、渐近符号O、Ω、Θ
27
第3章 数据描述（线性表）
15
字符串比较
• 字符串大小比较：比较字符串串对应位置上的字符的ASCII 码的大小。 • 如果两个字符串对应位置的字符都相等，且它们长度相等， 则称这两个字符串相等。
16
字符串比较
在比较时，设置一个计数器，从0开始，一直循环到最短的 那个字符结束，一位一位进行比较, • 1、如果 字符串1的第n位的ASCII码值 等于 字符串2的第n位 的ASCII码值则 继续比较下一位 ；
• ai是串中的字符（0≤i<n），可以是ASCII码字符中可打印字 符，通常是字母、数字等字符，i称为字符ai在串中的位置（从0 开始）。 • n是串的长度，即串中字符个数，不包括引号，也不包括串 结束符‘\0’。
11
空串和空格串
• 空串：长度为零的串，除串结束符外，不包括任何其他字符； • 空格串：长度不为零，除串结束符外，还包括其他字符均为 空格。
例如，char str[]=“Data Structure” D a t a S t r u c t u r e NULL
字符串在内存中的存储结构 str
14
字符串的操作
1、求串的长度；
2、把一个串的值赋给另一个串；
3、把两个串连接形成另一个长度为两个串长度之和的新串；
4、比较两个串的大小； 5、在一个串中查找是否存在和另一个串相等的子串； 6、在一个串中是否存在一个字符； 7、截取子串形成一个新串； 8、在一个串中插入一个另一个串； 9、从一个串中删除一个子串。
1、线性结构的特点 2、线性表的公式化描述（顺序表） • 用一组连续的存储单元依次存放线性表中的各数据元素。 • 特点：逻辑结构上相邻的元素其物理结构也相邻。
3、线性表的链式描述（链表）
4、两种存储结构下的插入、删除、查找等操作算法 5、线性表的合并、拆分、逆转等操作算法； 6、线性表的应用
28
第4章 数组和矩阵
• 2、如果 字符串1的第n位的ASCII码值 大于 字符串2的第n位 的ASCII码值，则 输出结果:1，表示字符串1 > 字符串2;
• 3、如果 字符串1的第n位的ASCII码值 小于 字符串2的第n位 的ASCII码值，则输出结果:-1， 表示字符串1 < 字符串2; • 4、如果 每一位的ASCII码值都相等，而且长度相同, 则输出 结果：0 ，表示字符串1 == 字符串2; • 5、如果 字符串1是字符串2的前m位，例如 abcd 与abcdef 比 较, 则字符串1<字符串2.
7
函数的不同形式
template <class T> class Chain { public： Chain<T>& Merge(Chain<T>& hb); void Merge(Chain<T>& hb); void Merge(Chain<T>&ha,Chain<T>& hb); };
8
示例程序
5
函数的不同形式
class LinearList { private： …… public： LinearList& Merge(const LinearList &A,const LinearList &B); LinearList Merge(const LinearList &A,const LinearList &B); void Merge(const LinearList &A,const LinearList &B, LinearList &C); }；
从目标串T=“t0t1…tn-1”的第一个字符开始与模式串 pat=“p0p1…pn-1”的第一个字符比较； 若相等，则继续比较后续字符；否则，从目标串T的第二个 字符开始重新与模式串pat的第一个字符比较。 如此继续，若在目标串T中有一个与模式串相等的连续字符 序列，则匹配成功，函数返回串pat的首字符在串T中的位置； 22 否则，匹配失败，函数返回-1。
17
串的特点
• 串的逻辑结构与线性表极为相似，区别仅在于串的数据对 象约束为字符； • 串的基本操作和线性表有很大差别：在串的基本操作中， 通常以“串的整体”作为操作对象。
18
常用的C++字符串函数
C++的串库（cstring）中提供了许多字符串操作函数，例 如常用的有：
1、串长度 int strlen(char *str); 2、串拷贝 char *strcpy(char *str1,char *str2);
30
第6章 队列
1、队列的结构特点：FIFO
2、队列的顺序存储表示——循环队列（重点）
• 循环队列队空、队满的条件 • 循环队列的插入、删除
3、队列的链式存储表示——链式队列
• 链式队列无溢出问题，空间可扩充 • 插入与删除分别在队尾和队头处执行 • 适合于多队列操作