算法之链表篇

基础

概念及结构

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

链表的种类：

• 单链表：一个节点有一个指向或一个节点的指针
• 双链表：一个节点有两个指针分别指向前一个节点和后一个节点
• 循环链表：头结点与尾节点相连

代码定义：

struct ListNode{
    int val;
    ListNode* next;
    ListNode(int x): val(x), next(NULL){}
};

操作方法

插入新节点

• 在头节点、尾节点或中间的结点前或后插入一个新的节点
  删除节点
• 删除链表中的任意一个节点；可根据值也可根据位置
  获取节点
• 获取链表中的某一个节点 ；可根据值也可根据位置
  反转
• 一般是单链表的反转操作

代码演练

链表基本操作 力扣题目链接707

class MyLinkedList {

public:
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
    MyLinkedList() {
        Head = new LinkedNode(0);
        size = 0;
    }
    
    int get(int index) {

        if (index < 0 || index > size - 1)  return -1;
        LinkedNode* cur = Head -> next;

        while (index --)
        {
            cur = cur -> next;
        }
        return cur -> val;
    }
    
    void addAtHead(int val) {
        LinkedNode* a = new LinkedNode(val);
        a -> next = Head -> next;
        Head -> next = a;
        size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* a = new LinkedNode(val);
        LinkedNode * cur = Head;
        while (cur -> next) cur = cur -> next;
        cur -> next = a;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > size || index < 0) {
            return;
        }
        LinkedNode* a = new LinkedNode(val);
        LinkedNode * cur = Head;
        while (index--) cur = cur -> next;
        a -> next = cur -> next;
        cur -> next = a;
        size++;

    }
    
    void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        LinkedNode * cur = Head;
        while (index--) cur = cur -> next;
        LinkedNode * t =  cur -> next;
        cur -> next = cur -> next -> next;
        delete t;
        size--;

        
    }
    
private:
    int size;
    LinkedNode* Head;
};

反转 力扣题目链接206

ListNode* reverse(ListNode* pre,ListNode* cur)
    {
        if (!cur)
            return pre;
         ListNode* t = cur -> next;
         cur -> next = pre;
         return reverse(cur, t);
    }
    ListNode* reverseList(ListNode* head) {
    //     // 方法一 双指针法
    //     ListNode* cur = head;
    //     ListNode* pre = nullptr;
    //     ListNode* t;
    //     while (cur)
    //     {
    //         t = cur -> next;
    //         cur -> next = pre;
    //         pre = cur;
    //         cur = t;
    //     }
    //     return pre;
    // }

        // 方法二 递归方法
        return reverse(NULL, head);
    }
};

总结

相对于数组操作，链表更适合插入和删除操作，效率很高，时间复杂度为O(1)；而数组更适合查询操作；
关于对应头结点的情况都要单独处理，而使用虚拟头结点，可以解决这个问题