线性表

线性表：最基本、最简单、也是最常用的一种数据结构

线性表的定义

• 有穷性：一个线性表中的元素个数是有限的
• 一致性：一个线性表中所有元素的性质相同。从实现的角度看，所有元素具有相同的数据类型
• 序列性：一个线性表中所有元素之间的相对位置是线性的，即存在唯一的开始元素和终端元素，除此之外，每个元素只有唯一的前驱元素和后继元素。各元素在线性表中的位置只取决于它们的序号，所以在一个线性表中可以存在两个值相同的元素

顺序表

• 顺序表的定义
  • 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素
  • 顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙
• 顺序存储方式
  • 一维数组实现顺序存储结构

#define MAXSIZE 20          //存储空间的初始分配量
typedef int ElemType;       //ElemType类型根据实际情况而定，这里是int
typedef struct
{
    ElemType data[MAXSIZE]; //数组，存储数据元素
　　 int length;             //线性表当前长度
}SpList;

• • 描述顺序存储结构需要三个属性
  • 存储空间的起始位置：数组data，它的存储位置就是存储空间的存储位置
  • 线性表的最大存储容量：数组长度MAXSIZE
  • 线性表的当前长度：length
• 数组长度与线性表长度的区别
  • 数组长度：存放线性表的存储空间的长度，存储分配后这个量一般是不变的
  • 线性表长度：线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是变化的
  • 在任意时刻，线性表的长度应该小于等于数组的长度

顺序存储结构的插入与删除

• 获得元素操作

#define OK 1
#define ERROR 0
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L,int i,ElemType *e)
{
    if(L.length==0 || i<1 || i>L.length)
            return ERROR;
    *e=L.data[i-1];
    return OK;
}

• 插入操作

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
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;
}

• 删除操作

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e) 
{ 
    int k;
    if (L->length==0)               /* 线性表为空 */
        return ERROR;
    if (i<1 || i>L->length)         /* 删除位置不正确 */
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length)                /* 如果删除不是最后位置 */
    {
        for(k=i;k<L->length;k++)/* 将删除位置后继元素前移 */
            L->data[k-1]=L->data[k];
    }
    L->length--;
    return OK;
}

• 线性表的顺序存储结构的优缺点
• 优点：
• 无须为表示表中元素之间的逻辑关系而增加额外的存储空间
• 可以快速地存取表中任一位置的元素
• 缺点：
• 插入和删除操作需要移动大量元素
• 当线性表长度变化较大时，难以确定存储空间的容量
• 造成存储空间的碎片

线性表的链式存储结构--链表

链表概述

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些元素可以存在内存未被占用的任意位置

在链式结构中，不但要存储数据元素信息外，还要存储它的后继元素的存储地址

存储元素信息的域称为数据域，

存储直接后继位置的域称为指针域

指针域中存储的信息称作指针或链

这两部分信息组成数据元素ai的存储映像，称为结点（Node）

n个结点（ai的存储映像）链结成一个链表，即为线性表（a1,a2,.....an）的链式存储结构

因为此链表的每个结点中只包含一个指针域，所以叫做单链表

链表中第一个结点的存储位置叫做头指针

线性链表的最后一个结点指针为"空"

有时，为了更方便对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点。

头指针与头结点的异同

头指针：

• 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针
• 头指针具有标志作用，所以常用头指针冠以链表的名字
• 无论链表是否为空，头指针均不为空。头指针是链表的必要元素

头结点：

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

线性表链式存储结构代码描述

定义一个单链表

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */

单链表的读取

/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;        /* 声明一结点p */
    p = L->next;        /* 让p指向链表L的第一个结点 */
    j = 1;        /*  j为计数器 */
    while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */
    {   
        p = p->next;  /* 让p指向下一个结点 */
        ++j;
    }
    if ( !p || j>i ) 
        return ERROR;  /*  第i个元素不存在 */
    *e = p->data;   /*  取第i个元素的数据 */
    return OK;
}

单链表的插入

核心代码
s->next = p->next;  //将p的后继结点赋值给S的后缀
p->next = s;        //将S赋值给p的后继

/* 初始条件：链式线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
　　int j;
　　LinkList p,s;
　　p = *L;
　　j = 1;
　　while (p && j < i) /* 寻找第i个结点 */
　　{
　　　　p = p->next;
　　　　++j;
　　}
　　if (!p || j > i)
　　　　return ERROR; /* 第i个元素不存在 */
　　s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */
　　s->data = e;
　　s->next = p->next; /* 将p的后继结点赋值给s的后继 */
　　p->next = s; /* 将s赋值给p的后继 */
　　return OK;
}

单链表的删除

核心代码
q = p->next;
p->next = q->next;
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j < i)    /* 遍历寻找第i个元素 */
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i) 
        return ERROR;           /* 第i个元素不存在 */
    q = p->next;
    p->next = q->next;            /* 将q的后继赋值给p的后继 */
    *e = q->data;               /* 将q结点中的数据给e */
    free(q);                    /* 让系统回收此结点，释放内存 */
    return OK;
}

对于插入或删除数据越频繁的操作，单链表的效率优势就越明显

单链表的整表创建

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
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;             /*  随机生成100以内的数字 */
        p->next = (*L)->next;    
        (*L)->next = p;                        /*  插入到表头 */
    }
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
    LinkList p,r;
    int i;
    srand(time(0));                      /* 初始化随机数种子 */
    *L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
    r=*L;                                /* r为指向尾部的结点 */
    for (i=0; i<n; i++) 
    {
        p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */
        p->data = rand()%100+1;           /*  随机生成100以内的数字 */
        r->next=p;                        /* 将表尾终端结点的指针指向新结点 */
        r = p;                            /* 将当前的新结点定义为表尾终端结点 */
    }
    r->next = NULL;                       /* 表示当前链表结束 */
}

单链表的整表删除

/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{ 
    LinkList p,q;
    p=(*L)->next;           /*  p指向第一个结点 */
    while(p)                /*  没到表尾 */
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;        /* 头结点指针域为空 */
    return OK;
}

单链表结构与顺序存储结构的对比

存储分配方式

• 顺序存储结构用一段连续存储单元依次存储线性表的数据元素
• 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素

时间性能

• 查找
  • 顺序存储结构O(1)
  • 单链表O(n)
• 插入和删除
  • 顺序存储结构需要平均移动表长一半的元素，时间复杂度为O(n)
  • 单链表在找出位置的指针后，插入和删除时间复杂度仅为O(1)

空间性能

• 顺序存储结构需要预分配存储空间，容易浪费或溢出
• 单链表不需要分配存储空间，元素个数不受限制

静态链表

用数组描述的链表叫做静态链表

/* 线性表的静态链表存储结构 */
typedef struct 
{
    ElemType data;
    int cur;  /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];


/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space) 
{
    int i;
    for (i=0; i<MAXSIZE-1; i++)  
        space[i].cur = i+1;
    space[MAXSIZE-1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
    return OK;
}

静态链表的插入操作

为了辨明数组中哪些分量未被使用，将所有未被使用过的及已被删除的分量用游标链成一个备用的链表，每当进行插入时，便可以从备用链表上取得第一个结点作为待插入的新结点

/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space) 
{ 
    int i = space[0].cur;                   /* 当前数组第一个元素的cur存的值 */
                                            /* 就是要返回的第一个备用空闲的下标 */
    if (space[0]. cur)         
        space[0]. cur = space[i].cur;       /* 由于要拿出一个分量来使用了， */
                                            /* 所以我们就得把它的下一个 */
                                            /* 分量用来做备用 */
    return i;
}

/*  在L中第i个元素之前插入新的数据元素e   */
Status ListInsert(StaticLinkList L, int i, ElemType e)   
{  
    int j, k, l;   
    k = MAXSIZE - 1;   /* 注意k首先是最后一个元素的下标 */
    if (i < 1 || i > ListLength(L) + 1)   
        return ERROR;   
    j = Malloc_SSL(L);   /* 获得空闲分量的下标 */
    if (j)   
    {   
        L[j].data = e;   /* 将数据赋值给此分量的data */
        for(l = 1; l <= i - 1; l++)   /* 找到第i个元素之前的位置 */
           k = L[k].cur;           
        L[j].cur = L[k].cur;    /* 把第i个元素之前的cur赋值给新元素的cur */
        L[k].cur = j;           /* 把新元素的下标赋值给第i个元素之前元素的ur */
        return OK;   
    }   
    return ERROR;   
}

静态链表的删除操作

/*  删除在L中第i个数据元素   */
Status ListDelete(StaticLinkList L, int i)   
{ 
    int j, k;   
    if (i < 1 || i > ListLength(L))   
        return ERROR;   
    k = MAXSIZE - 1;   
    for (j = 1; j <= i - 1; j++)   
        k = L[k].cur;   
    j = L[k].cur;   
    L[k].cur = L[j].cur;   
    Free_SSL(L, j);   
    return OK;   
} 

/*  将下标为k的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k) 
{  
    space[k].cur = space[0].cur;    /* 把第一个元素的cur值赋给要删除的分量cur */
    space[0].cur = k;               /* 把要删除的分量下标赋值给第一个元素的cur */
}

静态链表的长度

/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
    int j=0;
    int i=L[MAXSIZE-1].cur;
    while(i)
    {
        i=L[i].cur;
        j++;
    }
    return j;
}

静态链表的优缺点

• 优点：在插入和删除操作时，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中插入和删除操作需要移动大量元素的缺点
• 缺点：没有解决连续存储分配带来的表长难以确定的问题，失去了顺序存储结构随机存取的特性

循环链表

 将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环。

双向链表

双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域

/* 线性表的双向链表存储结构*/
typedef struct DulNode
{
    ElemType data;
    struct DoLNode *prior;     //直接前驱指针
    struct DoLNode *next;     //直接后继指针      
}DulNode,*DuLinkList;

对于某一节点p，它的后继的前驱是它自己，它的前驱的后继也是它自己

p->next->prior = p = p->prior->next

双向链表的插入操作

s->prior = p;        //把p赋值给s的前驱，如图中的1
s->next = p->next;   //把p->next赋值给s的后继，如图中2
p->next->prior = s;  //把s赋值给p->next的前驱，如图中3
p->next = s;         //把s赋值给p的后继，如图中4

双向链表的删除操作

p->prior->next = p->next;  //把p->next赋值给p->prior的后继
p->next->prior = p->prior; //把p->prior赋值给p->next的前驱
free(p);                   //释放结点