数据结构之数组和链表

最新推荐文章于 2023-10-02 20:41:16 发布

原创最新推荐文章于 2023-10-02 20:41:16 发布 · 540 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #数组 #链表 #区别 #单链表

数据结构和算法专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了数组和链表这两种数据结构，包括它们的定义、特点和优缺点。数组提供随机访问但插入删除操作较慢，而链表在插入删除上优势明显但无法随机访问。此外，文章还探讨了单链表的插入操作、链表的逆置和合并，以及链表环的检测等主题。强调根据实际需求选择合适的数据结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组

1 是顺序存储的相同数据类型的数据结构，在内存空间上地址也是连续的，所以在声明数组的时候就要确定长度

声明数组

静态创建数组 
int array[100];//定义一个大小100的数组，没有初始化
int array[2]= {1,2};//定义长度为2的数组，并初始化
int array[20]= {1,2};//定义长度为20的数组，并初始化前两个
new动态创建:使用new分配一个数组，返回指向第一个元素的指针
int* array = new int[100]; delete []array;//分配长度为100的数组并删除
int* array = new int[100]（1,2）; delete []array;//分配长度为100的数组并初始化前两个元素，再删除
也可用malloc：
int a[100] = malloc(sizeof(int) * 100);
字符串数组  char b[] = “abd”;//定义大小为4的字符数组，因为字符串结尾以‘\0’结束
字符数组  char b[] = {'a','b'};//定义大小为2的字符数组

2 数组可以通过下标访问元素，速度很快，但是同样插入或者删除元素就很困难，需要移动大量的元素

3 数组存在下标越界问题，下标的范围应该大于等于0，小于数组的大小

链表

1 物理存储单元上不连续，非顺序的存储结构

2 数据的逻辑顺序是通过指针链接次序实现的，每个节点包括数据域和指针域。空间开销大

3 长度不固定，可以任意的增加删除元素，但是不能做到随机访问

数组缺点需要预先知道数据大小，链表缺点不能像数组一样随机读取，增加结点指针域，空间开销大，优点方便插入跟删除任意位置结点

数组和链表有以下几点不同：

存储形式：数组是一块连续的空间，声明时就要确定长度。链表是一块可不连续的动态空间，长度可变，每个结点要保存相邻结点指针。
数据查找：数组的线性查找速度快，查找操作直接使用偏移地址。链表需要按顺序检索结点，效率低。
数据插入或删除。链表可以快速插入和删除结点，而数组则可能需要大量数据移动
越界问题：链表不存在越界问题，数组有越界问题。

说明：一定要根据实际需求进行选择。数组便于查询(定位访问)，链表便于插入删除。数组节省空间但是长度固定，链表虽然变长但是占了更多的存储空间。

struct ListNode
{
	int val;//数据域
	ListNode *next;//指针域，指向下一个节点的指针
	ListNode(int x) : val(x), next(NULL) {}//初始化当前节点值为x, 指针为空(这一行是构造函数)
};

数组和链表的应用场景（待补充，又看到这篇文章的可以一起补充啊，互相交流）

单链表

//头插法：每个新节点都插入到头结点后面，第一个插进去的是尾节点，所以打印出来是倒序
newNode->data = x;
newNode->next = headNode->next;
headNode->next = newNode;
//尾插法：每个新节点都插入到这个链表的后面,所以多一个始终指向表尾的指针
ListNode *rear;
rear = headNode;//一开始头结点是表尾
newNode->data = x;
rear->next = newNode;
rear = newNOde;//rear始终指向表尾
所有节点插入后，循环之后，rear->next = NULL;

插入节点

链表不要断，先让新节点的next指向要插入的那个节点，然后让那个节点的前驱节点的next指向新节点

p->next = cur->next;//p是新节点，cur是要插入位置的前驱节点
cur->next = p;

双链表

每个节点都有两个指针，分别指向直接前驱和直接后继，相比单链表更方便找到直接前驱节点和后继节点

循环链表(待补充)

单链表逆置，反转链表

循环算法,迭代，思路就是就地箭头转过来完整代码参见单链表逆序

ListNode* reverseList(ListNode* head) {
        if (head == NULL) return head;//注意一定要考虑指针是否为空，不然就是思路不周祥
        ListNode* pre = NULL;
        ListNode* cur = head;
        while (cur) {
            ListNode* p = cur->next;//cur跟p依次后移
            cur->next = pre;//箭头转过来，类似交换两数的
            pre = cur;
            cur = p;
        }
	        return pre;}

递归

ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) return head;
        ListNode* p = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return p;

链表合并

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        ListNode *dummy = new ListNode(0);
        ListNode *head = dummy;
        
        while(l1 && l2){
            if(l1 ->val < l2 ->val){//升序，那个数字小，就指向哪个
                head->next = l1;
                l1 = l1->next;
            }
            else{
                head ->next = l2;
                l2 =l2->next;
            }
            head = head->next;
        }
        head ->next = l1 ? l1 : l2;
        return dummy->next;}