写在前面

为了考研，需要复习数据结构。而对于数据结构这门学科来说，写代码是非常必要的。用代码把一些常见的数据结构与算法实现一遍，非常有利于对于数据结构的理解。

于是今天是第一章，即线性表的实现。主要参考是王道的数据结构复习指导与黑皮的严蔚敏的教材。虽然代码文件后缀都是cpp，但写法还是C的写法，主要借用了cpp里的&与bool来方便书写。

静态存储的顺序表实现

注意点

静态存储的顺序表，其实就是用数组来实现，主要注意点在于数组的下标和顺序表的位序并不是一一对应的关系，而是差1（顺序表的位序 = 数组的下标 + 1）。要注意这点。

代码

/*
 * @Description: 静态存储的顺序表实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-05 21:39:06
 */
#include<bits/stdc++.h>
#define maxSize 10

// 定义静态存储的顺序表结构
typedef struct{
    int data[maxSize];
    int length;
}SqList;

// 初始化
void initList(SqList &L){
    // 将所有初值设置为0
    for(int i = 0;i < maxSize;i++){
        L.data[i] = 0;
    }
    // 长度设置为0
    L.length = 0;
}

// 插入
bool listInsert(SqList &L,int i,int e){
    // 判断i的范围是否有效
    if(i < 1 || i>L.length+1){
        return false;
    }
    // 判断存储空间是否已经满
    if(L.length >= maxSize){
        return false;
    }
    // 将第i个元素之后的元素后移
    for(int j=L.length;j >= i;j--){
        L.data[j] = L.data[j-1];
    }
    // 在位置i处放入e
    L.data[i-1] = e;
    L.length++;
    return true;
}

// 打印顺序表
void printList(SqList &L){
    printf("顺序表的元素为：\n");
    for(int i = 0;i < L.length; i++){
        printf("%d  ",L.data[i]);
    }
    printf("\n");
}

// 删除
bool listDelete(SqList &L,int i,int &e){
    // 判断i的范围
    if(i < 1 || i > L.length){
        return false;
    }
    // 将被删除的元素赋值给e
    e = L.data[i-1];
    // 将第i个位置后的元素前移
    for(int j=i;j<L.length;j++){
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

// 按值查找
int locateElem(SqList L,int e){
    int i;
    for(i = 0;i < L.length;i++){
        if(L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

// 按位序查找
int getElem(SqList L,int i){
    return L.data[i-1];
}

// 主程序测试
int main(){
    SqList L;
    // 初始化
    initList(L);
    printList(L);
    // 插入几个元素看看
    listInsert(L,1,1);
    listInsert(L,2,2);
    listInsert(L,3,22);
    printList(L);
    // 删除一个元素
    int deleteElem = 0;
    listDelete(L,1,deleteElem);
    printList(L);
    // 查找元素22
    printf("元素22的所在位置为 -> %d\n",locateElem(L,22));
    // 根据位序查找
    printf("位序为1的位置为 -> %d\n",getElem(L,1));
    return 0;
}

动态存储的顺序表实现

注意点

动态存储的顺序表，相当于是在结构体中存储一个指针，当容量不够的时候再去动态申请一波新的空间，把旧的移到新区域就好。其他实现与静态存储的顺序表差别不大。

代码

/*
 * @Description: 动态存储的顺序表实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-06 19:18:08
 */
#include<bits/stdc++.h>
#define initSize 3

// 定义动态存储的顺序表结构
typedef struct{
    int *data;
    int maxSize;
    int length;
}SeqList;

// 初始化顺序表
void initList(SeqList &L){
    // 用malloc函数申请一片连续的存储空间
    L.data = (int *)malloc(initSize * sizeof(int));
    // 长度设为0
    L.length = 0;
    // 最大大小设为初始大小
    L.maxSize = initSize;
}

// 动态增加长度
void increaseSize(SeqList &L,int len){
    int *p = L.data;
    // C
    // L.data = (int *) malloc((L.maxSize + len) * sizeof(int));
    // C++
    L.data = new int[L.maxSize + len];
    // 把数据复制到新区域
    for(int i = 0;i < L.length;i++){
        L.data[i] = p[i];
    }
    // 增加长度
    L.maxSize += len;
    // 释放原有空间
    // C
    // free(p);
    // C++
    delete p;
}

// 插入
bool listInsert(SeqList &L,int i,int e){
    // 判断i的范围是否有效
    if(i < 1 || i>L.length+1){
        return false;
    }
    // 判断存储空间是否已经满
    if(L.length >= L.maxSize){
        // 如果已满，申请更多空间
        // 一次多申请几个
        increaseSize(L,5);
    }
    // 将第i个元素之后的元素后移
    for(int j=L.length;j >= i;j--){
        L.data[j] = L.data[j-1];
    }
    // 在位置i处放入e
    L.data[i-1] = e;
    L.length++;
    return true;
}

// 打印顺序表
void printList(SeqList &L){
    printf("顺序表的元素为：\n");
    for(int i = 0;i < L.length; i++){
        printf("%d  ",L.data[i]);
    }
    printf("\n");
}

// 删除
bool listDelete(SeqList &L,int i,int &e){
    // 判断i的范围
    if(i < 1 || i > L.length){
        return false;
    }
    // 将被删除的元素赋值给e
    e = L.data[i-1];
    // 将第i个位置后的元素前移
    for(int j=i;j<L.length;j++){
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

// 按值查找
int locateElem(SeqList L,int e){
    int i;
    for(i = 0;i < L.length;i++){
        if(L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

// 按位序查找
int getElem(SeqList L,int i){
    return L.data[i-1];
}

// 主程序测试
int main(){
    SeqList L;
    // 初始化
    initList(L);
    printList(L);
    // 插入几个元素看看
    listInsert(L,1,1);
    listInsert(L,2,2);
    listInsert(L,3,22);
    printList(L);
    // 此时已满，测试能不能继续插入
    listInsert(L,2,30);
    printList(L);
    // 删除一个元素
    int deleteElem = 0;
    listDelete(L,1,deleteElem);
    printList(L);
    // 查找元素30
    printf("元素30的所在位置为 -> %d\n",locateElem(L,30));
    // 根据位序查找
    printf("位序为1的位置为 -> %d\n",getElem(L,1));
    return 0;
}

带头结点的单链表实现

注意点

这里实现的是带头结点的单链表，不带头结点的会在各个函数上有着区别，要注意这点。对于有头结点的单链表，需要注意判空条件为L -> next == NULL，即头指针指向NULL，否则都为非空。其他需要注意的便是头插法与尾插法的实现了，这块为难点和重点。

代码

/*
 * @Description: 单链表的实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-06 20:57:47
 */
#include<bits/stdc++.h>

// 定义带头结点的单链表
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LinkList;

// 初始化单链表
bool initList(LinkList &L){
    // 分配一个头结点
    L = (LNode *) malloc(sizeof(LNode));
    // 内存已满
    if (L == NULL){
        return false;
    }
    // 把头结点指向空
    L -> next = NULL;
    return true;
}


// 判断单链表是否为空
bool empty(LinkList L){
    if(L -> next == NULL){
        return true;
    }
    return false;
}

// 链表输出
void printList(LinkList L){
    LNode *p = L -> next;
    printf("单链表内的元素为：\n");
    while(!empty(p)){
        printf("%d ",p->data);
        p = p->next;
    }
    // 最后一个元素虽指向NULL但仍有值，继续打印
    printf("%d ",p->data);
    printf("\n");
}

// 按位查找,返回第i个元素
LNode * getElem(LinkList L,int i){
    if(i < 0){
        return NULL;
    }
    LNode *p;
    int j = 0;
    p = L;
    while(p != NULL && j < i){
        p = p -> next;
        j++;
    }
    return p;
}

// 按值查找
LNode * locateElem(LinkList L,int e){
    LNode *p = L -> next;
    // 循环遍历链表
    while(p != NULL && p->data !=e){
        p = p->next;
    }
    return p;
}

// 后插,在p结点之后插入元素e
bool insertNextNode(LNode *p,int e){
    // 判断是否超出长度
    if(p == NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s == NULL){
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 前插,在p结点之前插入元素e,O(1)
bool insertPriorNode(LNode *p,int e){
    if(p == NULL){
        return false;
    }
    LNode *s = (LNode *) malloc(sizeof(LNode));
    if(s == NULL){
        return false;
    }
    // 相当于把p的值给了s,把新的值e给了p,然后连接起来
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

// 插入
bool listInsert(LinkList &L,int i,int e){
    if(i < 1){
        return false;
    }
    // 找到第i-1个结点
    LNode *p = getElem(L,i-1);
    // p结点之后插入元素e
    return insertNextNode(p,e);
}

// 删除 O(n)
bool listDelete1(LinkList &L,int i,int &e){
    if(i < 1){
        return false;
    }
    // 查找前驱结点
    LNode *p = getElem(L,i-1);
    // q指向被删除结点
    LNode *q = p->next;
    // 把q从链中断开
    p ->next = q->next;
    // 释放空间
    free(q);
    return true;
}

// 删除 O(1)
// !有坑,在删除最后一个结点时会报错
bool listDelete2(LNode *p){
    if (p == NULL){
        return false;
    }
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}

// 求链表长
int getLength(LinkList L){
    int len = 0;
    LNode *p = L;
    while(p -> next != NULL){
        p = p->next;
        len++;
    }
    return len;
}

// 尾插法建立
LinkList listTailInsert(LinkList &L){
    int x;
    // 初始化
    initList(L);
    // 定义头尾指针
    LNode *s = L;
    LNode *r = L;
    scanf("%d",&x);
    while(x != 9999){
        // 在r结点之后插入x
        s = (LNode *) malloc(sizeof(LNode));
        s -> data = x;
        r -> next = s;
        // 让r指针指向新的尾
        r = s;
        scanf("%d",&x);
    }
    r -> next = NULL;
    return L;
}

// 头插法建立
LinkList listHeadInsert(LinkList &L){
    LNode *s;
    int x;
    // 初始化L
    initList(L);
    scanf("%d",&x);
    while(x != 9999){
        // 把新结点插入到头部
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d",&x);
    }
    return L;
}

// 主函数测试
int main(){
    // 测试尾插法
    LinkList L1,L2;
    listTailInsert(L1);
    printList(L1);
    // 测试头插法
    listHeadInsert(L2);
    printList(L2);
    // 测试插入一个新结点
    listInsert(L1,1,100);
    listInsert(L2,3,200);
    printList(L1);
    printList(L2);
    // 测试删除一个结点
    int deletedNode1;
    listDelete1(L1,3,deletedNode1);
    LNode *deletedNode2 = getElem(L2,3);
    listDelete2(deletedNode2);
    printList(L1);
    printList(L2);
    // 测试查找结点
    printf("在L1中查找100，下一个位置的值为 -> %d",locateElem(L1,100)->next->data);
    return 0;
}

双向链表的实现

注意点

对于双向链表，与单链表不同的是多了一个前向指针，可以实现向前遍历这样的操作了。需要注意的是双向链表的判空条件以及插入时的临界条件。

代码

/*
 * @Description: 双向链表的实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-07 21:32:35
 */
#include <bits/stdc++.h>

// 定义双向链表结构
typedef struct DLinkNode
{
    int data;
    // 前向指针与后向指针
    DLinkNode *pre;
    DLinkNode *next;
} DLinkNode, *DLinkList;

// 初始化双链表
bool initList(DLinkList &DL)
{
    // 分配一个头结点
    DL = (DLinkNode *)malloc(sizeof(DLinkNode));
    // 内存已满
    if (DL == NULL)
    {
        return false;
    }
    // 把头结点指向空
    DL->pre = NULL;
    return true;
}

// 创建
DLinkList createDLinkList(DLinkList &DL)
{
    int x;
    initList(DL);
    DLinkNode *p;
    DLinkNode *s;
    p = DL;
    scanf("%d", &x);
    while (x != 9999)
    {
        s = (DLinkNode *)malloc(sizeof(DLinkNode));
        s->data = x;
        p->next = s;
        s->pre = p;
        p = s;
        scanf("%d", &x);
    }
    s->next = NULL;
    return DL;
}

// 打印
void printList(DLinkList DL)
{
    DLinkNode *p = DL->next;
    printf("双链表内的元素为：\n");
    while (p->next)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    // 最后一个元素虽指向NULL但仍有值，继续打印
    printf("%d ", p->data);
    printf("\n");
}

// 头部插入
void insertListHead(DLinkList &DL, int data)
{
    DLinkNode *pNode = (DLinkNode *)malloc(sizeof(DLinkNode));
    pNode->data = data;
    pNode->next = DL->next;
    pNode->pre = DL;
    if (pNode->next != NULL)
    {
        pNode->next->pre = pNode;
    }
    DL->next = pNode;
}

// 尾部插入
void insertListTail(DLinkList &DL, int data)
{
    DLinkNode *pNode = (DLinkNode *)malloc(sizeof(DLinkNode));
    pNode->data = data;
    DLinkNode *pCur = DL;
    while (pCur->next != NULL)
    {
        pCur = pCur->next;
    }
    pCur->next = pNode;
    pNode->pre = pCur;
    pNode->next = NULL;
}

// 获取链表长度
int getListLength(DLinkList DL)
{
    DLinkNode *p;
    int len = 0;
    p = DL;
    for (; p->next != NULL; p = p->next)
    {
        len++;
    }
    return len;
}

// 指定位置插入节点,前插
bool insertList(DLinkList &DL, int data, int index)
{
    DLinkNode *pCur = DL;
    int len = getListLength(DL);
    if (index > len)
    {
        return false;
    }
    else if (index == 0)
    {
        insertListHead(DL, data);
        return true;
    }
    else if (index == len)
    {
        insertListTail(DL, data);
        return true;
    }

    DLinkNode *pNode = (DLinkNode *)malloc(sizeof(DLinkNode));
    pNode->data = data;
    int i = 0;
    while (index--){
        pCur = pCur->next;
    }
    pNode->next = pCur->next;
    pCur->next = pNode;
    pNode->pre = pCur;
    pNode->next->pre = pNode;
    return true;
}

// 删除指定值
bool deleteListNode(DLinkList &DL,int key){
    DLinkNode *pPre = DL;
    DLinkNode *pCur = DL->next;
    while(pCur != NULL){
        if(pCur->data == key){
            if(pCur->next != NULL){
                pCur->next->pre = pCur->pre;
            }
            pCur->pre->next = pCur->next;
            pPre = pCur;
            pCur = pCur->next;
            free(pPre);
            return true;
        }else{
            pPre = pCur;
            pCur = pCur->next;
        }
    }
    return false;
}

// 主函数测试
int main(){
    DLinkList DL;
    // 创建
    createDLinkList(DL);
    printList(DL);
    // 从头插入一个值
    insertListHead(DL,5);
    printList(DL);
    // 从尾插入一个值
    insertListTail(DL,100);
    printList(DL);
    // 任意位置插入
    insertList(DL,1000,2);
    printList(DL);
    // 删除值为100的结点
    deleteListNode(DL,100);
    printList(DL);
}

带头结点的单循环链表的实现

注意点

这里实现的是带头结点的单循环链表，循环链表在理解了其本质后其实是很好写的。主要就是把最后一个元素的next指针指向了第一个元素。关于实现，需要注意循环链表的判空条件，以及插入时的操作。

代码

/*
 * @Description: 循环单链表的实现
 * @version: 1.0
 * @Author: Liuge
 * @Date: 2021-07-08 19:38:04
 */

#include<bits/stdc++.h>

// 定义循环单链表结构体
typedef struct CLNode{
    int data;
    CLNode *next;
}CLNode,* CLinklist;

// 初始化
bool initList(CLinklist &CL){
    CL = (CLNode *)malloc(sizeof(CLNode));
    if(CL == NULL){
        return false;
    }
    // 循环链表初始化头结点指向本身
    CL->next=CL;
    return true;
}

// 判空
bool isEmpty(CLinklist CL){
    // 指向本身即为空
    if(CL->next == CL){
        return true;
    }
    return false;
}

// 长度
int getLength(CLinklist CL){
    CLNode *p = CL->next->next;
    int len = 0;
    // p未到表头时
    while(p != CL->next){
        len++;
        p = p->next;
    }
    return len;
}

// 取元素
int getElem(CLinklist CL,int i,int *e){
    CLNode *p = CL->next;
    int j = 0;
    if(i < 1 || i > getLength(CL)){
        // 不合法，返回-1
        return -1;
    }
    while(j < i){
        j++;
        p = p->next;
    }
    *e = p->data;
    // 返回0代表成功
    return 0;
}

// 定位元素
int locateElem(CLinklist CL,int e){
    CLNode *p = CL->next->next;
    int j = 0;

    while(p != CL->next){
        j++;
        if(p->data == e){
            return j;
        }
        p = p->next;
    }
    return -1;
}

// 插入元素
bool listInsert(CLinklist &CL,int i,int e){
    CLNode *p = CL->next;
    CLNode *s;
    int j = 0;
    if(i < 1 || i > getLength(CL) + 1){
        return false;
    }
    while(j < i -1){
        j++;
        p = p->next;
    }
    s = (CLNode *)malloc(sizeof(CLNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    // 如果在表尾插入,则把新插入的元素当做头结点(第一个元素)
    if(p == CL){
        CL = s;
    }
    return true;
}

// 删除元素
bool listDelete(CLinklist &CL,int i,int &e){
    CLNode *p = CL->next;
    CLNode *q;
    int j = 0;
    if(i < 1 || i > getLength(CL)){
        return false;
    }
    while(j < i - 1){
        j++;
        p = p->next;
    }
    q = p->next;
    e = q->data;
    p->next = q->next;
    // 删除表尾元素，指针发生变化
    if(q == CL){
        CL = p;
    }
    free(q);
    return true;
}

// 打印
void printList(CLinklist CL)
{
    CLNode *p = CL->next->next;
    printf("循环链表内的元素为：\n");
    while (p != CL->next)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 主函数测试
int main(){
    CLinklist CL;
    initList(CL);
    printList(CL);
    // 插入几个元素
    listInsert(CL,1,100);
    listInsert(CL,2,2);
    listInsert(CL,3,3);
    listInsert(CL,4,4);
    listInsert(CL,5,5);
    printList(CL);
    // 插入到表尾试试
    listInsert(CL,5,1000);
    printList(CL);
    // 删除一个元素
    int deletedElem;
    listDelete(CL,3,deletedElem);
    printList(CL);
}

总结

这里还缺双向循环链表的实现，其实这种实现也并不是很难的方式，读者可以去自行实现。在线性表这一块大量使用了指针，一定要好好理解指针的概念才能更好地实现代码。