文章目录
- **一 基本概念**
- **二 算法和算法评价**
- **三 线性表的定义和基本操作**
- **四 线性表的顺序表示**
- **1 定义**
- **2 基本操作**
- **五 线性表的链式表示**
- **1 单链表的定义**
- **2 单链表的基本操作实现**
- **3 双链表**
- **4 循环链表**
- **5 静态链表**
一 基本概念
数据类型:(1)原子类型:不可再分的,如int,char
(2)结构类型:可以再分解若若干成分,如
struct lnode
{int a;char C;
}LNODE;
(3)抽象数据类型:抽象数据组织及与之相关的操作,如栈(Stack)就是一种抽象数据类型。栈是一种具有后进先出(Last-In-First-Out,LIFO)特性的数据结构,它支持两个基本操作:压栈(Push)将元素添加到栈顶,弹栈(Pop)将栈顶元素移除并返回。
算法:对特定问题求解步骤的一种描述,是指令的有限序列
一个算法的设计取决于所选定的逻辑结构;算法的实现依赖于所采用的存储结构
数据结构分为两类:
(1)逻辑结构
数据元素间的逻辑关系
(2)存储结构
数据结构在计算机中的表示,又称物理结构
主要有顺序存储,链式存储,索引存储和散列(哈希)存储
散列存储:根据元素的关键字(散列函数)直接计算元素的存储地址
二 算法和算法评价
算法的特性:有穷性,确定性,可行性,输入,输出
一个好的算法:可读性,正确性,健壮性,高效率和低存储量
算法效率的度量:
(1)时间复杂度
通常考虑最坏情况
加法规则:以最大的为准
乘法规则:直接相乘
常见的时间复杂度
O(1)<O(Log2N)<O(N)<O(N*Log2N)<O(N2)<O(N3)<O(2N)<O(N!)<O(Nn)
(2)空间复杂度
算法所耗费的空间,一般是辅助空间
算法原地工作即O(1)
三 线性表的定义和基本操作
线性表是具有相同数据类型的n个元素的有限序列,是一种逻辑结构
即逻辑上每个数据是相邻的;每个元素只有一个直接前驱和直接后继
特点:个数有限,逻辑上的顺序性,每个元素都是单个数据元素,且类型相同
线性表的主要操作
Initlist(&L); \\初始化表
Length(L); \\求表长
LocateELem(L,e); \\按值查找
GetElem(L,i); \\按位查找
ListInsert(&L,i,e); \\插入操作
Listdelete(&L.i,&e);\\删除操作
PrintList(L); \\输出操作
Empty(L); \\判空操作
DestroyList(&L); \\销毁操作
采用的存储结构不同,存储结构也不同,算法的实现也不同;&在C++中表示引用调用
四 线性表的顺序表示
1 定义
线性表的顺序存储又称顺序表,用一组地址连续的存储单元依次存储线性表中的元素,常称为数组
#define MaxSize 50
typedef struct
{ElemType data[MaxSize];int length;
}Sqlist;
空间的静态分配:事先固定大小,空间占满时会发生溢出
动态分配:程序执行过程中通过动态存储分配语句分配的,占满后就开辟一块新的空间,不需要一次性划分
#define InitSize 100
typedef struct
{Elemtype *data; \\指示动态分配数组的指针int maxsize,length; \\数组的最大容量和当前个数
}seqlist;L.data = (elemtype)malloc(sizeof(elemtypr)*Initsize); \\C的动态分配
L.data = new elemtype(Initsize); \\C++的动态分配\\动态分配不是链表,只是运行时决定分配的空间大小
顺序表的特点:随机访问,存储密度高,物理上相邻,插入删除需要移动大量数据
2 基本操作
(1)插入
bool ListInsert(sqlist &L,int i , elemtype e) \\位置i插入e
{if(i < 1 || i > L.length+1) \\i有效return false;if(L.length >= Maxsize) \\空间是否满return false;for(int j = L.length; j >=i ;j--)L.data[j]=L.data[j-1]; \\逐个移动数据直到位置i L.data[i-1]=e; \\插入eL.length++;return true;
}
时间复杂度O(n)
(2)删除
bool Listdelete(sqlist &L,int i , elemtype e) \\位置i删除并返回为e
{ if(i < 1 || i > L.length) \\i有效return false;e = L.data[i-1];for(int j =i;j<L.length;j++)L.data[j-1]=L.data[j];L.length--;return true;
}
(3)按值查找
int LocateElem(sqlist &L,Elemtype e)
{ int i;for(i=0;i<L.length;i++){if(L.data == e)return i; \\返回下标 }return -1; \\表示查找失败
}
五 线性表的链式表示
1 单链表的定义
typedef struct Lnode
{ELemtype data; \\数据struct Lnode * next; \\指针,指向下一个节点
}Lnode, *Linklist;
解决了需要大量连续存储单元的缺点,但是也存在浪费空间;是非随机存取的,必须从头开始遍历查找
用头指针来标识一个单链表
在第一个节点之前加一个头结点,不存入信息,方便操作;不管带不带头结点,头指针L都指向第一个结点
2 单链表的基本操作实现
(1)头插法建立单链表
Linklist List_Headinsert(Linklist &L)
{ Lnode *s;int x;L=(Linklist)malloc(sizeof(Lnode)); \\创建头结点L->next = NULL; \\初始为空结点scanf("%d",&x);while(x!=9999){s = (Lnode *)malloc(sizeof(Lnode)); \\Lnode* 和 Linklist 是一样的 都是创建新结点s->data =x;s->next = L->next;L->next =s;scanf("%d",x);}return L;
}
(2)尾插法建立单链表
Linklist List_Tailinsert(Linklist &L)
{ int x;L=(Linklist)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 ;scanf("%d",x);}r->next=NULL;return L;
}
(3)按序号查找结点
Lnode *Getelem(Linklist &L,int i)
{if(i<1)return NULL;int j =i;Lnode *p=L->next;while(p!=NULL&&j<i){p = p->next;j++;}return p;
}
(4)按值查找表结点
Lnode *Locateelem(Linklist &L,elemtype e)
{Lnode *p=L->next;while(p!= NULL&&p->data!=e){p=p->next;}return p;
}
(5)插入结点
p=Getelem(L,i-1);
s->next=p->next;
p->next=s;\\对某一结点进行前插
s->next=p->next;
p->next=s;
temp = p->data;
p->data=s->data;
s->data=temp;
(6)删除结点
p=Getelem(L,i-1);
q=p->next;
p->next=q->next;
free(q);\\删除结点*p
q=p->next;
p->data=p->next->data;
p->next=q->next;
free(q);
3 双链表
typedef struct Dnode
{Elemtype data;struct Dnode * pri,*next;
}Dnode, *Dlinklist;
(1)插入操作
s->next=p->next;
p->next->pri=s;
s->pri =p;
p->next=s;
(2)删除操作
p->next=q->next;
q->next->pri=p;c
free(q);
4 循环链表
(1)循环单链表
即最后个结点的指针指向头结点
(2)循环双链表
空表时,pri和next都指向L
5 静态链表
借助数组来面熟线性表的链式存储结构,这里的指针是结点的相对地址(数组下标),要预先分配空间
#define Maxsize 100
typedef struct
{Elemtype data;int next;
}SLinklist[Maxsize];
以next==-1作为结束
6 顺序表与链表的比较
顺序表 | 链表 | |
---|---|---|
存取方式 | 顺序、随机 | 顺序 |
逻辑/物理结构 | 物理上也相邻 | 物理上不一定相邻 |
查找/插入和删除 | 时间复杂度O(N)或者O(log2n) | O(n) |
空间分配 | 静态会溢出,动态效率低 | 需要时动态申请,操作灵活 |