线性表

首先，线性表是一种最简单的一种数据结构。嗯，简单的说，一个线性表是n个数据元素的有限序列。（元素：可以是int ,float, double 等）
线性表的储存结构是这样的：

在表中a(i - 1)领先于ai ,ai 领先于 a(i+1)，则称 a(i-1)是ai的直接前驱元素，a(i+1)是ai的直接后驱元素。对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点（a1），有且仅有一个终端结点没有后继但有一个前驱结点（an），其它的结点都有且仅有一个前驱和一个后继结点。

线性表的顺序是指用连续的存储单元来存储线性表的数据元素。线性表的顺序存储结构是一种随机存取的存储结构。

其一般有两种顺序存储方式：数组和链表。（分解的用链表，最后附上数组的）

　　（1）用数组来存：　　优点：可以随机访问元素。　　缺点：插入和删除的时候需要移动大量的元素。

　　（2）用链表：　　优点：对于新增和删除很方便，不需要移动元素。　　缺点：不方便随机访问元素，需要一定元素。

　　

 

1.数组的实现

#include <stdio.h>
#include <stdlib.h>

/******* 创建别名 ******/
typedef int Status;
typedef int ElemType;

/******* 宏定义 *******/
#define TRUE   1  
#define FALSE   0  
#define OK    1  
#define ERROR   0  
#define INFEASIBLE -1  
#define OVERFLOW -2  

/******* 线性表的动态分配顺序存储结构 *******/
#define LIST_INIT_SIZE 100    //线性表存储空间的初始分配量
#define LISTINCREMENT 10    //线性表存储空间的分配增量
typedef struct{
    ElemType *elem;    //存储空间基址
    int length;        //当前长度
    int listsize;    //当前分配的存储容量
}SqList;

/******** 构造一个空的线性表 ********/
Status InitList_Sq(SqList &L){
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    //让电脑分配（ElemType）的字节 * LIST_INIT_SIZE 数量个内存空间，然后地址给L.elem
    if (!L.elem)    //存储分配失败
        exit(OVERFLOW);    
    /*
        exit() 是电脑函数
        exit()通常是用在子程序中用来终结程序用的，使用后程序自动结束，跳回操作系统。
        exit(0)表示正常退出，
        exit(x)（x不为0）都表示异常退出
    */
    L.length = 0;    //空表长度为0
    L.listsize = LIST_INIT_SIZE;    //初始存储的容量
    return OK;    //构造成功
}

对线性表的一些基本操作：

 

#include <stdio.h>
#include <stdlib.h>

/******* 创建别名 ******/
typedef int Status;
typedef int ElemType;

/******* 宏定义 *******/
#define TRUE   1  
#define FALSE   0  
#define OK    1  
#define ERROR   0  
#define INFEASIBLE -1  
#define OVERFLOW -2  

/******* 线性表的动态分配顺序存储结构 *******/
#define LIST_INIT_SIZE 100    //线性表存储空间的初始分配量
#define LISTINCREMENT 10    //线性表存储空间的分配增量
typedef struct{
    ElemType *elem;    //存储空间基址
    int length;        //当前长度
    int listsize;    //当前分配的存储容量
}SqList;

/******** 构造一个空的线性表 ********/
Status InitList_Sq(SqList &L){
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    //让电脑分配（ElemType）的字节 * LIST_INIT_SIZE 数量个内存空间，然后地址给L.elem
    if (!L.elem)    //存储分配失败
        exit(OVERFLOW);    
    /*
        exit() 是电脑函数
        exit()通常是用在子程序中用来终结程序用的，使用后程序自动结束，跳回操作系统。
        exit(0)表示正常退出，
        exit(x)（x不为0）都表示异常退出
    */
    L.length = 0;    //空表长度为0
    L.listsize = LIST_INIT_SIZE;    //初始存储的容量
    return OK;    //构造成功
}

/****** 在L中第i个位置之前插入新的元素e *******/
Status insertList(SqList &L, ElemType e, int i){
    ElemType *p, *q;    //申明两个类型为ElemType的指针变量
    if (i < 0 || i > L.length + 1)
        return ERROR;  //i值不合法(i的合法范围为 1<=i<=L.length+1) 
    if (L.length >= L.listsize) {    //当前的存储空间已满，需要增加分配
        ElemType *newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemType));
        /*
            先判断当前的指针是否有足够的连续空间，如果有，扩大L.elem指向的地址，并且将L.elem返回；
            如果空间不够，先按照newsize(L.listsize + LISTINCREMENT)*sizeof(ElemType)指定的大小分配空间，
            将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来L.elem所指内存区域
            （注意：原来指针是自动释放，不需要使用free），同时返回新分配的内存区域的首地址。即重新分配存储器块的地址。
            如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。
        */
        if (!newbase)
            return OVERFLOW;   //存储分配失败(即newbase 为NULL)  
        L.elem = newbase;               //新基值  
        L.listsize += LISTINCREMENT;    //增加存储容量  
    }
    q = &L.elem[i - 1];                     //q为插入的位置  
    for (p = &L.elem[L.length]; p >= q; --p) {
        *(p + 1) = *p;                    //i元素及之后的元素往后移动  
    }
    *q = e;                             //插入e  
    L.length++;        //表长加1    
    return OK;    //操作成功
}

/******** 删除第i个元素，并用e返回其值 **********/
Status deleteListElem(SqList &L, int i, ElemType &e){
    ElemType *p, *q;    //申明两个类型为ElemType的指针变量
    if (i<1 || i > L.length)
        return ERROR;  //i值不合法 (i的合法范围是 1<=i<=L.length) 
    p = &L.elem[i - 1];                       //被删除元素的位置为i，L.elem就是数组名,  
    e = *p;                               //被删除元素的值赋值给e
    q = L.elem + L.length - 1;            //表尾元素的位置
    for (++p; p <= q; p++){       
        *(p - 1) = *p;        //被删除元素后的元素左移
    }
    L.length--;    //表长减一
    return OK;    //操作成功
}

/************** 比较函数 **************/
Status Integercompare(ElemType x, ElemType y){
    if (x == y)
        return OK;
    else
        return ERROR;
}

/****** 在顺序线性表L中查找第i个值与e满足compare()的元素的位序 ******/
int LocateElem_Sq(SqList L, Status e, Status(*compare)(ElemType, ElemType)){
    //Status(*compare)(ElemType, ElemType)是一个函数指针
    int i = 1;    //第一个元素的位序
    int *p;
    p = L.elem;    //p为第一个元素的储存位置
    while (i <= L.length&&!(*compare)(*p++, e))//从头开始一个一个往后比较（当到表尾或找到时跳出）
        i++;
    if (i <= L.length)    //即i在表L 的内部
        return i;    //返回找到的位序
    else
        return 0;    //没有找到
}

/********* 归并La和Lb得到新的线性表Lc *********/
void MergeList_Sq(SqList La, SqList Lb, SqList &Lc){
    //已知顺序线性表La ,Lb的元素按值非递减排列
    ElemType *pa, *pb, *pc;        //申明3个类型为ElemType的指针变量
    Lc.listsize = Lc.length = La.length + Lb.length;    //Lc的长度是La的当前长度+Lb的当前长度
    pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));    //将Lc的首地址给pc
    if (!Lc.elem)    
        exit(OVERFLOW);    //存储分配失败(即Lc.elem 为NULL)
    ElemType *pa_last, *pb_last;    //申明2个类型为ElemType的指针变量
    pa_last = La.elem + La.length - 1;    //pa_last 是线性表La的末地址
    pb_last = Lb.elem + Lb.length - 1;    //pb_last 是线性表Lb的末地址
    while (pa <= pa_last && pb <= pb_last){    //判断La和Lb是否遍历完了
        if (*pa <= *pb) 
            *pc++ = *pa++;        //如果*pa <= *pb，则将*pc = *pa;
        else 
            *pc++ = *pb++;        //否则（*pa<*pb），则将*pc = *pb;
    }
    while (pa <= pa_last) *pc++ = *pa++;    //插入La的剩余元素
    while (pb <= pb_last) *pc++ = *pb++;    //插入Lb的剩余元素
}

int main(){
    //省略
    return 0;
}

2.线性链表实现（单链表）

单链表的逻辑存储状态就是这样的。

一般的操作：

#include <stdio.h>
#include <stdlib.h>

/******* 创建别名 ******/
typedef int Status;
typedef int ElemType;

/******* 宏定义 *******/
#define TRUE   1  
#define FALSE   0  
#define OK    1  
#define ERROR   0  
#define INFEASIBLE -1  
#define OVERFLOW -2  

/******* 单链表的存储结构 ******/
typedef struct LNode{
    ElemType data;    //单链表的数据域
    struct LNode *next;    //单链表的指针域
}LNode, *LinkList;    //*LinkList 是该结构体的指针

/******* 单链表的创建 ********/
Status ListInit_L(LinkList &L){
    L = (LinkList)malloc(sizeof(LNode));    //申请一个头结点
    if (!L)    
        exit(ERROR);    //申请空间失败（L = NULL）
    L->next = NULL;        //建立一个空链表
    return OK;    //操作成功
}

/******* 单链表的初始化 *******/
void ListCreate_L(LinkList &L, int n){
    ElemType data1;
    LinkList p, q;    //创建两个结构体指针
    q = L;    //q指向L的地址
    for (int i = 0; i < n; i++) {        //添加n个数据（即要循环n次）
        p = (LinkList)malloc(sizeof(LNode)); //申请一个新节点  
        scanf("%d", &data1);        //输入数据
        p->data = data1;            //p的数据域为data1
        p->next = q->next;            //p的指针域指向 q的指针域指向的地址
        q->next = p;                //再将q的指针域指向p
        q = p;            //此时将p赋给q
        //后面有配图解释
    }
}

/********* 单链表中寻找元素 *********/
Status GetElem_L(LinkList L, int i, ElemType &e){
    //当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    LinkList p;
    p = L->next;    //初始化，p指向第一个节点
    int j =    1;    //j为计数器
    while (p && j<i){                //顺着指针向后查找，直到p指向第i个元素或p为空
        p = p->next;
        j++;
    }
    if (!p || j >i)            //第i个元素不存在
        return ERROR;
    e = p->data;    //取第i个元素用e储存
    return OK;        //操作成功
}

/********* 单链表中在第i个位置之前插入元素e ***********/
Status ListInsert_L(LinkList &L, ElemType e, int i){
    LinkList s, p = L;    
    int j = 0;    //计数器
    while (p && j < i - 1){                //顺着指针向后查找第i-1节点  
        p = p->next;
        j++;
    }
    if (!p || j > i - 1)    //i小于1或者大于表长加一   就不是合法范围
        return ERROR;
    s = (LinkList)malloc(sizeof(LNode));       //生成新节点  
    s->data = e;
    s->next = p->next;            //插入L中  
    p->next = s;
    //后面有配图解释
    return OK;    //操作成功
}

/****** 删除第i个元素，并由e返回其值 *********/
Status ListDelete_L(LinkList &L, int i, ElemType &e){
    LinkList p, q;
    int j = 0;        //计数器
    p = L;            //初始化,将L的头指针给p
    while (p->next && j < i-1){    //寻找第i个节点，并令p指向其前驱
        p = p->next;
        ++j;
    }
    if (!p->next || j > i-1)  //删除的位置不合理
        return ERROR;
    q = p->next;        //删除节点
    p->next = q->next;
    e = q->data;        //去其值给e
    //后面有配图解释
    free(q);            //释放节点  
    /*
        free是调用操作系统的函数，将原先分配的内存区域释放
        与malloc()函数配对使用，释放malloc函数申请的动态内存。
    */
    return OK;
}

/********* 逆位序输入n个元素的值，初始化单链表L **********/
void CreateLiet_L(LinkList &L, int n){
    LinkList p;
    ElemType data1;
    for (int i = n; i > 0; i--){
        p = (LinkList)malloc(sizeof(LNode));
        scanf("%d", &data1);    //输入元素值
        p->data = data1;
        p->next = L->next;    //插入到表头
        L->next = p;
    }
}

/****** 归并La和Lb得到新的单链表Lc，Lc的元素也按非递减排列 *****/
void mergeList(LinkList  &La, LinkList  &Lb,  LinkList &Lc){  
    LinkList pa, pb, pc;  
    pa  = La->next;  
    pb  = Lb->next;  
    Lc =  pc = La;        //用La的头结点作为Lc的头结点
    while (pa && pa) {        //当pa和pb都不为空的时候
        if (pa->data > pb->data) {  //当pa的数据域大于pb的数据域的时候
            pc->next = pb;            //pc的指针域指向pb
            pc = pb;                //将pb赋给pc
            pb =pb->next;            //pb后移一个
        }else{                        //当pa的数据域小于或等于pb的数据域的时候
            pc->next = pa;            //pc的指针域指向pa
            pc = pa;                //将pa赋给pc
            pa =pa->next;            //pa后移一个
        }  
    }  
    pc->next = pa? pa :pb;            //插入剩余段
    free(Lb);                        //释放Lb的头结点
}

int main(){
    //略
    return 0;
}

 

 

 

 （循环链表和双向链表略）