203.移除链表元素 707.设计链表 206.反转链表

壹柯

已于 2023-07-14 22:13:49 修改

阅读量690

点赞数

文章标签：链表数据结构 leetcode

于 2023-01-14 19:01:08 首次发布

本文链接：https://blog.csdn.net/weixin_44640001/article/details/128688030

版权

203.移除链表元素 707.设计链表 206.反转链表

链表和数组对比

相比于数组，链表存在如下优势：

不要求连续的储存空间，且链表的长短随时可变，空间利用率高
因为链表的线性特征是利用指针实现的，所以链表的插入和删除都非常方便，只需要修改节点的指针即可，不需要像数组一样需要挪动元素的位置。

相比数组，链表也存在如下劣势：

数据访问效率低，需要移动指针找到想要的数据，不像数组可以直接通过索引获取数据。
实现更复杂，且需要多余的内存用于存放指针

数组的适用场景：数据量固定，频繁查询，较少增删；
链表的适用场景：数据量不固定，频繁增删，较少固定。

C++定义链表结构的方式

// 单链表
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;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

C++移除节点的话还要手动释放内存

203.移除链表元素

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

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

方法一-递归


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    if(head == NULL)
    {
    return head;
    }
    head->next = removeElements(head->next,val);     //用于接受下一个的值
    return head->val==val? head->next:head;
    }
};

思路：
判断head节点是否等于Val,如果等于Val那么返回head，如果不等于那么就获取head->next的值，并且这样不断递归比较。

方法二-使用原来的链表进行移除节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //在原链表上删除
        //1.删除头节点
        while(head!=NULL && head->val==val) 
        //若是每个节点都一样则需要都删除所以用while
        {
            ListNode * temp = head;
            head= head->next;
            delete temp;
        }

        //2.删除非头节点
        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;
    }
};

思考：
使用原来的链表进行删除操作，移除头节点和移除其他节点的操作不同，因为头节点前面没有其他节点。
所以移除头节点要将头节点head移向后一位head->next，并且最后将指向原头节点的temp指针删除；
移除非头节点时，若current->next的值为val 的话，那么移除current->next就是将curren指针直接指向current->next->next(跳过current->next)

方法三-使用一个虚拟头节点再进行删除操作


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    ListNode * dummyHead = new ListNode(0);     //设置一个虚拟头节点
    dummyHead->next = head;         //将dummyHead的结点指向head
    ListNode * current = dummyHead;
    while(current-> next != NULL)
    {
        if(current->next->val ==val)
        {
            ListNode * temp = current->next;
            current->next = current->next->next;
            delete temp;
        }
        else
        {
        current = current->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 个节点。

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

方法一-使用虚拟头结点

class MyLinkedList {
public:

    //定义链表节点结构体
    struct LinkedNode
    {
        int val;
        LinkedNode * next;
        LinkedNode(int val):val(val),next(NULL){}
    };

    //初始化链表
    MyLinkedList() {

        m_dummyhead=new LinkedNode(0);  //定义一个虚拟头结点
        m_size=0;
    }
    
    //获取第index个结点数值，index是从0开始即头结点开始
    int get(int index) {
        if(index>(m_size-1) || index<0)  return -1;  //非法index直接返回-1

        LinkedNode * current = m_dummyhead->next;       //从头结点开始，非虚拟头结点
        while(index--)                                  //当index为0时跳出循环,current不在往后指
        {
            current= current->next;
        }
        return current->val;

    }
    //在链表最前面插入节点，新插入的节点为链表头结点
    void addAtHead(int val) {
        LinkedNode * newNode = new LinkedNode(val);
        newNode->next = m_dummyhead->next;  //先将newNode的结点指向m_dummyhead->next,后将m_dummyhead和newNode链接
        m_dummyhead-> next = newNode;
        m_size++;
    }
    
    //在链表最后添加一个节点
    void addAtTail(int val) {
        LinkedNode * newNode = new LinkedNode(val);
        LinkedNode *current = m_dummyhead;
        while(current->next != NULL)
        {
            current = current->next;
        }
        current->next = newNode;
        m_size++;
    }
    
    //在链表指定index位置插入一个新节点
    void addAtIndex(int index, int val) {
        if(index>m_size) return ;                            //判断非法性
        LinkedNode*newNode = new LinkedNode(val);
        LinkedNode*current = m_dummyhead;
        while(index--)
        {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
        m_size++;
    }
    

    //删除第index个节点
    void deleteAtIndex(int index) {
        if(index>=m_size || index<0) return ;
        LinkedNode *current = m_dummyhead;
        while(index--)
        {
            current = current->next;
        }
        LinkedNode *temp = current->next;
        current->next = current->next->next;
        delete temp;            //不要忘记释放内存
        m_size--; //删除后size减小
    }


//打印链表
void printLinkedList()
{
    LinkedNode *current = m_dummyhead;
    while(current->next!=NULL)
    {
        cout << current->next->val;
        current= current->next;
    }
    cout << endl;
}



    private:
    int m_size;
    LinkedNode * m_dummyhead;
};

/**
 * 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);
 */

思考：

链表的定义前面的题直接给出，这道题自己定义有点不熟悉还需加强；
获取，插入，删除的过程其实都是利用虚节点来找到需要删除或插入的的节点位置来进行
需要注意的是在进行插入时，先将newNode的结点指向m_dummyhead->next,后将m_dummyhead和newNode链接，如果顺序相反的话，在将m_dummyhead->next指向newNode后，无法找到原本m_dummyhead->next的节点，也就无法将newNode与之建立节点。

206.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

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

方法一-双指针法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode * cur = head;
        ListNode * pre = NULL;  //最初让cur指针指向head,pre指向head前面的NULL
        while(cur)  //当cur不断向后移动，移动到末端后面的NULL时，停止循环
        {
            ListNode * temp = cur->next; //保存cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre;   //反转链表后，指向从 从左到右改为从右到左

            //更新pre 和cur 指针
            pre = cur;    //先更新pre是因为  若先改变cur则之后的pre指向就不是原来的cur了
            cur = temp;
        }
        return pre;  //此时pre为头结点，cur为NULL
    }
};

思考：

假设链表为 1→2→3→∅，我们想要把它改成3∅←1←2←3
双指针法其实就是将pre和cur一起作为一个整体向后移动（同时将cur的指向反转，指向pre)
要注意其中的细节，改变指向时注意顺序，如未先保存cur的下一个节点，那么在cur->next 指向pre后，无法再将cur向右移动。

方法二-递归

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode() : val(0), next(nullptr) {}
*     ListNode(int x) : val(x), next(nullptr) {}
*     ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
   ListNode* reverse(ListNode* pre, ListNode* cur)
   {
       if(cur==NULL) return pre;
       ListNode*temp = cur->next;
       cur->next = pre; 
       return reverse(cur,temp);        //和双指针中相同，pre=cur
                                                        //cur=temp
      
   }


   ListNode* reverseList(ListNode* head) {
       return reverse(NULL,head);
   }
};