4.3 设计链表

题目

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

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3

提示：

所有val值都在 [1, 1000] 之内。
操作次数将在 [1, 1000] 之内。
请不要使用内置的 LinkedList 库

来源：力扣（LeetCode）
链接: link.

思路

1. 创建节点结构体 LinkedNode
2. MyLinkedList ( ) 初始化链表 : 创建头节点,令链表长度为 0
3. int get( int index ) 返回下标为 index 节点的值 :
   if ( ) : 处理 index 不存在的情况 ;
   定义 pNew ;
   while ( index - - ) : 遍历到 pNew 指向尾节点截止;
   返值 ;
4. void addAtHead ( int val ) 在首节点前插入新节点 :
   创建新节点 newNode ;
   插入操作(顺序不能换) :
   ( 1 ) 对 newNode (新节点与后节点连接): newNode->next = head->next;
   ( 2 ) 对 newNode 的前节点 head (新节点与前节点连接): head->next = newNode;
   长度增一 ;
5. void addAtTail ( int val ) 在尾节点后追加新节点 :
   创建新节点 newNode ;
   定义 pNew ( pNew 从头结点计起 );
   while ( pNew->next != nullptr ) : 遍历到 pNew 指向尾节点截止 ;
   新节点与前节点连接 ;
   长度增一 ;
6. void addAtIndex ( int index, int val ) 在下标为 index 节点之前插入新节点 :
   if ( ) : 处理 index 不存在的情况 ;
   创建新节点 newNode ;
   定义 pNew ( pNew 从头结点计起 ) ;
   while ( index - - ) : 遍历到 pNew 指向下标为 index 节点的前节点截止 ;
   插入操作(顺序不能换) :
   ( 1 ) 对 newNode (新节点与后节点连接): newNode->next = pNew->next;
   ( 2 ) 对 newNode 的前节点 head (新节点与前节点连接): pNew->next = newNode;
   长度增一 ;
7. void deleteAtIndex ( int index ) 删除下标为 index 节点 :
   if ( ) : 处理 index 不存在的情况 ;
   定义 pNew ( pNew 从头结点计起 ) ;
   while ( index- - ) : 遍历到 pNew 指向下标为 index 节点的前节点截止 ;
   删除操作 :
   ( 1 ) 定义 tmp ( 指向下标为 index 节点 ) ;
   ( 2 ) 让下标为 index 节点的前节点与后节点连接 ;
   ( 3 ) 删除下标为 index 节点 ;
   长度减一 ;
8. 声明头节点 head,链表长度 len 为 private (在力扣上提交需在尾部定义,否则会报错) ;

具体代码实现(C++)

class MyLinkedList {
public:
	//1 创建节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val) : val(val), next(nullptr) {}
    };
    //2 初始化链表
    MyLinkedList() {
        head = new LinkedNode(0); //头节点
        len = 0; //链表长度
    }
    //3 返回下标为 index 节点的值
    int get(int index) {
        if (index > (len - 1) || index < 0) { //处理 index 不存在的情况
            return -1;
        }
        LinkedNode* pNew = head->next; //pNew 从首结点计起
        while (index --) {      //遍历到 pNew 指向下标为 index 节点截止
            pNew = pNew->next;
        }
        return pNew->val;
    }
    //4 在首节点前插入新节点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val); //创建新节点
        newNode->next = head->next; //新节点与后节点连接
        head->next = newNode; //新节点与前节点连接
        len++; //长度增一
    }
    //5 在尾节点后追加新节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val); //创建新节点
        LinkedNode* pNew = head; // pNew 从头结点计起
        while (pNew->next != nullptr) { //遍历到 pNew 指向尾节点截止
            pNew = pNew->next;
        }
        pNew->next = newNode; //新节点与前节点连接
        len++; //长度增一
    }
    //6 在下标为 index 节点之前插入新节点 
    void addAtIndex(int index, int val) {
        if (index > len) {  //处理 index 不存在的情况
            return;
        }
        if (index < 0) {
            addAtHead(val);
        }
        LinkedNode* newNode = new LinkedNode(val); //创建新节点
        LinkedNode* pNew = head; //pNew 从头结点计起
        while (index--) {        //遍历到 pNew 指向下标为 index 节点的前节点截止
            pNew = pNew->next;
        }
        newNode->next = pNew->next; //新节点与后节点连接
        pNew->next = newNode; //新节点与前节点连接
        len++; //长度增一
    }
    //7 删除下标为 index 节点
    void deleteAtIndex(int index) {
        if (index >= len || index < 0) { //处理 index 不存在的情况 ;
            return;
        }
        LinkedNode* pNew = head; //pNew 从头结点计起
        while (index--) {       //遍历到 pNew 指向下标为 index 节点的前节点截止
            pNew = pNew->next;
        }
        LinkedNode* tmp = pNew->next; //tmp 指向下标为 index 节点
        pNew->next = pNew->next->next; //让下标为 index 节点的前节点与后节点连接 
        delete tmp; //删除下标为 index 节点
        len--;  //长度减一     
    } 
    //8
    private:
        LinkedNode* head;
        int len;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

模型（知识点）

1.创建节点结构体

struct LinkedNode {
	int val;
    LinkedNode* next;
    LinkedNode(int val) : val(val), next(nullptr) {}
};

2.获得目标节点

( 1 ) 指定下标 index 的遍历

//使 pNew 指向下标为 index 节点的前节点
LinkedNode* pNew = head; //pNew 从头结点计起
while (index--) {        //遍历到 pNew 指向下标为 index 节点的前节点截止
	pNew = pNew->next;
}
  
//使 pNew 指向下标为 index 节点      
LinkedNode* pNew = head->next; //pNew 从首结点计起
while (index --) {      //遍历到 pNew 指向下标为 index 节点截止
	pNew = pNew->next;
}   

说明 : 获得 while ( ) 遍历次数的关键是明确其初始值和截止值( 0 ), 遍历次数 = | 截止值 - 初始值 | = | 初始值 | ( 截止值为 0 )

( 2 ) 到尾节点的遍历

LinkedNode* pNew = head; // pNew 从头结点计起
while (pNew->next != nullptr) { //遍历到 pNew 指向尾节点截止
	pNew = pNew->next;
}

3.链表插入操作(顺序不能换) :
pNew 指向下标为 index 节点的前节点
( 1 ) 对 newNode (新节点与后节点连接): newNode->next = pNew->next;
( 2 ) 对 newNode 的前节点 head (新节点与前节点连接): pNew->next = newNode;

链表删除操作 :
pNew 指向下标为 index 节点的前节点
( 1 ) 定义 tmp ( 指向下标为 index 节点 ) : LinkedNode* tmp = pNew->next;
( 2 ) 让下标为 index 节点的前节点与后节点连接 : pNew->next = pNew->next->next;
( 3 ) 删除下标为 index 节点 : delete tmp;

总结 : 无论是插入还是删除操作,关键都是找到目标节点的前节点,再进行节点的连接 ;