线性表

线性表作为最简单最常用的数据结构，有着广泛的作用。现对线性表的两种结构做以下归纳：

一、顺序结构

#define MAXSIZE 20
typedef int ElemType;
typedef struct
{
    ElemType data[MAXSIZE];
    int length;//线性表当前长度
}SqList;

其实就是封装一个数组，增加了一个当前长度的变量变量罢了。

由上述结构可以发现顺序存储结构封装需要的三个属性：
1、存储空间的起始地址（数组data的存储位置）
2、线性表的最大存储容量（Maxsize）
3、线性表的当前长度（length）
注：数组的长度是存放线性表的存储空间的总长度，一般初始化后不变。而当前长度是线性表中元素的个数，是会变化的。

---

地址计算方法：
假设ElemType占用的是c个存储单元（字节），则线性表中第i+1与第i个数据元素的存储位置的关系为地址（ai+1） = 地址（ai）+c
所以对于第i个数据元素ai的存储位置可以由a1推算出地址（ai） = 地址（a1） + （i-1）*c

通过上述公式，可以随时计算出线性表中任意位置的地址，不管是第一个还是最后一个都是相同的时间，即为O(1)。通常称为随机存储结构。

---

具体操作中的：
1、GetElem():

#define OK 1 
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
//Status是函数的类型，其值是函数结果状态代码，如OK等
//初始条件：顺序线性表L已存在，1 <= i <= ListLength(L);
//操作结果:用e返回L中第i个数据元素的值。

Status GetElem(SqList L, int i, ElemType *e)
{
    if(L.length == 0 || i > L.length)//增加程序健壮性
    {
        return ERROR;
    }
    *e = L.data[i-1];
    return OK;
}

2、ListInsert
插入算法的思路：
-1、如果插入位置不合理，抛出异常
-2、如果线性表长度大于等于数组长度，则抛出异常或动态增加数组容量
-3、从最后一个元素开始向前遍历到第i个位置，分别将他们都向后移动一个位置
-4、将要插入的元素填入位置i处
-5、线性表长+1

//在线性表L中的第i个位置插入新元素e
Status ListInsert(SqList *L, int i, ElemType e)
{
    int k;

    if(L->length == MAXSIZE)//顺序线性表已满
    {
        return ERROR;
    }
    if(i < 1 || i > L->length+1)//当i不在范围内时
    {
        return ERROR;
    }
    if(i <= L->length)//插入位置不在表尾
    {
        //移动
        for(k = L->length -1; k >= i-1; k--)
        {
             L->data[k+1] = L->data[k];
        }
    }
    L->data[i-1] = e;//插入
    L->length++;//不要忘记！

    return OK;
}

3、ListDelete
删除算法的思路可以类比插入操作
可根据如下代码对比ListInsert( )。

ListDelete(SqList *L, int i, ElemType *e)
{
        int k;

    if(L->length == 0)//顺序线性表为空
    {
        return ERROR;
    }
    if(i < 1 || i > L->length)//当i不在范围内时
    {
        return ERROR;
    }

    *e = L->data[i-1];//用e保存删除的值

    if(i < L->length)//删除位置不在表尾
    {
        //移动
        for(k = i; k <= L->length; k++)
        {
             L->data[k-1] = L->data[k];
        }
    }

    L->length--;//不要忘记！

    return OK;
}

分析插入和删除的时间复杂度
最好情况：刚好要求在最后一个位置操作，不需要移动任何元素，所以O(1)
最坏情况：要插入或删除的是第一个元素，所有元素需要移动，所以是O(n)
平均情况O((n-1)/2)

所以是O(n)

所以适合存取数据，不适合插入和删除。

---

二、链式结构
单链表：链表的每个结点中只包含一个指针域

typedef struct Node
{
    ElemType data;//数据域（数据本身）
    struct Node* Next;//指针域（下一个结点的位置）
}Node;
typedef struct Node* LinkList;
//在程序中LinkList就是 Node*

---

头指针和头结点
头指针：
头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。
头指针具有标识作用，所以常用头指针做链表名（指针变量的名字）
无论链表是否为空，头指针均不为空
头指针是链表的必要元素

头结点：
为了操作的统一和方便而设立。放在第一个元素之前，数据域一般无意义（也可以用来存放链表的长度）
有了头结点，在第一元素结点前插入结点，删除第一结点等操作就与其他结点的操作统一了
头结点不一定是链表的必须要素

---

1、单链表的读取：
必须从第一个结点开始挨个儿找
GetElem():
算法思路：
-1、声明一个结点P指向链表第一个结点，初始化j从1开始。（在链表中，没有第一个就不知道后面的结点在哪里）
-2、当j < i 时，遍历链表，让p的指针向后移动，不断指向下一个结点，j+1
-3、若到链表末尾P为空，则说明第i个元素不存在
-4、否则查找成功，返回结点p的数据

ElemType GetElem(LinKlist L, int i,ElemType *e)
{
    int j = 1
    LinkList  p = L->next;
    while(p && j < i)
    {
        p = p->next;//工作指针后移
        j++;
    }
    if(p == NULL  || j > i)
    {
        return ERROR;
    }
    else
    {
        *e = p->data;
        return OK;
    }

}

时间复杂度为O(n)。

---

单链表的插入：
假设要插入的结点为s，存储的数据为e。要实现结点p, s, p->next之间的逻辑关系的变化，则为：
s->next = p->next;
p->next = s;
(以上两句代码不能交换顺序。如交换，则p->next = s， 再将s->next = p->next,则相当于 s->next = s, 在s结点上绕圈)
单链表第i个数据插入结点的算法思路：
-1、声明一结点p指向链表头结点，初始化j从1开始
-2、当j < i 时，就遍历链表，让p的指针向后移动，不断指向下一结点，j++
-3、若到链表末尾p为空，则说明第i个元素不存在
-4、否则查找成功，在系统中生成一个空结点s
-5、使s->data = e,
-6、添加上述的两行标准插入代码
-7、返回成功

Status ListInsert(LinkList *L, int i ,ElemType e)
{
    int j;
    LinkList p, s;

    p = *L;
    j = 1;
    while(j < i && p)//用于寻找第i个结点
    {
        p = p ->next;
        j++;
    }
    if(j >i || !p)
    {
        return ERROR;
    }

    s = (LinkList)malloc(sizeof(Node));
    s->data = e;

    s->next = p->next;
    p->next = s;

    return OK;
}

---

单链表的删除
p->next = p ->next->next;
或者写成
q = p->next; p->next = q->next;

思路与插入相似，直接见代码：

Status ListDelete(LinkList *L, int i ,ElemType *e)
{
    int j;
    LinkList p, q;

    p = *L;
    j = 1;
    while(j < i && p->next)//用于寻找第i个结点
    {
        p = p ->next;
        j++;
    }
    if(j >i || !p->next)
    {
        return ERROR;
    }

    q = p->next;
    p->next = q->next;//这两行可以写成 p->next = p->next->next;

    *e = q->next;
    free(q);
    return OK;
}

无论单链表插入还是删除算法，其实都是两部分组成：1、遍历查找第i个元素，第二部分就是插入和删除元素。
时间复杂度都是O(n)。

---

单链表的整表创建
1、头插法 2、 尾插法

这是一个动态生成链表的过程，从“空表”的初始状态起，依次建立各元素结点并逐个插入链表。

算法思路：
-1、声明一结点p和计数器变量i
-2、初始化一空链表L
-3、让L的头结点的指针指向NULL。即建立一个带头结点的单链表。
-4、循环实现后继结点的赋值和插入。

头插法：每次都将新元素放在表头后的第一个位置。
所以生成的链表中结点的次序和输入的顺序相反。
-1、先让新节点的next指向头结点之后
-2、让表头的next指向新节点。

void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;

    srand(time(0));//初始化随机数种子

    *L = （LinkList）malloc(sizeof(Node));
    (*L)->next = NULL;

    for(i = 0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100+1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

尾插法：
把新结点都插入到最后。

void CreateListTail(LinkList *L, int n)
{
    LinkList p,r;//r是指向尾部的
    int i;

    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;

    for(i = 0; i < n; i++)
    {
        p = (Node *)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p; //让r继续指向尾部
    }
}

---

单链表的整条删除：
在内存中将它释放掉，留出空间。
算法思路：
1、声明结点p和q
2、将第一个结点赋值给p，下一个结点赋值给q
3、循环执行 释放p 和 将q赋值给p的操作

Status ClearList(LinkList *L)
{
    LinkList p,q;
    p = (*L)->next;
    while(p)
    {
        q = p->next;//p用来存放下一个结点的位置，不存储的话，free（p）会将数据域和指针域一同释放，找不到下一个
        free(p);
        p = q;       
    }
    (*L)->next = NULL;
    return OK;
}