1.线性表的顺序储存(线性表)
1.1什么是线性表和线性表的初始化
首先，要明白线性表的顺序储存是什么，线性表的顺序存储又叫做线性表，它是本质上就是一个动态数组，但是表示方式不同而已代码如下：
#define LIST_INIT_SIZE 100//初始长度
#define LISTINCREMENT 10//长度增量
typedef struct {
int* elem;//基址
int length;//有效元素长度
int listsize;//表长
}SqList;
int* InitList_Sq(SqList* S)//线性表的初始化
{
S->elem = (int*)malloc(LIST_INIT_SIZE * sizeof(int));
if (!S->elem) exit(1);//检测是否开辟空间成功
S->length = 100;
S->listsize = LIST_INIT_SIZE;
for (int i = 0; i < LIST_INIT_SIZE; i++)
S->elem[i] = 0;
return S->elem;
}我们可以看见，与数组不同的是使用了结构体来存储线性表的基本特征并初始化了，定义了一个指针来存储线性表的起始地址、实际长度、线性表长度。
-------------------------------------------------------------------------------------------------------------------------
1.2线性表的元素插入、删除
int* ListInsert(SqList*S,int i,int e)//S为基址，i为插入元素的位置、e为插入的元素
{
if (i < 0 || i >= S->listsize)
exit(1);//检测插入是否合理
if (S->length >= S->listsize) //检测空间是否够
{
int* newbase = (int*)realloc(S->elem, (LIST_INIT_SIZE + LISTINCREMENT) * sizeof(int));
if (!newbase)exit(1);
S->elem = newbase;
S->listsize += LISTINCREMENT;
}
for (int j =S->length; j>i-1;j--)//真正插入开始，从有线长度末端开始，后移一个单位
{
S->elem[j] = S->elem[j - 1];
}
S->elem[i - 1] = e;
S->length++;
return S->elem;
} 线性表的重要功能之一就是插入元素，功能的实现如图：
删除就是插入的逆操作。
------------------------------------------------------------------------------------------------------------------------
1.3两个线性表的合并
合并线性表是基本操作，实现如下：(假设两个线性表元素都是从小到大，要求是合并的线性表也是)
void MergeList(SqList La, SqList Lb, SqList* Lc)//合并线性表，Lc为合并线性表的基址
{
Lc->listsize = La.listsize + Lb.listsize;//确定Lc实际长度
Lc->elem = (int*)malloc(Lc->listsize * (sizeof(int)));
if (!Lc->elem)exit(-1);//检测
int* LaLast = La.elem + La.length - 1;
int* LbLast = Lb.elem + Lb.length - 1;
while (La.elem <= LaLast && Lb.elem <= LbLast)//排序合并
{
if (*La.elem == *Lb.elem)
*Lc->elem++ = *(Lb.elem++), La.elem++;
*Lc->elem++ = (*La.elem > *Lb.elem ? *(Lb.elem++) : *(La.elem++));
}
if (La.elem > LaLast)
while (Lb.elem <= LbLast)
*Lc->elem ++= *(La.elem++);
while (La.elem <= LaLast)
*Lc->elem =++ *(Lb.elem++);
}可以看见，合并的本质是创建新的线性表，就像排座位，先男女生各按高矮排座位，然后对比每个队中最矮的移出队，继续比较，直至一队为空。所以，如果前两个线性表不使用时，记得释放空间哦
------------------------------------------------------------------------------------------------------------------------
2.线性表的链式存储(链表)
2.1什么是链表
同样地，线性表的链式存储也叫链表，本质上是结构体，看代码：
typedef struct LNode {
int data;//数据域
LNode* next;//指针域
}LNode;把这么一个结构体叫做结点(Node)，是链表的基本组成单元，最开始的结点叫做头节点，一般数据域不存储数据，最后的结点叫做尾结点，指针域不存储数据
2.2链表的初始化
void CreatLNode1(LNode* L, int i)//L为链表头节点的地址，i为还需初始化的表长
{
if (i == 0)//递归结束的标志
{
L->next = NULL;
L->data = 2 * i;
return;
}
LNode* P = (LNode*)malloc(sizeof(LNode));//创建一个结点
L->next = P;
L->data = 2*i;
CreatLNode1(P, i - 1);
return;
}
void CreatLNode2(LNode* L, int i)
{
if (i == 0)
{
L->next = NULL;
L->data = 2 * i;
return;
}
LNode* P = (LNode*)malloc(sizeof(LNode));
L->next = P;
L->data = 2 * i-1;
CreatLNode2(P, i - 1);
return;
}
链表的初始化有两种，一种是正向的初始化(CreatLNode1)，另一种是逆向的初始化(CreatLNode2)。
------------------------------------------------------------------------------------------------------------------------
2.3链表的结点查找
由于链表不像数组那样是连续的，访问的方式也不同，查找方式如下：
void GetElem_L(LNode *L, int i)//在L后的第i个结点
{
int j=1;
LNode* p = L;
while (p && j < i)
{
p = p->next;
j++;
}
if (!p || j > i)exit(-1);
cout << p->data<<endl;
}2.4链表的元素插入
LNode* ListInsert_L(LNode* L, int i, int e)
{
LNode* P = L;
int j = 1;
while (P && j < i - 1)//先找到第i-个结点
{
P = P->next;
j++;
}
if (!P || j > i - 1)exit(-1);//检查是否找到
LNode* s = (LNode*)malloc(sizeof(LNode));//创建新的结点
s->data = 1;
s->next = P->next;
P->next= s;
return L;
} 链表的插入不像线性表那么麻烦，只需要将第i-1个元素和插入元素的next改变
时间复杂度：线性表O(length-i+1)和链表O(1)
图解：
同理，删除链表也是如此；
2.5两个链表的合并
看起来没有线性关系(物理储存相邻)的链表也能合并！！
void MergerList_L(LNode* L, LNode* M)//合并；链表
{
LNode* pa = L->next;//因为头节点通常不存储数据，所以先直接找到第二个结点
LNode* pb = M->next;
LNode* pc = L;//并以L和M中随便一个作为头节点
while (pa && pb)//检测尾节点
{
if (pa->data <= pb->data)
{
pc->next = pa;
pc = pa;
pa = pa->next;
}
else
{
pc->next = pb;
pc = pb;
pb = pb->next;
}
}
free(M);//释放另一个头节点
if (!pa)
{
pc->next = pb;
return;
}
pc->next = pa;
return;//检测终止并排序
}图解：
由图可知：先选一个结点作头节点(通常是L或M)，比较Pa和Pb的数据域，然后决定谁是第二个结点，将原先为第二个结点的指针指向下一个结点，同理(第三个、第四个····)，直至有一队指向尾节点。
3.静态链表
3.1什么是静态链表
静态链表，就是结构体数组(一般第一位也不储存数据)：
#define MAXSIZE 1000
typedef struct
{
int data;//数据
int cur;//游标，也叫指针
}component,SLinkList[MAXSIZE];游标的作用是指向数组中下一个结点的位置，也就是第数组的第cur+1位，如:
int main()
{
SLinkList S;
S[0].cur=1;
return 0;
}就创建了一个名为S的静态链表，长度为1000，且头结点的下一个结点是S[1]。
3.2静态链表的初始化
void Init_SL(SLinkList* S )//将静态链表初始化为首尾相连的形式
{
for (int j = 0; j < MAXSIZE-1; j++)
{
S[j].data = j + 1;
S[j].cur = j + 1;
}
S[MAXSIZE - 1].cur = 0;//设置尾点
}创建的表的示意图
3.3静态链表的元素定位
int LocateElem_SL(SLinkList S, int e)//查找第一个值为e的元素的位置
{
int i = S[0].cur;//设置始点
while (i && S[i].data != e)//检查是否到终点或查找元素点
i = S[i].cur;
return i;
}我们遍历静态链表，直至最后一个结点，找到数据域为e的元素的下标
3.4假如A、B两个静态链表，求(A-B)U(B-A)
示意图：
void difference_SL(SLinkList A, SLinkList B)
{
int i = 0, j = 0,k=0,m=0;
while (1)
{
while (1)
{
if (i >= 1 && j >= 1 && A[i].data == B[j].data)
{
A[k].cur = A[i].cur, A[i].cur = -1;//去除相同的结点并标记为空闲节点
B[m].cur = B[j].cur, B[j].cur = -1;
break;
}
m = j;//标记前一个结点，方便改游标
if (B[j].cur == 0)
break;
j = B[j].cur;
}
j = 0;
k = i;//标记前一个结点，方便改游标
if (A[i].cur == 0|| A[i].cur == -1)
break;
i = A[i].cur;
}//这段循环用于去除相同的元素
i=0,j = 0,k=0;
while (A[k].cur != 0)
k=A[k].cur;//获取A的尾节点
j = B[j].cur;
while (1)
{
while (A[i].cur != -1)
i++;//获取空闲结点
A[i].data = B[j].data;
A[k].cur = i;
k = A[k].cur;
A[i].cur = 0;//插入
if (B[j].cur == 0)
break;
j = B[j].cur;
}
}为了达到我们的目的和节省空间，我们将目的静态链表覆盖A
第一步：将A和B中的交集全部去除，我们遍历A、B，如果发现两个有相同数据的结点，直接删除结点，步骤和链表类似，先将要删除的结点的上一个结点的cur指向要删除的结点的下一个结点，然后把要删除的结点的cur改为-1，(方便我们在合并链表时找到空缺的位置),遍历完成后就挨个地将B的元素插入A：先遍历找到A的尾节点，先循环遍历找到A的cur为-1的结点，然后将B结点的数据插入，将A的尾节点的cur指向插入的点，然后插入的点成为了尾节点（为了合适A插入B后长度大于初始的A,最开始将A的所有cur先初始化为-1）。
1012
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
