算法练习Day3

最新推荐文章于 2024-07-23 20:57:57 发布

可可西里333

最新推荐文章于 2024-07-23 20:57:57 发布

阅读量1.5k

点赞数 40

文章标签：算法

本文链接：https://blog.csdn.net/2302_80474306/article/details/136257012

版权

203.移除链表元素

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

我的代码：

/**
 * 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(); //在进行链表的增删操作的时候，
                                              //可以定义一个虚拟头结点，该结点指向头结点
                                              //这样对于头结点和非头结点的操作就可以统一了
        dummyhead -> next = head;
        ListNode* p = new ListNode();
        p = dummyhead;
        while(p -> next != nullptr) {         //进行判断与操作的总是p结点的下一个结点
                                              //按值查找并删除是一个连续的过程，要删到该链表            
                                              //没有这个值的结点了为止，所以用while
            if(p -> next -> val == val) {
                ListNode* temp = p -> next;   //使用temp指针暂存要删除的结点，
                                              //可以防止内存泄露
                p -> next = p -> next -> next;
                delete temp;
            }else{                            //这里使用else，防止了val结点连续出现而不能全 
                                              //删的情况
                p = p -> next;
            }
        }
        return dummyhead -> next;            //返回真正的头结点
    }
};

反思：第一次做的时候，没能正确释放要删除结点的内存，使用一个temp结点来暂存可以防止内存泄漏；也没有把p = p -> next;放入else语句里，导致val结点连续出现时不能全删；本题比较重要的一个思想是使用虚拟头结点“dummyhead”来统一头结点与非头结点的操作，还有一个是判断、操作都是队p -> next进行；相比于两三星期前自己写这道题，虽然都能过，但是今天新增了释放内存这一步，感觉这样做更科学。

707.设计链表

自己两三周前做题就做到这里，，，当时一直改一直过不了，借着今天的机会看看能不能改对吧

题目内容：你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

我的错误代码（还没过！！！）：

class MyLinkedList {
public:
        struct ListNode{
            int val;
            ListNode* next;
            ListNode(int x): val(x), next(nullptr) {}
            ListNode(): val(0), next(nullptr) {}
        };
        int size;
        ListNode* head;

    MyLinkedList() {
        this -> size = 0;
        head = new ListNode();
    }
    
    int get(int index) {
        ListNode* dummyhead = new ListNode();
        dummyhead -> next = head;
        ListNode* p = dummyhead;
        while((index--)&&(p != nullptr)) {
            p = p -> next;
        }
        if(p -> next == nullptr) return -1;
        return p -> next -> val;
    }
    
    void addAtHead(int val) {
        ListNode* new_head = new ListNode(val);
        new_head -> next = head;
        head = new_head;
        size++;
    }
    
    void addAtTail(int val) {
        if(head == nullptr) {
            ListNode* new_node = new ListNode(val);
            head = new_node;
            return;
        }
        
        ListNode* p = head;
        while(p -> next != nullptr) {
            p = p -> next;
        }
        ListNode* new_tail = new ListNode(val);
        p -> next = new_tail;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        ListNode* dummyhead = new ListNode();
        dummyhead -> next = head;
        ListNode* p = new ListNode();
        p = dummyhead;
        ListNode* new_node = new ListNode(val);
        while((index--)&&(p -> next != nullptr)) {
            p = p -> next;
        }
        if(p -> next != nullptr) {
            new_node -> next = p -> next;
            p -> next = new_node;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if((index >= size)||(index < 0) ) return;
        ListNode* dummyhead = new ListNode();
        dummyhead -> next = head;
        ListNode* p = dummyhead;

        while(index--) {
            p = p -> next;
        }

        if(p -> next != nullptr) {
            ListNode* temp = p -> next;
            p -> next = p -> next -> next;
            delete temp;
            temp = nullptr;
            size--;
        }
    }
};

/**
 * 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->3的链表在最后一个函数输出0（？）对照了下卡哥标准答案的最后一个函数，感觉就dummyhead的定义有出入，代码随想录标准答案里dummyhead在MyLinkedList里就定义了，我这个则是定义在功能函数内部了，也不知道为啥前几个功能函数也这样搞但是没问题。。。

206.反转链表

最开始尝试写递归来着，想顺便练练自己的递归，后来不出意料的没过。。。一chat根本不给我讲递归，就是用了双指针，一个prev一个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* reverseList(ListNode* head) {
        if(head == nullptr || head -> next == nullptr) return head;
        ListNode* prev = nullptr;
        ListNode* cur = head;
        while(cur != nullptr) {
            ListNode* temp = cur -> next;
            cur -> next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
};

反思：函数开头对于空结点和只有一个结点的链表作了判断并及时返回，感觉我合法条件判断意识总是不够强；然后就是定义了两个指针“追及”，用了temp结点暂存当前结点的下一个结点以便cur指针能正确移动，也是我新学到的东西。

递归法：

我的代码：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head -> next == nullptr) return head;
        return reverse(nullptr, head);
    }

    ListNode* reverse(ListNode* prev, ListNode* cur) 
    {
        if(cur == nullptr) {
            return prev;
        }
        ListNode* temp = cur -> next;
        cur -> next = prev;
        return reverse(cur, temp);
    }
};

反思：后来看了卡尔老师的视频补了递归法，思路就是按照双指针法的思路来，把改变prev, cur的指向反映到了递归调用里，使得代码更加简洁；自己一开始写的最后两行代码是

reverse( cur, temp );

return prev;

没有注意到reverse函数调用最终是有返回值的，返回值就是反转后的链表的头结点，哪怕写个

ListNode* result = reverse( cur, temp );

return result;

都是能过的。

感觉递归对我来说还是晦涩难懂了点，害。

可可西里333

关注

40
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
算法练习Day3

对照了下卡哥标准答案的最后一个函数，感觉就dummyhead的定义有出入，代码随想录标准答案里dummyhead在MyLinkedList里就定义了，我这个则是定义在功能函数内部了，也不知道为啥前几个功能函数也这样搞但是没问题。然后就是定义了两个指针“追及”，用了temp结点暂存当前结点的下一个结点以便cur指针能正确移动，也是我新学到的东西。一chat根本不给我讲递归，就是用了双指针，一个prev一个cur，感觉这个方法还蛮不错的就是改变指针指向的时候有点绕了。以指示链表中的上一个节点。
复制链接

扫一扫