数据结构
- 第一章
- 第二章 线性表
- 1.线性表的顺序存储
- 1.1线性表的基本操作
- 1.2线性表的定义
- 1.2.1静态分配
- 1.2.2动态分配
- 1.2.3初始化语句
- 1.3基本操作的实现
- 1.3.1顺序表的初始化
- 1.3.2插入操作
- 1.3.3删除操作(删除第i个位置元素）
- 1.3.4查找操作
- 1.3.5增加动态数组长度
- 2.线性表的链式存储
- 2.1单链表的定义
- 2.2单链表的基本操作实现
- 2.2.1单链表的初始化
- 2.2.2求表长
- 2.2.3按序号查找表结点
- 2.2.4按值查找表结点
- 2.2.5插入结点操作(前插)
- 2.2.6删除结点操作
- 2.2.7采用头插法建立单链表
- 2.2.7采用尾插法建立单链表
- 2.3双链表
- 2.3.1双链表的插入操作
- 2.3.2双链表的删除操作
- 2.4循环链表
- 2.4.1循环单链表
- 2.4.2循环双链表
- 2.5静态链表
- 2.6顺序表和链表的比较
- 存取方式
- 逻辑结构和物理结构
- 查找，插入和删除操作
- 空间分配
- 3.实际中选取存储结构
- 3.1基于存储的考虑
- 3.2基于运算的考虑
- 3.3基于环境的考虑
- 3.4总结
第一章
1.数据是信息的载体。
2.数据项，数据元素和数据对象之间的关系。
3.数据对象就是数据子集。
4.数据元素之间的关系————数据结构。
5.数据结构
6.算法特性：有穷性，确定性，可行性，输入，输出
算法目标：正确性，可读性，健壮性，高效率，低存储
7.算法有穷，程序无穷。
8.时间复杂度是语句执行频度。
9.加法：O(f(n)) + O(g(n)) = O(max( f(n) , g(n) ))
乘法：O(f(n)) * O(g(n)) = O( f(n) * g(n) )
10.时间复杂度排列顺序(常对幂指阶)
O(1) < O(logn) <O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
-
时间复杂度等于递归调用深度。
-
如何计算时间复杂度
int i = 1； while(i < = n) i = i * 2; //先设执行t次，则代入最里面等式（只有n与t的等式） 2^t <= n t <= logn O(logn)第二章 线性表
1.数据结构的三要素：逻辑结构，存储结构和数据的运算。
2.所有整数按照递增排序不是线性表，因为无限。
3.linear list 相同数据类型组成的有序序列。
表位序从1开始，数组下标从0开始。
4.顺序表 + 链表 = 线性表。
1.线性表的顺序存储
1.1线性表的基本操作
数组基本操作 IninList(&L):初始化表，构造一个空表。 Length(L):求表长，返回线性表长度，机元素个数。 LocationElem(L,i):按值查找操作。 GetElem(L,i):按位查找操作。获取第i个位置的值。 ListInsert(&L,i,e):插入操作，在表中第i个位置插入元素e。 ListDelete(&L,i,&e):删除元素，删除表中第i个位置的元素并将其值返回给e。 PrintList(L):输出操作，按照前后顺序输出表中所有元素的值。 Empty(L)：判空操作，判断L是否为空表。 DestroyList(&L):销毁操作，销毁线性表并释放空间。1.2线性表的定义
1.2.1静态分配
#define MaxSize 50 typedef struct{ ElemType data[MaxSize]; int length; //表长 }Sqlist;1.2.2动态分配
#define InitSize 50 typedef struct { ElemType *data; //指针指向第一个数据元素 int MaxSize,length; //数组的最大容量和当前长度 }Sqlist; //Sq == squence 顺序1.2.3初始化语句
L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize); //申请一片内存并将data指针指向其地址段的首地址1.3基本操作的实现
1.3.1顺序表的初始化
静态
//SqList L;//声明一个顺序表 void InitList(SqList &L){ L.length = 0; //顺序表初始长度为0 }动态
//SqList L; void InitList(SqList &L){ L.data = (int *)malloc(InitSize*sizeof(ElemType));//分配空间 L.length = 0; L.MaxSize = InitSize; //初始存储容量 }1.3.2插入操作
bool ListInsert(SqList &L,int i,ElemType e){ //判断i值是否合法 if (i < 1 || i > L.length + 1) return false; //判断空间满 if (L.length >= MaxSize) return false; //依次后移并插入 for (int j = L.length; j >= i; j--) L.data[j] = L.data[j-1]; L.data[i-1] = e; //长度加1 L.length ++; return true; }1.3.3删除操作(删除第i个位置元素）
bool ListDelete(SqList &L,int i,ElemType &e){ //判断i值 if(i < 1 || i > L.length) return 0; //删除值赋值给e e = L.data[i-1]; //依次前移并覆盖 for(int j = i; j < L.length;j++) L.data[i-1] = L.data[i]; //长度减1 L.length--; return true; }1.3.4查找操作
//按值查找操作 int LocateElem(SqList &L,ElemType e){ int i; for(i = 0;i < L.length;i++){ if(L.data[i] == e) return i+1; } return 0; } //假设结构体a,b,则不能用“==”，若判定是否相同则用"(a.num == b.num && a.people == b.peope)"来判断 //按位查找操作----取第i个元素 int GetElem(Sqlist L,int i){ return L.data[i-1]; }1.3.5增加动态数组长度
void InCreaseSize(Sqlist &L,int len){ int *p = L.data; L.data = (int *)malloc((L.MaxSize + len)* sizeof(int)); for (int i = 0;i < L.length;i++){ L.data[i] = p[i]; } L.MaxSize = L.MaxSize + len; }2.线性表的链式存储
2.1单链表的定义
typedef struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域，指向下一个结点区域 }LNode,*LinkList; //或者 struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域，指向下一个结点区域 }; typedef struct LNode LNode; typedef struct LNode *LinkList; //定义指向结构体指针 LNode *L;强调指向结点L LinkList L;强调这是一个单链表L的头指针2.2单链表的基本操作实现
2.2.1单链表的初始化
//带有头结点 bool InitList(LinkList &L){ // 创建带有头节点的单链表 L = (LNode *)malloc(sizeof(LNode)) //创建一个LNode型的结点并将结点的起始地址赋值给L L -> next = NULL; return true; } //不带有头结点 bool InitList(LinkList &L){ L = NULL; return true; } //判空操作 //带头结点 bool Empty(LinkList L){ if (L -> next == NULL) return true; else return false; } //不带头结点 bool Empty(LinkList L){ if(L == NULL) return true; else return false; }2.2.2求表长
//带头结点，表头不包括头结点 int Length(LinkList L){ int len = 0; LNode *p = L; while( p->next !- NULL){ p = p -> next; len ++; } return len; }2.2.3按序号查找表结点
//带头结点 LNode *GetElem(LinkList L,int i){ LNode *p = L; int j = 0; while(p != NULL&&j < i){//头结点是第0个 p = p->next; j++; } return p; }2.2.4按值查找表结点
LNode *LocateElem(LinkList L,ElemType e){ LNode *p = L; while(p != NULL&&p->data != e){ p = p->next; } return p;//返回该节点指针，否则NULL }2.2.5插入结点操作(前插)
//在第i个位置插入结点，则在第i-1个结点后插入结点 //带头结点 bool ListInsert(LinkList &L,int i,ElemType e){ LNode *p = L; int j = 0; while(p != NULL&&j < i - 1) P = P->Next; j++; } if(p == NULL){ return false; } LNode *s = (LNode *)malloc(sizeof(LNode)); s->data = e; s->next = p->next; p->next = s; return true; } //不带头结点 bool ListInsert(LinkList &L,int i ,ElemType e){ if(i < 1) return false; if(i == 1){ LNode *s = (LNode*)malloc(sizeof(LNode)); s->data = e; s->next = L L = s; return true; } ...... ...... ...... }扩展：对某一结点进行后插操作
//依然将节点插入后面并交换值 s->next = p->next; p->next = s; temp = p->data; p->data = s->data; s->data = temp;2.2.6删除结点操作
//删除第i个 bool ListDelete(LinkList &L,int i,ElemType &e){ LNode *p = L; int j = 0; while(p!=NULL&&j<i-1){ p = p->next; j++; } if(p == NULL||p->next == NULL) return false; LNode *q = p->next; e = q->data; //前驱结点直接连接后驱结点 p->next = q->next; free(q); return true; }扩展：删除结点可以用删除后继结点的方式实现，若p为最后一个则需要传入头指针方式遍历删除。
//交换值 q = p->next; p->data = p->next->data; p->next = q->next; free(q);2.2.7采用头插法建立单链表
//带头结点 LinkList List_HeadInsert(LinkList &L){ LNode *s;int x; L = (LNode *)malloc(sizeof(LNode)); L->next = NULL; scanf("%d",&x); while(x != 9999){ s = (LNode *)malloc(sizeof(LNode)); s->data = x; s->next = L->next; L->next = s; scanf("%d",&x); } }2.2.7采用尾插法建立单链表
//采用尾指针 LinkList List_TailInsert(LinkList &L){ int x; L = (LNode *)malloc(sizeof(LNode)); LNode *s,*r = L; scanf("%d",&x); while(x!=9999){ s = (LNode *)malloc(sizeof(LNode)); s->data = x; r->next = s; r = s; //r指向s scanf("%d",&x); } r->next = NULL; return L; //返回头指针 }2.3双链表
typedef struct DNode{ ElemType data; struct DNode *prior,*next; }DNode,*DLinkList;2.3.1双链表的插入操作
//在p结点之后插入s结点 s->next = p->next; p->next->prior = s; s->prior = p; p->next = s;2.3.2双链表的删除操作
//删除p结点之后的q结点 p->next = q->next; q->next ->prior = p; free(q);2.4循环链表
2.4.1循环单链表
将单链表的最后一个结点的指针指向头结点
2.4.2循环双链表
将最后一个结点的尾指针指向头结点，将头结点的首指针指向最后一个节点
2.5静态链表
#define MaxSize 50 typedef struct{ ElemType data; int next; }SLinkList[MaxSize];2.6顺序表和链表的比较
存取方式
1.顺序表可以顺序存取也可以随机存取。
2.链表只能从表头开始顺序存取。逻辑结构和物理结构
1.顺序存储时，逻辑上相邻的元素物理存储位置也相邻。
2.链式存储时，逻辑关系通过指针链接表示，物理存储位置也不一定相邻。查找，插入和删除操作
1.按值查找时，顺序表无序时，二者时间复杂度为O(n)，,顺序表有序时，采用折半查找的时间复杂度为O(log2n)。
2.按序号查找时，顺序表时间复杂度为O(1)，链表平均时间复杂度为O(n)。
3.插入，删除时，顺序表平均移动半个表长，链表仅需要移动相关指针域即可。空间分配
1.顺序存储在静态存储分配情形下，一旦存储空间装满就不能扩充， 若再加入新元素，则会出现内存溢出，因此需要预先分配足够大的存储空间。预先分配过大，可能会导致顺序表后部大量闲置； 预先分配过小，又会造成溢出。
2.动态存储分配虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且若内存中没有更大块的连续存储空间，则会导致分配失败。链式存储的结点空间只在需要时申请分配，只要内存有空间就可以分配， 操作灵活、高效。此外，由于链表的每个结点都带有指针域，因此存储密度不够大。
3.实际中选取存储结构
3.1基于存储的考虑
1.难以估计线性表的长度或存储规模时，不宜采用顺序表；
2.链表不用事先估计存储规模，但链表的存储密度较低，显然链式存储结构的存储密度是小于1的。3.2基于运算的考虑
1.在顺序表中按序号访问a;的时间复杂度为0(1),而链表中按序号访问的时间复杂度为0(n), a因此若经常做的运算是按序号访问数据元素，则显然顺序表优于链表。
2.在顺序表中进行插入、删除操作时，平均移动表中一半的元素，当数据元素的信息量较大且表较长时，这一点是不应忽视的;在链表中进行插入、删除操作时，虽然也要找插入位置， 但操作主要是比较操作,从这个角度考虑显然后者优于前者。
3.3基于环境的考虑
顺序表容易实现，任何高级语言中都有数组类型;链表的操作是基于指针的，相对来讲，前者实现较为简单，这也是用户考虑的一个因素。
3.4总结
总之，两种存储结构各有长短，选择哪一种由实际问题的主要因素决定。通常较稳定的线性表选择顺序存储，而频繁进行插入、删除操作的线性表(即动态性较强)宜选择链式存储。
扫一扫
43万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
