数据结构学习笔记（一）

一、绪论

程序 = 数据结构 + 算法

1.1 基础知识点

根据存储方式可将数据结构分为两类：

• 顺序存储结构 ---- 将数据存储到地址连续的存储单元中

• 链式存储结构 ---- 将数据存储在任意的存储单元中，可连续也可不连续

算法 ---- 是用来解决问题的方法

1.2 时间复杂度及空间复杂度

链接：一套图 搞懂“时间复杂度”-CSDN博客

二、线性表

线性表 ---- 零个/多个数据元素的有限序列

2.1 顺序存储结构

根据名称我们可知，即为用一段连续的存储单元依次进行存储线性表的数据元，如下图所示，存储器中每个存储单元都有自己的编号，即被称为地址。
对于线性表每个位置的存入和取出的时间都是相等的，即线性表的存取操作时间复杂度为：O(1)，插入删除操作因为需移动其他元素，则其时间复杂度为：O(n) 。

则其使用场景为：元素存取操作较多、增删操作较少的场景

2.2 链式存储结构

2.2.1 基础知识点

• 链表 ------- 一个/多个结点组成的数据结构
• 数据域 ---- 存储真实的数据元素
• 指针域 ---- 存储下一个结点的地址
• 头指针 ---- 将链表中第一个结点成为头指针，即为链表的第一个数据元素
• 头节点 ---- 为方便操作，则在链表的头指针前设置一个结点，称为头节点

2.2.2 单链表

单链表是一种链式存取的数据结构，其存放的地址为任意的，不必连续，链表中的数据以结点的形式表示，头结点内通常不存储信息，如下图所示：

a. 单链表结构体的定义

typedef struct ListNode {
    int data;               // 数据域
    struct ListNode* next;  // 指针域，指向下一个结点
} ListNode;

b. 初始化单链表

// 初始化单链表
ListNode* initList() {
    ListNode* head = NULL;  // 头结点
    head = (ListNode*)malloc(sizeof(ListNode));  // 分配内存空间
    if (head == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    head->next = NULL;  // 头结点的指针域设置为NULL，表示单链表为空
    return head;
}

在以上示例中，我们通过定义一个ListNode结构体来表示链表的节点，结构体包含一个data字段用于存储结点数据，以及一个next指针字段用于指向下一个结点。
在initList函数中，我们创建一个头节点，并将其next字段初始化为NULL，然后返回头节点的指针。
可在main函数中，我们调用initList函数来初始化链表，并输出链表头节点的地址。

int main() {
    // 初始化链表
    ListNode* list = initList();
    // 输出链表头节点地址
    printf("链表头节点地址：%p\n", list);

    return 0;
}

单链表需手动分配内存再将结点连接起来。

c. 单链表的头插法插入

头插法是指每一次插入数据都是在头结点后插入，例如插入的数据顺序为：1、2、3、4，则实际单链表中呈现的顺序为：4、3、2、1，如下图所示：

示例代码如下：

// 头插法插入节点
void insertAtHead(ListNode* head, int data) {
    // 创建新节点
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;  // 设置新节点的数据域
    newNode->next = NULL;  // 设置新节点的指针域为NULL

    // 将新节点插入到头结点之后
    newNode->next = head->next;
    head->next = newNode;
}

d. 单链表的尾插法插入

尾插法顾名思义则为从单链表的尾部插入新的结点，例如插入的数据顺序为：1、2、3、4，则实际单链表中呈现的顺序为：1、2、3、4。

示例代码如下：

void insertAtTail(ListNode* head, int data) {
    // 创建新节点
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;  // 设置新节点的数据域
    newNode->next = NULL;  // 设置新节点的指针域为NULL

    // 找到尾节点
    ListNode* tail = head;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    // 将新节点插入到尾节点之后
    tail->next = newNode;
}

e. 在单链表指定位置插入结点

// 在指定位置插入节点
void insertAtPosition(ListNode* head, int data, int position) {
    // 创建新节点
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;  // 设置新节点的数据域
    newNode->next = NULL;  // 设置新节点的指针域为NULL

    // 找到指定位置的前一个节点
    ListNode* prev = head;
    for (int i = 0; i < position - 1; i++) {
        prev = prev->next;
        if (prev == NULL) {
            printf("插入位置无效\n");
            return;
        }
    }

    // 将新节点插入到指定位置之后
    newNode->next = prev->next;
    prev->next = newNode;
}

f. 单链表的打印

// 输出单链表
void printList(ListNode* head) {
    ListNode* node = head->next;  // 头结点之后的第一个节点
    while(node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

f. 在单链表删除指定位置的结点

// 删除指定位置的节点
void deleteAtPosition(ListNode* head, int position) {
    // 找到指定位置的前一个节点
    ListNode* prev = head;
    for (int i = 0; i < position - 1; i++) {
        prev = prev->next;
        if (prev == NULL || prev->next == NULL) {
            printf("删除位置无效\n");
            return;
        }
    }
    
    // 删除指定位置的节点
    ListNode* nodeToDelete = prev->next;
    prev->next = nodeToDelete->next;
    free(nodeToDelete);
}

g. 单链表按位查找值

int getValueByPosition(ListNode* head, int pos) {
    ListNode* p = head; // 指向当前节点的指针
    int count = 0;  // 记录当前节点位置的计数器

    while (p != NULL && count < pos)
    {   
        p = p->next;
        count++;
    }   

    if (count == pos && p != NULL)
    {   
        return p->data;
    }   
    else
    {   
        return -1; // 未找到指定位置的节点，返回 -1
    }   
}

h. 单链表按值查找

// 查找指定元素的位置
int findPosition(ListNode* head, int data) {
    ListNode* node = head->next;
    int position = 0;
    while (node != NULL) {
        position++;
        if (node->data == data) {
            return position;
        }
        node = node->next;
    }
    return -1;
}

i. 单链表的删除

// 删除单链表
void deleteLinkedList(ListNode** head) {
    ListNode* current = *head;
    ListNode* temp = NULL;

    while (current != NULL) {
        temp = current;
        current = current->next;
        free(temp);
    }

    *head = NULL;
}

主函数为：

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

int main() {
    // 初始化单链表
    ListNode* head = initList();

    // 头插法插入节点
    insertAtHead(head, 1);
    insertAtHead(head, 2);
    insertAtHead(head, 3);

    // 尾插法插入节点
    insertAtTail(head, 4);
    insertAtTail(head, 5);
    insertAtTail(head, 6);

    // 输出单链表
    printList(head);

    // 在指定位置插入节点
    insertAtPosition(head, 7, 2);

    // 输出单链表
    printList(head);

    // 删除指定位置的节点
    deleteAtPosition(head, 4);

    // 输出单链表
    printList(head);

    // 查找指定元素的位置
    int position = findPosition(head, 5);
    if (position != -1) {
        printf("元素5的位置是：%d\n", position);
    } else {
        printf("找不到元素5\n");
    }

    //根据位置查找值
    int value = getValueByPosition(head, position);
    printf("第%d个位置的值为：%d\n", position, value);

    // 删除链表
    deleteLinkedList(&head);

    return 0;
}

最后打印结果为：

2.2.3 静态链表

2.2.4 循环链表

2.2.5 双链表