顺序表与链表数据结构实现与操作-优快云博客

一、顺序表

1. 静态表

1.1 引入库文件，添加宏定义

#include <stdio.h>
#define MaxSize 50        // 定义顺序表最大长度

1.2 创建结构体

typedef struct {
    int data[MaxSize];
    int length;
} SqList;

1.3 初始化

// 初始化顺序表
void InitList(SqList &L, int list[], int n) {
    for (int i = 0; i < MaxSize; i++) {
        if (i >= n) {
            L.data[i] = 0;        // 设置其他元素的默认值，防止”脏数据“
        }
        L.data[i] = list[i];         // 将list放入顺序表
    }
    L.length = n;           // 顺序表的当前长度为list的长度
    printf("初始化成功！\n");
}

1.4 输出所有元素

// 输出顺序表所有元素的值
void Printf(SqList &L) {
    printf("当前元素为：\n");
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

1.5 插入元素

// 在 i 的位置插入元素 data[i-1] = e
bool ListInsert(SqList &L, int i, int e) {
    if (i < 1 || i > L.length + 1) {             // 判断插入的位置i的值是否有效
        printf("插入失败！");
        return false;
    }
    if (L.length >= MaxSize) {                  // 若空间已满则不能插入
        printf("插入失败！");
        return false;
    }
    for (int j = L.length; j >= i; j--) {          // 将第i个元素及之后的元素后移
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;
    L.length++;
    printf("插入成功！");
    return true;
}

1.6 删除元素

// 删除元素
bool ListDelete(SqList &L, int i, int &e) {
    if (i < 1 || i > L.length) {
        return false;
    }
    e = L.data[i - 1];
    for (int j = i; j < L.length; j++) {            // 将第i个位置的元素前移
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    printf("删除成功！");
    return true;
}

1.7 查找元素（按值查找）

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

1.8 测试

1.8.1 主方法

int main() {
    SqList L;
    int list[5] = {3, 6, 1, 8, 5}, i;
    InitList(L, list, 5);
    Printf(L);
    fflush(stdout);
    puts("请输入要执行的操作的号码(1.查找元素 2.插入元素 3.删除元素):");
    fflush(stdout);
    scanf("%d", &i);
    Operation(L, i);
    return 0;
}

1.8.2 快捷操作

// 增删查操作
void Operation(SqList L, int i) {
    // 查找
    if (i == 1) {
        int e;
        puts("请输入要查找的元素：");
        fflush(stdout);
        scanf("%d", &e);
        int search = LocateElem(L, e);
        if (search != 0) {
            printf("查找成功！%d为第%d个元素。", e, search);
        } else {
            printf("没有%d这个元素。", e);
        }
    }
        // 插入元素
    else if (i == 2) {
        int loc, num;
        puts("请输入要插入的位置：");
        fflush(stdout);
        scanf("%d", &loc);
        puts("请输入要插入的值：");
        fflush(stdout);
        scanf("%d", &num);
        if (ListInsert(L, loc, num)) {
            printf("插入元素为：%d\n", num);
        }
        Printf(L);
    }
        // 删除元素
    else if (i == 3) {
        int loc, e;
        puts("请输入要删除的元素的位置：");
        fflush(stdout);
        scanf("%d", &loc);
        if (ListDelete(L, loc, e)) {
            printf("删除的元素为%d", e);
        }
    } else {
        printf("输入不合法！");
    }
}

1.8.3 测试结果

2. 动态表

2.1 引入库文件，添加宏定义

#include <stdio.h>
#include <stdlib.h>             // malloc和free函数库

#define InitSize 100

2.2 定义结构体

typedef struct {
    int *data;
    int MaxSize, length;
} SqList;

2.3 初始化

// 初始化顺序表
void InitList(SqList &L) {
    L.data = (int *) malloc(InitSize * sizeof(int));
    L.length = 0;
    L.MaxSize = InitSize;
}

2.4 扩展存储空间

// 扩展顺序表存储空间
void IncreaseSize(SqList &L, int len) {
    int *p = L.data;
    L.data = (int *) malloc((L.MaxSize + len) * sizeof(int));
    for (int i = 0; i < L.length; i++) {
        L.data[i] = p[i];                     // 将数据元素复制到新区域
    }
    L.MaxSize = L.MaxSize + len;
    free(p);                   // 释放原来的内存空间
}

2.5 测试

2.5.1 主方法

int main() {
    SqList L;
    InitList(L);
    printf("当前存储空间大小：%d\n", L.MaxSize);
    IncreaseSize(L,50);
    printf("扩展后存储空间大小：%d\n", L.MaxSize);
}

2.5.2 测试结果

二、链表

1. 单链表

1.1 定义

typedef struct LNode {
    int data;
    struct LNode *next;
} LNode, *LinkList;

1.2 建立单链表

1.2.1 头插法

// 头插法插入元素，逆向建立单链表
LinkList List_headerInsert(LinkList &L) {
    LNode *s;
    int x;
    L = (LinkList) malloc(sizeof(LNode));    // 创建头结点
    L->next = NULL;         // 初始化为空链表,防止脏数据
    scanf("%d", &x);
    while (x != 9999) {
        s = (LNode *) malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;            // 将新结点插入表中，L为头指针
        scanf("%d", &x);
    }
    printf("输入结束！");
    return L;
}

1.2.2 尾插法

// 尾插法建立
LinkList List_TailInsert(LinkList &L) {
    int x;
    L = (LinkList) malloc(sizeof(LNode));
    LNode *s, *r = L;           // r为表尾指针
    scanf("%d", &x);
    while (x != 9999) {
        s = (LNode *) malloc(sizeof(LNode));
        s->data = x;
        r->next = s;        // 将链表连起来
        r = s;     // r指向新的表尾结点
        scanf("%d",&x);
    }
    printf("输入结束！");
    r->next = NULL;
    return L;
}

1.3 查找

1.3.1 按位查找

// 按位查找结点
LNode *GetElem(LinkList L, int i) {
    int j = 1;           // 不算头结点，从第一个结点开始找
    LNode *p = L->next;    // 指针指向第一个结点
    if (i == 0)
        return L;       // i == 0 返回头结点
    if (i < 1)
        return NULL;     // 输入不合法
    while (p != NULL && j < i) {        // 从第1个结点开始找，一直找到第i个
        p = p->next;
        j++;
    }
    return p;
}

1.3.2 按值查找

// 按值查找：成功则返回位序，失败返回0
int LocateElem(LinkList L, int e) {
    LNode *p = L->next;
    int count = 1;
    while (p != NULL) {
        if (p->data == e)
            return count;
        p = p->next;
        count++;
    }
    return 0;
}

1.4 插入

1.4.1 在第i个后面插

// 插入结点（按位序插入）
bool ListInsert(LinkList &L, int i, int e) {
    if (i < 1)         // 输入的ii不合法
        return false;
    LNode *p = GetElem(L, i - 1);
    if (p == NULL)      // i的值超出范围
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

1.4.2 在第i个后面插前面插

在 s->data = e; 后面添加这行代码。（交换数据后又变成前插）

p->data = s->data;

1.5 删除

1.5.1 按位序删除

// 删除结点(按位序删除)
bool ListDelete(LinkList &L, int i, int &e) {
    LNode *p = GetElem(L, i - 1);
    LNode *q = p->next;           // q 指向被删除接结点
    if (p->next == NULL)
        return false;
    e = q->data;           // 把被删除的结点带回
    p->next = q->next;
    free(q);
}

1.5.2 删除指定结点

// 删除指定结点*p
bool DeleteNode(LNode *p) {
    if (p == NULL)
        return false;
    LNode *q = p->next;
    p->data = q->data;       // 和后继结点交换数据域
    p->next = q->next;         // 将*q结点从链中断开
    free(q);
    return true;
}

1.6 其他

1.6.1 判空

// 判空
bool IsEmpty(LinkList L) {
    if (L->next == NULL)
        return true;
    return false;
}

1.6.2 遍历整个链表

// 遍历
void PrintList(LinkList L) {
    LNode *p = L->next;
    int i = 0;
    while (i <= 6) {
        printf("%d ", p->data);
        p = p->next;
        i++;
    }
}

1.6.3 单链表长度

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

2. 双链表

1. 定义

typedef struct DNode {
    int data;
    struct DNode *prior, *next;
} DNode, *DLinkList;

2.初始化

// 初始化
bool InitDLinkList(DLinkList &L) {
    L = (DLinkList) malloc(sizeof(DNode));
    if (L == NULL)
        return false;         // 内存不足，分配空间失败
    L->prior = NULL;
    L->next = NULL;
    return true;
}// 初始化
bool InitDLinkList(DLinkList &L) {
    L = (DLinkList) malloc(sizeof(DNode));
    if (L == NULL)
        return false;         // 内存不足，分配空间失败
    L->prior = NULL;
    L->next = NULL;
    return true;
}

3. 插入

/*
 * 插入
 * 参数：p: 在p后面插入一个元素
 *      s: 插入的元素的指针为s
 * */
bool InsetNextDNode(DNode *p, DNode *s) {
    if (p == NULL || s == NULL)                  // 输入非法参数
        return false;
    s->next = p->next;
    if (p->next != NULL)          // 确保p的后面还有结点
        p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}

4. 删除

/*删除
 * 参数：
 *      p: 要删除的结点的前一个结点的指针*/
bool DeleteNextDNode(DNode *p) {
    if (p == NULL)       // 输入不合法
        return false;
    DNode *q = p->next;
    if (q == NULL)           // p没有后继结点
        return false;
    p->next = q->next;
    if (q->next != NULL)          // q不是最后一个结点
        q->next->prior = p;
    free(q);
    return true;
}

5. 遍历

/*
 * 遍历(后向)
 * */
void PrintDLinkLst(DLinkList L) {
    DNode *p = L->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
}