JAVA面试题分享五百五十五：揭秘数组和链表的不同

之乎者也·

于 2024-02-20 18:10:56 发布

阅读量1k

点赞数 19

分类专栏： JAVA 面试题分享文章标签： java 链表面试

本文链接：https://blog.csdn.net/qq_45038038/article/details/136042385

版权

JAVA 面试题分享专栏收录该内容

567 篇文章 98 订阅

订阅专栏

一、简介

数据结构是组织和存储数据的方式，直接影响着程序性能、内存利用和资源管理等关键方面。

数据结构提供了各种方法来组织和存储数据，包括数组、链表、栈、队列、树和图等。
许多算法的设计和优化都与数据结构密不可分。
合适的数据结构能够更有效地利用内存资源，减少资源浪费并提高程序性能。
在软件工程和系统设计中，数据结构是构建复杂系统和解决实际问题的基础。

数组和链表是两种常见的数据结构，本文旨在深入探讨数组和链表的区别，揭秘它们的异同点。

二、数组的特点和特性

数组是一种数据结构，用于存储相同类型的元素，这些元素通常被存储在连续的内存位置上。

定义：数组是具有相同数据类型的元素集合，这些元素按照一定的顺序在内存中连续存储。数组可以包含任意数量的元素，但一旦创建后其大小通常是固定的。

三、链表的特点和特性

链表是一种常见的线性数据结构，由一系列的节点组成，每个节点由两部分组成：数据域和指针域。数据域用于存储节点的数据，而指针域用于指向下一个节点，从而形成一系列的连接。

基本概念：

节点：链表中的基本单元，包含数据和指向下一个节点的指针。
头节点：链表的第一个节点，通常用来标识链表的起始位置。
尾节点：链表的最后一个节点，其指针通常指向空值（null），表示链表的结束。
单向链表：每个节点只包含一个指向下一个节点的指针。
双向链表：每个节点包含两个指针，分别指向前一个节点和后一个节点，使得可以双向遍历链表。

链表相对于数组的优点在于，可以更高效地支持插入和删除操作，因为在链表中插入或删除节点只需要修改相邻节点的指针，而不需要移动大量的元素。链表的缺点是访问时需要从头节点开始顺序查找，无法像数组那样通过索引直接访问元素。

链表的每个节点至少由两部分组成：数据域和指针域。指针域指向下一个节点（对于单向链表）或者同时指向前一个和后一个节点（对于双向链表）。

单向链表的存储结构特点：

每个节点包含数据和指向下一个节点的指针。
节点在内存中不必须是连续存储的，每个节点可以存储在任意内存地址上。
插入和删除节点的操作比较灵活，只需要修改节点指针即可，不需要移动大量元素。
无法直接访问链表中的任一元素，需要从头节点开始按顺序查找，访问效率较低。

双向链表的存储结构特点：

每个节点包含数据和分别指向前一个节点和后一个节点的指针。
可以双向遍历链表，即可以从头节点到尾节点或者从尾节点到头节点进行遍历。
插入和删除节点的操作相对于单向链表更方便，可以在节点前后两个方向进行操作。
每个节点需要额外存储一个指向前一个节点的指针，因此占用的空间较大。

在链表中插入一个新节点，可以分为以下几种情况：

在链表头部插入节点：新节点成为链表的新头节点，将新节点的指针指向原来的头节点，更新链表的头指针。
在链表尾部插入节点：遍历链表，直到找到尾节点，将新节点的指针指向尾节点，并将新节点设置为新尾节点。
在链表中间插入节点：找到要插入位置的前一个节点，将前一个节点的指针指向新节点，新节点的指针指向原来位置的下一个节点。

从链表中删除一个节点，可以分为以下几种情况：

删除头节点：将头指针指向头节点的下一个节点，并释放原来的头节点内存。
删除尾节点：遍历链表，找到倒数第二个节点，将倒数第二个节点的指针设置为null，并释放原尾节点的内存。
删除中间节点：找到要删除位置的前一个节点，将前一个节点的指针指向要删除节点的下一个节点，并释放要删除节点的内存。

通过遍历链表来查找特定节点：

遍历查找：从头节点开始，依次遍历链表的每个节点，直到找到要查找的节点或者遍历到链表尾部。
特定查找：根据实际需求，可以采用不同的方式进行特定的查找，例如查找第一个符合条件的节点。

四、数组和链表的对比

数组是连续存储，链表是离散存储；数组插入和删除操作需移动元素，而链表插入和删除操作只需要简单修改指针；数组支持随机访问，而链表只能遍历查找。

数组的连续存储：

数组中的元素在内存中是连续存储的，即相邻的元素在内存中的地址是相邻的。
由于元素的连续存储特性，可以通过元素的下标直接访问和操作元素。
在插入和删除元素时需要移动元素的位置，如果在中间插入或删除元素，需要移动后续元素的位置。

链表的离散存储：

链表中的节点在内存中是离散存储的，即每个节点可以存储在任意的内存地址上。
由于节点的离散存储特性，不能通过下标直接访问元素，只能通过指针进行遍历访问。
在插入和删除节点时，只需要调整节点的指针指向，不需要移动大量的元素，因此插入和删除的时间复杂度通常较低。

插入操作：

在数组中插入元素需要移动插入位置后面的所有元素，以腾出空间来插入新元素。最好情况下，插入到末尾的时间复杂度为 O(1)，最坏情况下需要移动整个数组，时间复杂度为 O(n)。
在链表中插入元素只需要修改节点的指针，将新节点插入到合适的位置。无需移动其他节点，时间复杂度为 O(1)。

删除操作：

在数组中删除元素同样需要移动删除位置后面的所有元素，填补删除位置，最好情况下为 O(1)，最坏情况下需要移动整个数组，时间复杂度为 O(n)。
在链表中删除元素只需要修改节点的指针，将要删除节点的前一个节点指向要删除节点的下一个节点。同样，时间复杂度为 O(1)。

在查找操作的效率方面，数组的随机访问时间复杂度为 O(1)，链表的遍历查找时间复杂度为 O(n)。

五、数组和链表的代码实现

数组的实现：

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    // 访问数组中的元素
    cout << arr[0] << endl;  // 输出：1

    // 修改数组中的元素
    arr[2] = 10;

    // 打印整个数组
    for (int i = 0; i < 5; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;  // 输出：1 2 10 4 5

    return 0;
}

链表的实现：

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int data) {
        this->data = data;
        this->next = nullptr;
    }
};

class LinkedList {
public:
    Node* head;

    LinkedList() {
        head = nullptr;
    }

    // 在链表末尾添加一个节点
    void append(int data) {
        Node* new_node = new Node(data);
        if (!head) {
            head = new_node;
            return;
        }
        Node* last_node = head;
        while (last_node->next) {
            last_node = last_node->next;
        }
        last_node->next = new_node;
    }

    // 打印链表中的所有节点数据
    void print_list() {
        Node* current_node = head;
        while (current_node) {
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
    }
};

int main() {
    LinkedList linked_list;

    // 在链表末尾添加节点
    linked_list.append(3);
    linked_list.append(5);
    linked_list.append(7);

    // 打印链表数据
    linked_list.print_list();  // 输出：3 5 7

    return 0;
}