lesson 1 顺序表和链表

1、线性表
2、顺序表

2.1 顺序表的概念
（1）静态顺序表
（2）动态顺序表
3、链表
3.1 链表的概念
3.2 链表的分类：
（1）单向或者双向
（2）带头或者不带头
（3）循环或者非循环
（4）常用的几种链表（重点）
3.3 链表的实现
（1）无头单向链表
（2）带头双向循环链表
4、线性表和顺序表的区别
5、知识补充

1、线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使
用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，
线性表在物理上存储时，通常以数组和链式结构的形式存储。

2、顺序表：

2.1 顺序表的概念：
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
储。在数组上完成数据的增删查改。
顺序表一般分为两种：
1、静态顺序表：使用定常数组存储元素。
2、动态顺序表：使用动态开辟的数组存储。
静态顺序表和动态顺序表的本质区别在于：静态顺序表存储的元素个数确定，而动态顺序表存储的元素个数不定。

3、链表

3.1 链表的概念
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。

3.2 链表的分类
（1）单向或者双向：

（2）带头或者不带头：

（3）循环或者非循环

（4）常用的几种链表（重点）：

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
   构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
   是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
   来很多优势，实现反而简单了，后面我们代码实现了就知道了。
   3.3 链表的实现：
   链表的核心组成：插入、删除（尾插），本文为了简化教学内容，方便读者理解，只是实现了链表最核心的部分。
   （1）无头单向链表

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

struct Node* createNode(int data) （创建哨兵位）
{
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->next = NULL;
    return node;
}

void insertNode(struct Node** head, int data) {
    struct Node* node = createNode(data);
    if (*head == NULL) {
        *head = node;
    }
    else {
        struct Node* curr = *head;
        while (curr->next != NULL) {
            curr = curr->next;
        }
        curr->next = node;
    }
}

void deleteNode(struct Node** head, int data) {
    if (*head == NULL) {
        return;
    }
    if ((*head)->data == data) {
        struct Node* temp = *head;
        *head = (*head)->next;
        free(temp);
    }
    else {
        struct Node* curr = *head;
        while (curr->next != NULL && curr->next->data != data) {
            curr = curr->next;
        }
        if (curr->next != NULL) {
            struct Node* temp = curr->next;
            curr->next = curr->next->next;
            free(temp);
        }
    }
}

void printList(struct Node* head) {
    struct Node* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;
    insertNode(&head, 1);
    insertNode(&head, 2);
    insertNode(&head, 3);
    printList(head);
    deleteNode(&head, 2);
    printList(head);
    return 0;
}

（2）带头双向循环链表

```c
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}ListNode;
// （哨兵位）
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
// 动态申请一个结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));
	if (NewNode == NULL)
	{
		printf("分配内存失败\n");
		exit(-1);
	}
	NewNode->prev = NewNode->next = NULL;
	NewNode->data = x;
	return NewNode;
}
// 打印
void Listprint(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
// 尾插
void ListPushBack(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* NewNode = BuyListNode(x);
	ListNode* tail = plist->prev;
	tail->next = NewNode;
	NewNode->prev = tail;
	plist->prev = NewNode;
	NewNode->next = plist;
}
// 删除pos位置的结点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* PosPrev = pos->prev;
	ListNode* PosNext = pos->next;
	PosPrev->next = PosNext;
	PosNext->prev = PosPrev;
	free(pos);
	pos = NULL;
}

int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	Listprint(plist);
}

带头结点和不带头结点的区别：有没有在头节点前添加一个指向头节点的哨兵位（哨兵位不存储值）
双向和单向链表的区别：结点中有没有指针prev保存上一个结点的地址

4、顺序表和链表的区别

5、知识补充

1、引用链表的主要目的是为了提高空间利用率，减少不必要的空间浪费
2、带头链表可以快速找到链表头节点（建议实现链表时添加哨兵位）
3、链表的插入和删除本质上就是调整结点中prev、next指针的指向
4、链表一般是在堆上创建，删除链表时，不要忘记free（），否则会产生内存泄漏！！！
5、在使用结构体指针时，一定要想一想该指针有没有可能为nullptr
6、链表的实现分为两部分：哨兵位+链表结点（头节点和哨兵位不是同一个，头节点是存储有效数据的第一个链表结点，哨兵位是辅助找头的结点）