线性表

定义

零个或多个数据元素组成的有限序列
  注：   
    除首尾元素外，线性表中每个元素有且仅有一个前驱和后继元素
    线性表是有限的、有序的

线性表的顺序存储结构 -静态分配数组

定义

#define MAX_SIZE 20 //存储空间初始分配大小
typedef int ElemType; //根据实际情况定义元素的数据类型
typedef struct{
    ElemType data[MAX_SIZE]; //数组存储数据元素，最大值为MAX_SIZE
    int length; //线性表当前长度
}SqList;

基本操作

//如果存在，返回线性表中第i个的元素
bool GetElem(SqList L,int i,ElemType *e){
    if(L.length==0||i<1||i>L.length){
        return false;
    }
    *e=L.data[i-1];
    return true;
}
//在线性表第i个位置插入元素e 1<=i<=L->length
bool ListInsert(SqList *L,int i,ElemType e){
    if(L->length==MAX_SIZE){ //线性表存储空间已满
        return false;
    }
    if(i<1||i>L->length-1){ //检查插入位置合法性
        return false;
    }
    if(i<=L->length){ //插入位置不是表尾
        for(int k=L->length-1;k>=i-1;k++){
            L->data[k+1]=L->data[k];
        }
    }
    L->data[i-1]=e;
    L->length++;
    return true;
}

//删除线性表第i个位置元素,并用e返回 1<=i<=L->length
bool ListDelete(SqList *L,int i,ElemType *e){
    if(L->length==0){  //线性表为空
        return false;
    }
    if(i<1||i>L->length){ //检查位置合法性
        return false;
    }
    *e=L->data[i-1];
    if(i<L->length)
    for(int k=i;k<L->length;k++){
        L->data[k-1]=L->data[k];
    }
    L->length--;
    return true;
}

线性表的链式存储结构

单链表

    data：数据域，存放元素
    next：指针域，指向下一个结点，若是尾结点则指向NULL

链表可以带头结点

头结点和头指针的区别：
头结点是为了操作的统一和方便设立的，放在链表第一个结点之前，其数据域一般无意义（可以拿来存放链表长度），有了头结点，对在第一个结点前的插入和删除操作与其他位置结点的操作就统一了。链表不一定必须带头结点。
头指针是指向链表第一个结点的指针，若链表有头结点，则是指向头结点的指针。头指针具有标识作用，标识一个链表的开始，一般把头指针命名为链表的名字。无论链表是否为空，头指针均不为空，链表必须有头指针。

定义

typedef struct Node{ //结点定义
    ElemType data;
    struct Node *next;
}Node,LinkList; //单链表定义

基本操作（带头结点）

//初始化，创建头结点
LinkList *initList(LinkList *L)
{
    L = (LinkList *) malloc(sizeof(LinkList));//为头结点分配空间
    L->next = NULL;//头结点指针域置空
    return L;
}
//将元素插入指定位置
int insertLinkList(LinkList *L, int pos, ElemType e)
{
    if(pos < 1 || pos > getLen(L)+1) return 0;//插入位置错误
    LinkList *r = L, *n;
    n = (LinkList *) malloc(sizeof(LinkList));
    n->data = e;
    n->next = NULL;
    for（int i=0;i<pos;i++)
    {
        r = r->next;//将尾指针移动到插入位置前一个
    }
    n->next = r->next;//先把新指针（插入值）链入尾指针后一个节点
    r->next = n;//再把新指针（插入值）链入尾指针之后
    return 1;
}
//将指定位置元素删除，并用e返回其值
int deleteLinkList(LinkList *L, int pos, ElemType *e)
{
    if(pos < 1 || pos > getLen(L)) return 0;//删除位置错误
    LinkList *r = L, *d;
    while(--pos > 0)
    {
        r = r->next;//将尾指针移动到删除位置
    }
    d = r->next;//删除元素节点
    *e = d->data;//保存删除元素值
    r->next = d->next;//将尾指针跳过删除节点链入下一个节点
    free(d);//释放删除节点
    return 1;
}
//查找指定元素，返回指定元素位序
int seachLinkList(LinkList *L, ElemType e)
{
    if(isEmpty(L)) return -1;
    int pos = 1;//位序从1开始、下标从零开始
    LinkList *r = L->next;
    while(r)
    {
        if(r->data == e) return pos;//找到指定元素，返回位序
        r = r->next;//尾指针后移
        pos ++;
    }
    return -1;//遍历完成仍未找到返回-1
}
//获得链表长度
int getLen(LinkList *L)
{
    if(L->next == NULL) return 0;//头指针指针域为空，说明单链表不含任何元素
    int len = 0;
    LinkList *r = L->next;
    while(r)
    {
        r = r->next;//尾指针后移
        len++;
    }
    return len;
}
//判空
int isEmpty(LinkList *L)
{
    return !L->next;//L->next == NULL亦可
}
//打印输出链表
void printLinkList(LinkList *L)
{
    LinkList *p;
    p = L->next;
    while(p)
    {
        printf("%d ",p->data);
        p = p->next;
    }
}

建立单链表

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

单链表创建步骤：
    1. 声明一个辅助结点p和计数器i
    2. 初始化一个空链表L
    3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表
    4. 循环：
           生成新结点赋值给p
           将p结点插入到链表中

根据插入位置的不同，可以分为头插法和尾插法。

头插法

//建立带头结点的长度为len的线性单链表（头插法）
LinkList *List_HeadInsert(int len)
{
    int i;
    ElemType e;
    Node *p;//辅助结点p
    LinkList *L = (LinkList*)malloc(sizeof(Node));
    L->next=NULL;//先建立一个带头结点的单链表
    for( i=0;i<len;i++){
        p=(Node*)malloc(sizeof(Node));
        scanf("%d",&e);
        p->data=e;
        p->next=L->next;
        L->next=p;//插入到链表头
    }
    return L;
}
头插法建立单链表，读入的数据顺序与生成的链表中的元素顺序是相反的。

尾插法

// 使用尾插法建立单链表L
LinkList *List_TailInsert(int len) {
    int i;
    int x;            //设ElemType为整型int
    LinkList *L = (LinkList *) malloc(sizeof(Node)); //建立头结点(初始化空表)
    Node *s, *r = L; //r为表尾指针
    for (i = 0; i < len; i++) {
        scanf("%d", &x);//输入要插入的结点的值
        s = (Node *) malloc(sizeof(Node));
        s->data = x;
        r->next = s;
        r = s;       //r指针指向新的表尾结点
    }
    r->next = NULL;  //尾结点指针置空
    return L;
}
头插法建立单链表，读入的数据顺序与生成的链表中的元素顺序相同

链表的逆置

//带头结点
//思路：逆置链表初始为空，原表中结点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空；
LinkList *Inverse(LinkList *L)
{
	LNode *p, *q;
	p = L->next;     //p指针指向第一个结点
	L->next = NULL;  //头结点指向NULL 
	while (p != NULL){
		q = p;
		p = p->next;
		q->next = L->next;  
		L->next = q;
	}
	return L;
}
//不带头结点
//在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。
LinkList *Inverse(LinkList *L)
{
	LNode *pre, *temp;
	while(head){
       temp=head->next;
       head->next=pre;
       pre=head;
       head=temp;
   }
   return pre;
}

双链表

prior:指针域，指向结点的前驱结点，若是头结点则指向NULL
data:数据域
next：指针域，指向下一个结点，若是尾结点则指向NULL

定义

    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 = NULL;   //头结点的prior指针永远指向NULL
    L->next = NULL;    //头结点之后暂时还没有结点
    return true;
}
//判断双链表是否为空
bool Empty(DLinklist L) {
    if (L->next == NULL)    //判断头结点的next指针是否为空
        return true;
    else
        return false;
}
//将结点 *s 插入到结点 *p之后
bool InsertNextDNode(DNode *p, DNode *s) { 
    if (p == NULL || s == NULL) //非法参数
        return false;

    s->next = p->next;
    if (p->next != NULL)   //p不是最后一个结点=p有后继结点
        p->next->prior = s;
    s->prior = p;
    p->next = s;

    return true;
}
//删除p结点的后继结点
bool DeletNextDNode(DNode *p) {
    if (p == NULL) return false;
    DNode *q = p->next;            //找到p的后继结点q
    if (q == NULL) return false;     //p没有后继结点;
    p->next = q->next;
    if (q->next != NULL)           //q结点不是最后一个结点
        q->next->prior = p;
    free(q);

    return true;
}
//销毁一个双链表
bool DestoryList(DLinklist L) {
    //循环释放各个数据结点
    while (L->next != NULL) {
        DeletNextDNode(L);  //删除头结点的后继结点
        free(L); //释放头结点
        L = NULL;  //头指针指向NULL
    }
}

循环链表

循环单链表

链表的最后一个结点的指针不是NULL，而是指向头结点,其余操作与单链表类似

typedef struct LNode{            
    ElemType data;               
    struct LNode *next;  
}DNode, *Linklist;
//初始化一个循环单链表
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode)); //分配一个头结点
    if(L==NULL)             //内存不足，分配失败
        return false;
    L->next = L;            //头结点next指针指向头结点
    return true;
} 
//判断循环单链表是否为空（终止条件为p或p->next是否等于头指针）
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指向头结点
} 
//判断循环双链表是否为空
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;
}

循环链表的插入和删除

//插入
bool InsertNextDNode(DNode *p, DNode *s){ 
    s->next = p->next;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
}
//删除p的后继结点q
p->next = q->next;
q->next->prior = p;
free(q);