线性表学习笔记

　　最近学习数据结构的线性表，主要是借助教材《数据结构》（C语言版）那本。在课堂上学习的时候没有认真听讲，唉，，，书上面的程序没有写过，知识了解大概，现在开始准备面试，数据结构是首先要拿下的基础知识，所以开始了数据结构的再学习，下面是线性表部分，下面还会有栈、队列、串、数组、树、图、排序、查找等等。程序不一定完全正确，都是用C语言实现的书上的例子，没有包括所有的线性表性质，但基本上实现了线性表基本操作（顺序和链式），欢迎大家提出宝贵意见。

下面附上练习源码（仅作参考）

/**
 * 线性表的各种操作
 * 对应《数据结构(C语言版)》的教材
 * @author:zhaoyafei
 * @aime:2015-6-16
 */
//引入必要头文件
#include <stdio.h>
#include <stdlib.h>
//约定的宏定义  
#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
//Status是函数的类型，其值是函数结果的状态码
typedef int Status;
//数据元素约定为ElemType，可以自己定义
typedef int ElemType;

//线性表的顺序实现
typedef struct{
    ElemType * elem;  //存储空间的基地址
    int      lenght;  //当前的长度
    int      listsize;//当前分配的存储容量
}SqList;

//线性表的链式实现
typedef struct LNode{
    ElemType     data; //存储数据
    struct LNode * next; //递归定义，指向下一个元素
}LNode,*LinkList;//结构体类型指针

//双向链表的实现
typedef struct DuLNode{
    ElemType data;
    struct DuLNode *prior;
    struct DuLNode *next;
}DulNode, *DuLinkList;

/*************************顺序实现***************************/
//构造空的线性表
Status InitList(SqList &L, int lenght){
    if (lenght == 0) {
        lenght = LIST_INIT_SIZE;
    }
    L.elem = (ElemType *)malloc(lenght * sizeof(ElemType));

    if(!L.elem){
        exit(OVERFLOW);  //分配存储空间失败
    }
    L.lenght = 0;        //初始空表长度为0
    L.listsize = lenght ;//初始存储容量为100
    return OK;
}

//在第i的位置插入元素e
Status ListInse_Sq(SqList &L, ElemType e, int i){
    ElemType *p, *q;
    if(i < 0 || i > L.lenght){
        //i的值不合法
        return ERROR;
    }
    if (L.lenght >= L.listsize) {
        //空间不够，重新分配存储空间
        ElemType *newbase = (ElemType *)realloc(L.elem ,(L.listsize + LISTINCREMENT)*sizeof(ElemType));
        if(!newbase){
            return OVERFLOW;            //存储分配失败
        }
        L.elem = newbase;               //记录新基值
        L.listsize += LISTINCREMENT;    //增加存储容量
    }
    q = &L.elem[i];                     //得到元素插入的位置
    for (p = &L.elem[L.lenght]; p >= q; --p) {
        *p = *(p-1);                    //把插入位置元素之后的元素往后移动
    }
    *q = e;                             //插入新元素e
    L.lenght +=1;
    return OK;
}   

//删除第i位置元素，并用e返回其值
Status ListDelete_sq(SqList &L, int i, ElemType &e){
    int *p,*q;
    if(i < 0 || i > L.lenght){
        return ERROR;  //i的值不合法
    }
    q = &L.elem[i];    //被删除元素的位置为i;
    e = *q;            //被删除元素的值赋值给e
    //被删除元素后的元素左移
    for (p = q; p< (L.elem + L.lenght); p++){  
        *p = *(p + 1);
    }
    --L.lenght;
    return OK;
}  

//得到第i个元素
Status GetElem(SqList &L, int i, ElemType &e){
    ElemType *p;
    p = L.elem;
    int j = 1;
    if(i < 1){
        exit(OVERFLOW);//下表不合法
    }
    while(p && j < i){
        p = &L.elem[j];
        j++; //寻找第i个元素，同时检查p是否越界
    }
    if(!p || j > i){
        return false;//下标越界
    }
    e = L.elem[j-1];
    return OK;
}

//打印线性表
void PrintList(SqList L){
    for(int i = 0; i < L.lenght; i++) {
        printf("%d ", *(L.elem + i));
    }
    printf("
");
} 

//合并两个线性表
void Combine(SqList La, SqList Lb, SqList &Lc){
    ElemType *pa, *pb, *pc;
    Lc.listsize =  La.lenght + Lb.lenght;
    InitList(Lc, Lc.listsize); //初始化LCpc = Lc.elem;
    Lc.lenght = Lc.listsize;
    pc = Lc.elem;
    pa = La.elem;
    pb = Lb.elem;
    //还没有循环完
    while (pa <= &La.elem[La.lenght -1] && pb <= &Lb.elem[Lb.lenght -1]){
        if (*pa <= *pb){
            *pc++ = *pa++;
        }else{
            *pc++ = *pb++;
        }
    }
    //插入La的剩余元素  
    while(pa <= &La.elem[La.lenght -1]){
        *pc++ = *pa++;
    }
    //插入Lb的剩余元素 
    while(pb <= &Lb.elem[Lb.lenght -1]){
        *pc++ = *pb++;
    }
} 

//冒泡排序法，排序线性表
void Sort(SqList &L){
    ElemType *pd1,*pd2,nums,length = L.lenght;
    for(int num = 0; num < length - 1; num++){
        for(int num1 = num + 1 ;num1 < length; num1++){
            pd1 = &L.elem[num];
            pd2 = &L.elem[num1];
            if(*pd1 > *pd2){
                nums = *pd1;
                *pd1 = *pd2;
                *pd2 = nums;
            }
        }
    }
}
 
/*************************链式实现***************************/
//单链表初始化
Status InitList_L(LinkList &L){
    L = (LinkList)malloc(sizeof(LNode));
    if(!L){
        exit(OVERFLOW);  //分配存储空间失败
    }
    L->next = NULL; //初始的头结点为空
    return OK;
}

//逆向建立单链表
Status CreateList_L(LinkList &L, int n){
    L = (LinkList)malloc(sizeof(LNode));
    if(!L){
        exit(OVERFLOW);  //分配存储空间失败
    }
    L->next = NULL; //初始的头结点为空
    printf("请输入5个整数：
");
    for(int i = n; i > 0; --i){
        LinkList p;
        p = (LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->data);
        p->next = L->next;
        L->next = p;
    }
    return OK;
}

//在建立好的单链表中的第n个位置插入元素e
Status ListInsert_L(LinkList &o, int n, ElemType e){
    LinkList L = o;
    int j = 0;//记录插入点的位置
    while(L && j < n - 1 && n > 0){
        L = L->next;
        j++;
    }
    if(L){//合法
        LinkList p;
        p = (LinkList)malloc(sizeof(LNode));
        p->data = e;
        p->next = L->next;
        L->next = p;
        return OK;
    }
}

//在建立好的单链表中的第n个位置删除元素，并用e返回
Status ListDelete_L(LinkList &o, int n, ElemType e){
    LinkList L = o;
    int j = 0; //记录插入点的位置
    while(L && j < n - 1 && n > 0){
        L = L->next;
        j++;
    }
    if(L && L->next){//合法
        LinkList q;
        q = L->next;
        e = q->data;
        L->next = q->next;
        free(q);
        return OK;
    }
}

//合并链式线性表
void Combine_L(LinkList &La, LinkList &Lb,LinkList &Lc){
    LinkList pa,pb,pc;
    pa = La->next;
    pb = Lb->next;
    //Lc = La;//把La作为Lc的头结点
    pc = Lc;
    while(pa && pb){
        if(pa->data <= pb->data){//判断两者得大小
            pc->next = pa;
            pa = pa->next; //pa指针下移
        }else{
            pc->next = pb;
            pb = pb->next; //pb指针下移
        }
        pc = pc->next; //pc下移一位
    }
    pc->next = pa ? pa : pb;
    free(La);
    free(Lb);
}

//得到第i个元素
Status GetElem_L(LinkList &L, int i, ElemType &e){
    LinkList p;
    p = L;
    int j = 0;
    if(i < 1){
        exit(OVERFLOW);//下表不合法
    }
    while(p && j < i){
        p = p->next;//寻找第i个元素，同时检查p是否越界
        j++;
    }
    if(!p || j > i){
        return false;//下标越界
    }
    e = p->data;
    return OK;
}

//冒泡排序法排序单链表
void Sort_L(LinkList &L){
    LinkList p,q;
    int num;
    for(p = L; p != NULL; p = p->next){
        for(q = p->next;q != NULL; q = q->next){
            if(p->data > q->data){
                num = p->data;
                p->data = q->data;
                q->data = num;
            }
        }
    }
}

//打印链表节点信息
void PrintfList_L(LinkList L){
    if(L){
        do{
            L = L->next;
            printf("%d ",L->data);
        }while(L->next);
    }
    printf("
");
}

/***********************双向链表实现*************************/
//单链表初始化
Status InitList_Du(DuLinkList &L){
    L = (DuLinkList)malloc(sizeof(DulNode));
    if(!L){
        exit(OVERFLOW);  //分配存储空间失败
    }
    L->next = NULL; //初始的头结点为空
    L->prior = NULL;
    return OK;
}

//在双向链表中第n个位置插入元素e;
Status ListInsert_Dul(DuLinkList &P, int n, ElemType e){
    DuLinkList L = P;
    int j = 0;//记录插入点的位置
    while(L && j < n - 1 && n > 0){
        L = L->next;
        j++;
    }
    if(L){//合法
        DuLinkList c;
        c = (DuLinkList)malloc(sizeof(DulNode));
        c->data = e;
        c->next = L->next;
        L->next = c;
        if(c->next){
            c->next->prior = c;
        }
        c->prior = L;
        return OK;
    }
}

//在双向链表中第n个位置删除元素，并用e返回数据;
Status ListDelete_Dul(DuLinkList &P, int n, ElemType &e){
    DuLinkList L = P;
    int j = 0;//记录插入点的位置
    while(L && j < n && n > 0){
        L = L->next;
        j++;
    }
    if(L){//合法
        e = L->data;
        L->prior->next = L->next;
        L->next->prior = L->prior;
        //free(L);
        return OK;
    }
}

//打印双向链表的数据
void PrintList_Du(DuLinkList L){
    if(L){
        do{
            L = L->next;
            printf("%d ",L->data);
        }while(L->next);
    }
    printf("
");
}

//主方法
void main(){
    ElemType e,f;
    int init,i,elem;    
    int TestData[8] = {9,1,8,5,7,2,1,3};
    int TestDataTwo[5] = {8,3,2,6,1};
    
    printf("*************线性表顺序实现*************
");
    SqList La,Lb,Lc;
    init = InitList(La, LIST_INIT_SIZE);
    
    for (i = 0; i < 8; i++) {//初始化La
        ListInse_Sq(La, TestData[i], i);
    }
    printf("La:
构造后的La:");
    PrintList(La);
    
    GetElem(La,3,e);//得到第3个元素
    printf("得到La的第3个元素是:%d
",e);

    ListDelete_sq(La,3,e);//线性表的删除操作
    printf("删除后的La:");
    PrintList(La);

    ListInse_Sq(La,e,3);//还原数据
  
    Sort(La);//排序  
    printf("排序后的La:");
    PrintList(La);

    printf("Lb:
构造后的Lb:");
    InitList(Lb, LIST_INIT_SIZE);
    for (i = 0; i < 5; i++) {  
        ListInse_Sq(Lb, TestDataTwo[i], i);
    }
    PrintList(Lb);

    Sort(Lb);//排序Lb
    printf("排序后的Lb:");
    PrintList(Lb);

    printf("合并La与Lb后的Lc:");//合并La,Lb
    Combine(La, Lb, Lc);
    PrintList(Lc);

    printf("
*************线性表链式实现*************
");
    LinkList LaL,LbL,LcL,LdL;
    //CreateList_L(LbL,5)//逆序建立单链表
    InitList_L(LaL);//初始化单链表
    printf("LaL:
构造后的LaL:");
    for (i = 1; i <= 8; i++) {//初始化La
        ListInsert_L(LaL, i, TestData[i-1]);
    }

    PrintfList_L(LaL);//打印单链表信息

    GetElem_L(LaL,3,e);//得到第3个元素
    printf("得到LaL的第3个元素是:%d
",e);

    ListInsert_L(LaL,3,10);//插入新元素
    printf("插入后的LaL:");
    PrintfList_L(LaL);
    
    ListDelete_L(LaL,3,e);//删除添加的新元素
    printf("删除后的LaL:");
    PrintfList_L(LaL);

    Sort_L(LaL);//排序  
    printf("排序后的LaL:");
    PrintfList_L(LaL);
    
    printf("LbL:
构造后的LbL:");
    InitList_L(LbL);//初始化单链表
    
    for (i = 1; i < 6; i++) {  
        ListInsert_L(LbL, i, TestDataTwo[i-1]);
    }
    PrintfList_L(LbL);
    
    printf("排序后的LbL:");
    Sort_L(LbL);//排序  
    PrintfList_L(LbL);

    printf("合并La与Lb后的Lc:");
    InitList_L(LcL);//初始化单链表
    Combine_L(LaL, LbL, LcL);
    PrintfList_L(LcL);

    printf("
*************双向链表的实现*************
");
    DuLinkList DuLa;
    //初始化双向链表
    InitList_Du(DuLa);
    
    for (i = 1; i < 9; i++) {
        ListInsert_Dul(DuLa, i, TestData[i-1]);
    }
    printf("DuLa:
构造后的DuLa:");
    PrintList_Du(DuLa);
    printf("添加新元素元素后的DuLa:");
    ListInsert_Dul(DuLa, 3, 10); //在第三个位置添加元素10
    PrintList_Du(DuLa);

    printf("删除新添加元素后的DuLa:");
    ListDelete_Dul(DuLa,3,e);//删除元素
    PrintList_Du(DuLa);

}

 运行结果：

需要补充一下知识点：C语言动态内存分配，C动态内存分配主要有这几个函数：malloc、free、calloc、realloc

malloc：原型 void *malloc（unsigned size）

size表示分配内存的大小，函数会从内存池里取一块连续的内存，返回指向内存起始位置的指针，这块内存进行初始化，需要手动初始化也可以通过calloc初始化。

注意：malloc分配的是连续的内存。可用内存小于请求，malloc向操作系统请求得到更多的内存，如果无法提供更多内存，则返回一个NULL指针。

例如：初始化线性表（构造空的线性表 ）

L.elem = (ElemType *)malloc(lenght * sizeof(ElemType));

calloc：原型 void*calloc（unsigned n，unsigned size）

其中n表示需要分配内存的数据项个数，size指每个数据项的大小。malloc和calloc之间主要区别：calloc返回指向内存的指针之前把它初始化未0。 请求内存数量的方式不同。

realloc：原型：void *realloc（void*list，unsigned size）

将list所指的已分配内存区的大小改为size。realloc是修改一个原先已经分配的内存块的大小。如果原先的内存块无法改变大小，realloc将分配另一块正确大小的内存，并把原先那块内存的内容复制到新的快上。

例如：ElemType *newbase = (ElemType *)realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));  

free()：  原型：void free (void* list);

　　C语言中，free可以释放calloc, malloc, realloc动态分配的空间，注意：释放的不是自己定义的指针，而是定义的指针指向的空间。自己定义的普通指针能不能可以通过free
释放，这个要看情况。如果定义的指针指向动态分配的地址空间，则可以使用free释放指针指向的这段空间；否则，就不能使用free释放指针指向的空间。