【LeetCode刷题日记】数组和链表性质总结

一、数据结构的存储方式

数据结构的存储方式只有两种：数组（顺序存储）和链表（链式存储）。

这句话怎么理解，不是还有散列表、栈、队列、堆、树、图等等各种数据结构吗？

我们分析问题，一定要有递归的思想，自顶向下，从抽象到具体。你上来就列出这么多，那些都属于「上层建筑」，而数组和链表才是「结构基础」。因为那些多样化的数据结构，究其源头，都是在链表或者数组上的特殊操作，API 不同而已。

比如说「队列」、「栈」这两种数据结构既可以使用链表也可以使用数组实现。用数组实现，就要处理扩容缩容的问题；用链表实现，没有这个问题，但需要更多的内存空间存储节点指针。

「图」的两种表示方法，邻接表就是链表，邻接矩阵就是二维数组。邻接矩阵判断连通性迅速，并可以进行矩阵运算解决一些问题，但是如果图比较稀疏的话很耗费空间。邻接表比较节省空间，但是很多操作的效率上肯定比不过邻接矩阵。

「散列表」就是通过散列函数把键映射到一个大数组里。而且对于解决散列冲突的方法，拉链法需要链表特性，操作简单，但需要额外的空间存储指针；线性探查法就需要数组特性，以便连续寻址，不需要指针的存储空间，但操作稍微复杂些。

「树」，用数组实现就是「堆」，因为「堆」是一个完全二叉树，用数组存储不需要节点指针，操作也比较简单；用链表实现就是很常见的那种「树」，因为不一定是完全二叉树，所以不适合用数组存储。为此，在这种链表「树」结构之上，又衍生出各种巧妙的设计，比如二叉搜索树、AVL 树、红黑树、区间树、B 树等等，以应对不同的问题。

了解 Redis 数据库的朋友可能也知道，Redis 提供列表、字符串、集合等等几种常用数据结构，但是对于每种数据结构，底层的存储方式都至少有两种，以便于根据存储数据的实际情况使用合适的存储方式。

综上，数据结构种类很多，甚至你也可以发明自己的数据结构，但是底层存储无非数组或者链表，二者的优缺点如下：

数组由于是紧凑连续存储,可以随机访问，通过索引快速找到对应元素，而且相对节约存储空间。但正因为连续存储，内存空间必须一次性分配够，所以说数组如果要扩容，需要重新分配一块更大的空间，再把数据全部复制过去，时间复杂度 O(N)；而且你如果想在数组中间进行插入和删除，每次必须搬移后面的所有数据以保持连续，时间复杂度 O(N)。

链表因为元素不连续，而是靠指针指向下一个元素的位置，所以不存在数组的扩容问题；如果知道某一元素的前驱和后驱，操作指针即可删除该元素或者插入新元素，时间复杂度 O(1)。但是正因为存储空间不连续，你无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

二、数据结构的基本操作

对于任何数据结构，其基本操作无非遍历 + 访问，再具体一点就是：增删查改。

数据结构种类很多，但它们存在的目的都是在不同的应用场景，尽可能高效地增删查改。话说这不就是数据结构的使命么？

如何遍历 + 访问？我们仍然从最高层来看，各种数据结构的遍历 + 访问无非两种形式：线性的和非线性的。

线性就是 for/while 迭代为代表，非线性就是递归为代表。再具体一步，无非以下几种框架：

数组遍历框架，典型的线性迭代结构：

void traverse(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        // 迭代访问 arr[i]
    }
}

链表遍历框架，兼具迭代和递归结构：

/* 基本的单链表节点 */
class ListNode {
    int val;
    ListNode next;
}

void traverse(ListNode head) {
    for (ListNode p = head; p != null; p = p.next) {
        // 迭代访问 p.val
    }
}

void traverse(ListNode head) {
    // 递归访问 head.val
    traverse(head.next);
}

二叉树遍历框架，典型的非线性递归遍历结构：

/* 基本的二叉树节点 */
class TreeNode {
    int val;
    TreeNode left, right;
}

void traverse(TreeNode root) {
    traverse(root.left);
    traverse(root.right);
}

你看二叉树的递归遍历方式和链表的递归遍历方式，相似不？再看看二叉树结构和单链表结构，相似不？如果再多几条叉，N 叉树你会不会遍历？

二叉树框架可以扩展为 N 叉树的遍历框架：

/* 基本的 N 叉树节点 */
class TreeNode {
    int val;
    TreeNode[] children;
}

void traverse(TreeNode root) {
    for (TreeNode child : root.children)
        traverse(child);
}

N 叉树的遍历又可以扩展为图的遍历，因为图就是好几 N 叉棵树的结合体。你说图是可能出现环的？这个很好办，用个布尔数组 visited 做标记就行了，这里就不写代码了。

所谓框架，就是套路。不管增删查改，这些代码都是永远无法脱离的结构，你可以把这个结构作为大纲，根据具体问题在框架上添加代码就行了，下面会具体举例。

三、C语言数组和链表的基本操作实例

1.数组的增删改查

数组增删改查的基础是对数组的遍历和访问，因为数组在内存中是连续存储，因此可以通过索引进行随机访问，需要遍历数组元素的话我们只需要使用 for 循环遍历即可。

测试代码如下

#include "stdio.h"

int main() {
    //数组容量为6，已使用5
    int arr[6] = {1, 2, 3, 4, 5};
    int temp;

    //增删改查的基础是遍历和访问

    //数组的随机访问
    printf("数组的第一个元素%d", arr[0]);
    printf("数组的第五个元素%d", arr[4]);

    //因为可以随机访问，我们很容易对数组进行修改和查询
    //因为数组的内存空间都是分配好的，因此对数组的增加和删除是比较复杂的
    //如果要增加数组的值，我们需要将增加元素位置后面的元素全部向后移一位（数组空间足够的话）
    //如果要删除元素，则需要将删除元素位置处后面的元素全部向前移一位

    //数组的修改,修改第一个元素值
    arr[0] = 99;

    //数组的查询，查询第一个元素值
    temp = arr[0];

    //数组的增加，比如我们要在第二个元素后增加一个元素值999
    for (size_t i = 4; i > 1; i++) {
        arr[i + 1] = arr[i];
    }
    arr[2] = 999;

    //数组的删除，比如我们删除第三个元素
    for (size_t i = 2; i < 5; i++) {
        arr[i] = arr[i + 1];
    }

}

2.链表的增删改查

链表因为在内存中不是连续存储的，因此我们不能对链表进行随机读取，我们一般是通过递归的方式来访问链表节点。使用递归的方式可以很方便的遍历所有节点。

当我们需要访问第几个节点时，我们就需要设置一些标志来让我们在遍历链表时停在该节点前，然后就可以进行增加节点、删除节点、修改节点内容等操作。

下面是所有的测试代码

#include "stdio.h"
#include "stdlib.h"

//链表节点定义
typedef struct test {
    int data;
    struct test* next;
}TEST;

int main() {
    //因为链表在内存中不是连续存储的

    //构建一个空链表(带头结点)
    TEST*  mylist = (TEST*)malloc(sizeof(TEST));

    //增加一个元素（链表节点）
    TEST*  mynode = (TEST*)malloc(sizeof(TEST));
    mynode->data = 1;
    mynode->next = NULL;
    //将该节点加入到链表中
    mylist->next = mynode;
    printf("%d", mylist->next->data);

    //继续增加一个元素（节点）到链表中
    mynode = (TEST*)malloc(sizeof(TEST));
    mynode->data = 2;
    mynode->next =NULL;
    //将该节点加入到链表中
    mynode->next = mylist->next;
    mylist->next = mynode;
    printf("%d", mylist->next->data);

    //继续增加一个元素（节点）到链表中
    mynode = (TEST*)malloc(sizeof(TEST));
    mynode->data = 3;
    mynode->next =NULL;
    //将该节点加入到链表中
    mynode->next = mylist->next;
    mylist->next = mynode;
    printf("%d", mylist->next->data);

    //查询和修改都是要借助对链表的遍历访问（链表不能进行随机访问）
    //先使用两种方法遍历一下链表
    for(TEST* p = mylist; p->next != NULL; p = p->next) {
        printf("\n%d", p->next->data);
    }

    TEST* pp = mylist;
    while(pp->next) {
        printf("\n%d", pp->next->data);
        pp = pp->next;
    }

    //查询链表的第二个元素
    int temp;
    TEST* ppp = mylist;
    for(size_t i = 0; ppp->next != NULL && i < 2 ; ppp = ppp->next, i++) {
    }
    temp = ppp->data;

    //修改第二个元素值
    ppp->data = 99;
    for(TEST* p = mylist; p->next != NULL; p = p->next) {
        printf("\n%d", p->next->data);
    }

    //在第二个节点前插入一个节点
    mynode = (TEST*)malloc(sizeof(TEST));
    mynode->data = 999;
    mynode->next = NULL;

    TEST* pppp = mylist;
    int i = 1;
    while(i) {
        pppp = pppp->next;
        i--;
    }

    mynode->next = pppp->next;
    pppp->next = mynode;
    for(TEST* p = mylist; p->next != NULL; p = p->next) {
        printf("\n%d", p->next->data);
    }

    //删除第二个节点
    //找到需要删除节点前的节点
    TEST* ppppp = mylist;
     i = 1;
    while(i) {
        ppppp = ppppp->next;
        i--;
    }
    ppppp->next = ppppp->next->next;
    for(TEST* p = mylist; p->next != NULL; p = p->next) {
        printf("\n%d", p->next->data);
    }

}

四、总结

• 上面总结了数组和链表的所有基本性质和操作，这是后面我们对所有数据结构进行操作的基础。
• 对数据结构进行的操作可以概括为遍历和访问，通过遍历和访问，我们可以对数据结构进行增删改查，而不同的数据结构（这里指数组和链表）会带来不同的性质和基础操作。
• 最后，一定要多写代码，看懂和写出来中间差了十万八千里，因此要多敲代码，这样才会基础扎实，心中有底。