线性表
定义：
线性表是具有相同数据类型的n（n大于等于0）个数据元素的有限序列，其中n为表长，当n=0时线性表时一个空表。若用L命名线性表，则七一般标识为L = （a1，a2，...，ai，ai+1，...an）
概念：
ai是线性表中的“第i个”元素线性表中的为序
a1是表头元素；an是表尾元素。
除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有有一个直接后续
线性表的基本操作：
InitList(&L):初始化表。构造一个空的线性表L，分配内存空间
DestoryList(&L):销毁操作。销毁线性表，并释放线性表L所占用的内存空间
ListInsert(&L,i,e):插入操作。在表L中的第i个位置上插入指定元素e
ListDelete(&L,i,&e):删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值
LocateElem(L,e):按值查找操作。在表L中查找具有给定关键字值的元素
GetElem(L,i):按位查找操作。获取表L中第i个位置的元素的值
Length(L):求表长。返回线性表L的长度，即L中数据元素的个数
PrintList(L):输出操作。按前后顺序输出线性表L的所有元素值
Empty(L):判空操作。若L位空表，则返回true，否则返回false
顺序表
定义：
用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现
线性表是具有相同数据类型的n个数据元素的有限序列，每个数据元素所占空间一样大。可以使用sizeof（Elem Type）函数来获取一个数据元素大小。
#define MaxSize 10 //定义顺序表最大长度
typedef struct {
ElemType data[MaxSize]; //用静态的数组存放数据元素 （ElemType 任意类型）
int length;
}SqList; //顺序表的类型定义（静态分配方式）动态申请和释放内存空间
C——malloc、free函数
#define InitSize 10 //定义顺序表最大长度
typedef struct {
int* data; //动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //顺序表的当前长度
}SeqList;
void InitList(SeqList& L) {
//用malloc函数生气一片连续的存储空间,要先引入头文件#include <stdlib.h>
L.data = (int*)malloc(InitSize * sizeof(int));
L.length = 0;
L.MaxSize = InitSize;
}
//增加动态数组的长度
void IncreaseSize(SeqList& 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; //更新顺序表最大长度
free(p); //释放原来的用过的比较小的空间
}
顺序表的特点：
1.随机访问，即可以在O（1）时间内找到第i个元素
2.存储密度高，每个节点只存储数据元素
3.扩展容量不方便（即便采用动态分配的方式实现，扩展长度的时间复制度也比较高）
4.插入、删除操作不方便需要移动大量元素
顺序表的基本操作——插入
//输入链表的地址，要插入的位置，要插入的数字，返回是否插入成功
bool ListInsert(SeqList& L, int i, int e) {
if (i < 1 || i > L.length + 1) //判读i的范围是否有效
return false;
if (L.length >= InitSize) //当前存储空间已满，不能插入
return false;
for (int j = L.length; j >= i; j--)//倒着就i个元素之后的元素后移
{
L.data[j] = L.data[j - 1];
}
L.data[i - 1] = e; //在位置i处放入e
L.length++; //长度加1
return true;
}最坏的时间复杂度 = O（n）
顺序表的基本操作——删除
bool ListDelete(SeqList& L, int i, int& e) {
if (i < 1 || i > L.length) //判读i的范围是否有效
return false;
e = L.data[i - 1]; //将被删除的元素赋给e
for (int j = i; i < L.length; j++) //将被删除元素的后面的元素向前移
{
L.data[j - 1] = L.data[j];
}
L.length--; //长度减一
return true;
}最坏的时间复杂度 = O（n）
顺序表的基本操作——查找
按位查找
//查找数组里面第i个元素
ElemyType GetElem(SeqList L, int i) {
return L.data[i - 1];
}最坏的时间复杂度 = O（1）
按值查找
//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L, ElemType e) {
for (int i = 0; i < L.length; i++)
{
if (L.data[i] == e) //注：只有基本的数据类型能够用==，而结构体不能
{
return i+1;
}
}
return 0;
}最坏的时间复杂度 = O（n）
线性表
定义：
每个节点除了存放数据元素外，还要存储指向下一个节点的指针
优点：不要求大片连续空间，改变容量方便
缺点：不可能随机存取，要耗费一定空间存放指针
不带头结点的单链表的创建
typedef struct LNode { //定义单链表结点类型
ElemType data; //每个节点存放一个数据类型
struct LNode* next; //指针指向下一个节点
}LNode,*LinkList;
//初始化一个空的单链表
bool InitList(LinkList& L) {
L = NULL; //空表，暂时还没有仍和结点，防止脏数据
return true;
}
//判断单链表是否为空
bool ElemType(LinkList L) {
if (L == NULL)
{
return true;
}
return false;
}
void test() {
LinkList L; //声明一个指向单链表的指针
InitList(L); //初始化一个空表
}带头节点的单链表创建
typedef struct LNode { //定义单链表结点类型
ElemType data; //每个节点存放一个数据类型
struct LNode* next; //指针指向下一个节点
}LNode, * LinkList;
//初始化一个空的单链表
bool InitList(LinkList& L) {
L = (LNode*)malloc(sizeof(LNode)); //分配一个头结点
if (L == NULL) //内存不足，分配失败
return false;
L->next = NULL; //头结点之后暂时还没有节点
return true;
}
//判断单链表是否为空
bool ElemType(LinkList L) {
if (L->next == NULL)
{
return true;
}
return false;
}
void test() {
LinkList L; //声明一个指向单链表的指针
InitList(L); //初始化一个空表
}按位序插入（带头结点）
typedef struct LNode{
ElemType data;
struct LNode* next;
}LNode,*LinkList;
//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList& L, int i, ElemType e) {
if (i < 1)
return false;
LNode* p; //指针p指向当前扫描到的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点（不存数据）
while (p != NULL && j<i-1) //循环找到第i-1个结点
{
p = p->next;
j++;
}
if (p == NULL) //i不合法
return false;
LNode* s = (LNode*)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
}
按位序插入（不带头结点）
如果不带头结点，则插入、删除第一个元素时，需要更改头指针L
typedef struct LNode{
ElemType data;
struct LNode* next;
}LNode,*LinkList;
//在第i个位置插入元素e（带头结点）
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;
}
LNode* p; //指针p指向当前扫描到的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点（不存数据）
while (p != NULL && j<i-1) //循环找到第i-1个结点
{
p = p->next;
j++;
}
if (p == NULL) //i不合法
return false;
LNode* s = (LNode*)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
}指定结点的后插操作
//后插操作：在p结点之后插入e
bool InsertNextNode(LNode* p, ElemType e) {
if (p == NULL)
return false;
LNode* s = (LNode*)malloc(sizeof(LNode));
if (s == NULL)
return true; //某些情况下有可能分配失败（如内存不足）
s->data = e;
s->next = p->next;
p->next = s;
}
指定结点的前插操作
//前插操作：在p结点之前插入结点s
bool InsertPriorNode(LNode* p, LNode* s) {
if (p == NULL || s == NULL)
return false;
s->next = p->next;
p->next = s; //s连到p之后
ElemType temp = p->data; //交换数据域部分
p->data = s->data;
s->data = temp;
return true;
}
按位序删除（带头结点）
bool ListDelete(LinkList& L, int i, ElemyType& e) {
if (i < 1)
return false;
LNode* p;
int j = 0;
p = L;
while (p != NULL && j < i - 1)
{
p = p->next;
j++;
}
if (p == NULL)
return false;
if (p->next == NULL) //第i-1个结点之后已无其他结点
return false;
LNode* q = p->next; //令q指向被删除结点
e = q->next; //用e返回元素的值
p->next = q->next; //将*q结点从链中断开
free(q); //释放结点的存储空间
return true;
}删除固定的结点
//删除固定的结点
bool DeletNode(LNode* p) {
if (p == NULL)
return false;
LNode* q = p->next; //令q指向*p的后继结点
p->data = p->next->data; //和后继结点交换数据域
p->next = q->next; //将*q结点从链中“断开”
free(q); //释放后结点的存储空间
return true;
}注：该方法只适用与后一个结点不为空的情况，如果后一个为空则要从头结点开始遍历删除
按位查找
//按位查找，返回第i个元素（带头结点）
LNode* GetElem(LinkList L, int i) {
if (i < 0)
return NULL;
LNode* p; //指针p指向当前扫描到的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点
while (p != NULL && j < i) //循环找到第i个结点
{
p = p->next;
j++;
}
return p;
}按值查找
//按值查找，找到数据域 == e的结点
LNode* LocateElem(LinkList L, ElemType e) {
LNode* p = L->next;
//从第1个结点开始查找数据域为e的结点
while (p != NULL && p->data != e)
p = p->next;
return p; //找到后返回该结点指针，否则返回NULL
}
求表的长度
//求表的长度
int Length(LinkList L) {
int len = 0;
LNode* p = L;
while (p->next != NULL) {
p = p->next;
len++;
}
return len;
}尾插法建立单链表
//正向建立单链表
LinkList List_Taillnsert(LinkList& L) {
int x; //设ElemType为整型
L = (LinkList)malloc(sizeof(LNode)); //建立头结点（初始化空表
LNode* s, * r = L; //r为表尾指针
scanf("%d", &x); //输入结点的值
while (x != 9999) //输入9999表示结束
{
s = (LNode*)malloc(sizeof(LNode));
s->data = x;
r->next = s; //在r结点之后插入s元素
r = s; //r指向新的表尾结点（永远保持r指向最后一个结点
scanf("%d", &x);
}
r->next = NULL; //尾结点指针置空
return L;
}
头插法建立单链表
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));
s->data = x;
s->next = L->next;
L->next = s; //将新结点插入表中，L为头指针
scanf("%d", & x);
}
return L;
}
双链表
//定义双链表结点类型
typedef struct DNode {
ElemyType data; //数据域
struct DNode* prior, * next; //前驱和后继指针
}DNode,*DLinklist;
//初始化链表
bool InitDLinkList(DLinklist& L) {
L = (DNode*)malloc(sizeof(DNode)); //分配一个头结点
if (L == NULL) //内存不足，分配失败
return false;
L->prior = NULL; //头结点的prior永远指向null
L->next = NULL; //头结点之后暂时还没有结点
return true;
}
void testDLinkList() {
DLinklist L;
InitDLinkList(L);
}双链表的插入
//在p结点之后插入s结点
bool InsertNextDNode(DNode* p, DNode* s) {
if (p == NULL || s == NULL)
return false;
s->next = p->next; //将结点*s插入到结点*p之后
if (p->next != NULL) //如果p结点有后继结点
p->next->prior = s;
s->prior = p;
p->next = s;
}
双链表的删除
//删除p结点的后继结点
bool DeleteNextDNode(DNode* p) {
if (p == NULL)
return false;
DNode* q = p->next; //找到p的后继结点q
if (q == NULL) //如果p没有后继结点
return false;
p->next = q->next;
if (q->next != NULL) //q结点不是最后一个结点
q->next->prior = p;
free(q); //释放空间
return true;
}
void DestoryList(DLinklist& L) {
//循环释放各个数据结点
while (L->next != NULL)
DeleteNextDNode(L);
free(L); //释放头结点
L = NULL; //头指针指向NULL
}循环列表
//定义单链表结点类型
typedef struct LNode {
ElemType data; //每个结点存放一个数据元素
struct LNode* next; //指针指向下一个节点
}LNode,*LinkList;
//初始化一个循环单链表
bool InitList(LinkList& L) {
L = (LNode*)malloc(sizeof(LNode)); //分配一个头节点
if (L == NULL) //内存不足，分配失败
return false;
L->next = L; //头节点next指向头结点
return true;
}
//判断循环单链表是否为空
bool Empty(LinkList L) {
if (L->next == L)
return true;
else
return false;
}
//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode* p) {
if (p->next == L)
return true;
else
return false;
}循环单链表：从一个结点触发，可以找到其他任何一个结点
循环双链表
表头结点的prior指向表尾结点；表尾结点的next指向头结点
循环双链表的初始化
//构建一个双链表的类额
typedef struct DNode {
ElemType data;
struct DNode* prior, * next;
}DNode,*DLinklist;
//初始化空的循环双链表
bool InitDLinkList(DLinklist& L) {
L = (DNode*)malloc(sizeof(DNode));
if (L == NULL)
return false;
L->prior = L; //头结点的prior指向头结点
L->next = L; //头结点的next指向头结点
return true;
}
void testDLinkList() {
//初始化循环双链表
DLinklist L;
InitDLinkList(L);
}
//判断循环双链表是否为空
bool Empty(DLinklist L) {
if (L->next == L)
return true;
else
return false;
}
//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinklist L,DNode *p) {
if (p->next == L)
return true;
else
return false;
}双链表的插入
//在p结点之后插入s结点
bool InsertNextDNode(DNode* p, DNode* s) {
s->next = p->next; //将结点*s插入到结点*p之后
p->next->prior = s;
s->prior = p;
p->next = s;
}
静态列表
分配一整片连续的内存空间，各个结点集中安置
560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
