线性表基础知识总结

一.线性表的定义

线性表（List）是由同一类型的数据元素构成的有序序列的线性结构。线性表中元素的个数称为线性表的长度；当一个线性表中没有元素时，称之为空表，表的起始位置称为表头，表的结束位置称为表尾。
线性表的操作集：
List MakeEmpty():初始化一个新的空线性表。
ElementType FindKth（int K，List L）：根据指定的位序K，返回L中相应的元素a_k。
int Find(ElementType X, List L):已知X，返回线性表L中与X相同的第一个元素的相应位序i；若不存在则返回空。
void Insert(ElementType X, int i, List L)：在L的指定位序i前插入一个新元素X
void Delete(int i, List L):从L中删除指定位序i的元素
int Length（List L）：返回线性表L 的长度。

二.线性表的顺序存储实现

定义：线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素。由于一维数组在内存中占用的存储空间就是一组连续的存储区域，所以用一维数组来表示顺序存储的数据区域再合适不过。
线性表的存储结构如下：

typedef struct{
    ElementType Data[MaxSize];
    int Last;
}List;

三． 顺序存储线性表的操作实现

1. 初始化
   即构造一个空表。首先动态分配表结构所需要的存储空间，然后将表中的Last设置为-1，代码如下：

List* MakeEmpty()
{
    List *PtrL;
    PtrL = (List*)malloc(sizeof(List));
    PtrL -> Last = -1;
    return PtrL;
}

2 查找
在顺序存储的线性表中，查找主要是指在线性表中查找和给定数值X相同的数据元素，然后返回该元素在列表中的位置。

int Find(ElementType X，List *PtrL)
{
    int i = 0;
    while(i <= PtrL -> Last && PtrL -> Data[i] != X )
        i++;
    if(i > PtrL->Last)
        return -1;
    else
        return i;
}

3． 插入.
插入是指在表的第k（1<=k<=n+1）个位置上插入一个值为X的元素。代码如下

void Insert(ElementType X, int k, List *PtrL)//插入
{
    int i;
    /*检查插入位置的合法性*/
    if(i < 1 || i > PtrL -> Last+2)
    {
        printf("插入位置不合法")
        return;
    }

    /*开始从后往前逐个移位*/
    for(i=PtrL -> Last; i>=k-1; i--)
        PtrL -> Data[i+1] = PtrL -> Data[i];

    /*插入数据*/
    PtrL -> Data[k-1] = X;
    PtrL -> Last++;
    return; 
}

1. 删除
   删除是指从线性表中删除掉第k（1<=k<=n）个元素，删除之后表的长度变成n-1。代码如下：

void Delete(int k, List *PtrL)
{
    int i;
    /*检查删除位置的合法性*/
    if(k < 1 || k > PtrL -> Last+1)
    {
        printf("删除位置不合法")；
        return;
    }

    /*删除元素*/
    for(i = k; i <= PtrL -> Last; i++ )
        PtrL -> Data[i-1] = PtrL -> Data[i];
    PtrL -> Last--;
}

四． 线性表的链式存储实现
由于顺序表的存储特点时用物理上的相邻实现了逻辑上的相邻，因此对顺序表的插入，删除时需要移动数据元素来实现，影响了运行的效率。而线性表的链式存储结构是通过“链“来建立数据元素之间的逻辑关系的，所以对线性表的插入，删除不需要移动数据元素，只需要修改链。
链式存储中，结点的结构定义如下：

typedef struct Node
{
    ElementType Data;
    struct Node *Next;
}List;

五． 链式存储线性表的操作实现
1. 求表长

int Length(List *PtrL)
{
    List *p = PtrL;
    int i = 0;
    while(p)
    {
        p = p -> Next;
        i++;
    }
    return i;
}

1. 查找
   ○按顺序查找

List* FindKth(int k, List *PtrL)
{
    List *p = PtrL;
    int i = 1;
    while(p != NULL && i < k)
    {
        p = p -> Next;
        i++;
    }
    if(p == NULL)
        return NULL;
    else
        return p;
}

○按值查找

List* Find(ElementType X, List *PtrL)
{
    List *p = PtrL;
    while(p != NULL && p -> Data != X)
    p = p -> Next;
        return p;
}

1. 插入

List *Insert(List *PtrL, int k, ElementType X)
{
    List *p, *s;
    if(k==1)
    {
        s = (List*)malloc(sizeof(List));
        s -> Data = X;
        s -> Next = PtrL;
        return s;
    }
    p = FindKth(k-1, PtrL);
    if(p == NULL)
    {
        printf("请输入正确的K值")；
        return NULL;
    }
    else
    {
        s = (List*)malloc(sizeof(List));
        s -> Data = X;
        s -> Next = p -> Next;
        P -> Next = s;
        return PtrL;
    }
}

1. 删除

List *Delete(int k, List *PtrL)
{
    List *p, *s;
    /*删除的是第一个结点*/
    if(k == 1)
    {
        s = PtrL;
        PtrL = PtrL -> Next;
        free(s);
        return PtrL;
    }
    /*删除的不是第一个结点*/
    p = FindKth(k-1, PtrL);
    s = p -> Next;
    else if(p == NULL)
    {
        printf("第%d个结点不存在"， i-1);
        return NULL;
    }
    else if(s == NULL)
    {
        printf("第%d个结点不存在"， i);
        return NULL;
    }
    else
    {       
    p -> Next = s -> Next;
    free(s);
    return PtrL;
    }
}