代码随想录 day3链表

day3 第二章链表

链表基础

• 链表：

  • 是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域（存储数据元素信息的域），一个是指针域（存放指向下一个结点的指针），最后一个结点的指针域指向null（空指针）。
    

  • 链表中第一个结点的存储位置为头指针
    

  • 链表的入口节点称为链表的头结点（head）。
    

结点由存放数据元素的数据域与存放后继结点地址的指针域组成。p是指向第i个元素的指针，则该结点ai的数据域用p->data（一个数据元素）表示，指针域用p->next（一个指针）表示。p->next指向第i+1个元素，即指向ai+1的指针，如果p->data等于ai，p->next->data等于ai+1。

• 链表的类型：

  • 单链表：指针域只能指向节点的下一个节点；
  • 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
    双链表即可向前查询也可向后查询。
    
  • 循环链表：链表首尾相连；可以用来解决约瑟夫问题；
    

• 链表的存储方式：
  链表是通过指针域的指针链接在内存中各个节点。
  所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

• 链表节点的定义：

struct ListNode {
    int val; // 节点上存储的元素
    ListNode *next; // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数
};

• 通过自己定义构造函数初始化节点：

ListNode* head = new ListNode(5);

• 使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

203.移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足Node.val == val 的节点，并返回新的头节点 。

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

• 直接使用原来的链表进行删除操作。

class solution {
public:
   ListNode* removeElements(ListNode* head, int val) {
     //删除头节点
     while (head != NULL && head->val == val) {
       ListNode* temp = head;
       head = head->next;
       delete temp;
     }
      //删除非头节点
      ListNode* cur = head;
      while (cur != NULL && cur->next !=NULL) {
         if (cur->next->val == val) {
            ListNode* temp = cur->next;
            cur->next = cur->next->next;
            delete temp;
         }
         else {
            cur = cur->next;
         }
      }
      return head;
   }
}

• 设置一个虚拟头结点再进行删除操作。

class solution {
public:
   ListNode* removeElements(ListNode* head, int val) {
      ListNode* dummyHead = new ListNode(0); //设置一个虚拟头结点
      dummyHead->next = head;
      ListNode* cur=dummyHead;
      while (cur->next !=NULL) {
         if (cur->next->val == val) {
            ListNode* temp = cur->next;
            cur->next = cur->next->next;
            delete temp;
         }
         else {
            cur = cur->next;
         }
      }
      head = dummyHead->next;
      delete dummyHead;
      return head;
   }
}

707.设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}
    };
    MyLinkedList() {
       _dummyHead = new LinkedNode(0);
       _size=0;
    }
    
    int get(int index) {
        if (index < (_size-1) || index<0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){
            cur=cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        
        if (index > _size) return;
        if (index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur=cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= _size || index <0){
            return;
        }
        LinkedNode* cur = _dummyHead;
        while (index--) {
            cur=cur->next;
        }
        LinkedNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        _size--;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

206.反转链表

• 使用双指针法
  

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
         ListNode* temp;
         ListNode* cur = head;
         ListNode* pre = nullptr;
         while(cur) {
             temp = cur->next;
             cur->next=pre;
             pre = cur;
             cur = temp;
         }
         return pre;
    }
};