算法训练营Day3

#链表 #移除链表元素 #设计链表 #翻转链表

开源学习资料

Feeling and experiences:

链表理论基础:

算法训练营Day3_第1张图片

以上就是一个简单的单链表,每个节点有两个域,指针域与数据域。

每个节点的next指针指向下一个节点的地址。

当然,链表还有其他的类型,例如双链表,循环链表等。

卡哥在这里就写的很详细了——>链表理论基础

我就从题中来体会链表的细节以及用法。

移除链表元素:力扣题目链接
 

 该题目就是数据结构中链表一章的基本删除操作,那么就关键在于怎么找到这个要删除的节点?

找到之后改怎么处理它?

在数据结构的基础学习中,我们知道要想在链表中找到要删除的节点,就要找到指向这个节点的节点,也就要从头依次遍历(而在数组中,则是随机存取的,想找到一个元素,就很简单),这也是链表的一个特性。

以下是该题的思路与代码:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
    //思路:删除目标节点,那么肯定要先找到这个节点,当它满足条件,删除,再将指向删除节点的指针指向删除节点所指向的节点
    //那么首先提出特殊情况,当链表为空,则直接返回
    if(head == null){
        return head;
    }
    //在循环之前检查头节点是否要删除
    while(head !=null && head.val == val){
        head = head.next;
        //可以理解为当头姐节点的值已经等于val则删除它,让下一个当头节点
    }
     //循环遍历找要删除节点
     ListNode cur = head;
     while(cur != null&&cur.next!=null){
         //只要cur 和 cur所指向的节点不为空
         if(cur.next.val == val){
             //跳过这个要删除的节点,改变指针指向
             cur.next = cur.next.next;
         }
         else{
             cur = cur.next;
         }
     }
     return head;
    }
}

其实大体的思路很简答,一就是先找到这个要删除的节点,然后我们跳过它,改变原本指向它的那个节点的指针,让该指针去指向删除节点所指向的节点。

以下这个图可以帮助理解:

算法训练营Day3_第2张图片

目前也还在上数据结构,不妨用c语言再写一遍,当作复习了。

先记录一下第一次错误的提交:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
    if(head == NULL){
        return head;
    }
    if(head !=NULL && head->val == val){
        struct ListNode *p = head;
        head = head->next;
        free(p);
    }

   struct ListNode *node = head;
    while(node != NULL && node->next != NULL){
        if(node->next->val == val){
            struct ListNode *p = node->next;
            node->next = node->next->next;
            free(p);
        }
        else{
            node = node->next;
        }
       
    }
     return head;
}

其中存在有指针悬挂,内存对齐的错误.......

果然复习一下还是好的,指针确实容易出错。

Because:

如果不是自己new出来的对象不建议去delete,因为这个节点不是我们自己 new 的,就不清楚它的生命周期,力扣后台还会拿它怎么用之类的,free掉后还可能出现访问已释放内存的问题!

更改了错误:

struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* temp;
    // 当头结点存在并且头结点的值等于val时
    while(head && head->val == val) {
        temp = head;
        // 将新的头结点设置为head->next并删除原来的头结点
        head = head->next;
        free(temp);
    }

    struct ListNode *cur = head;
    // 当cur存在并且cur->next存在时
    // 此解法需要判断cur存在因为cur指向head。若head本身为NULL或者原链表中元素都为val的话,cur也会为NULL
    while(cur && (temp = cur->next)) {
        // 若cur->next的值等于val
        if(temp->val == val) {
            // 将cur->next设置为cur->next->next并删除cur->next
            cur->next = temp->next;
            free(temp);
        }
        // 若cur->next不等于val,则将cur后移一位
        else
            cur = cur->next;
    }

    // 返回头结点
    return head;
}

对于指针的写法,我认为更好理解。比如cur->next = temp->next; 我的理解是前面的的cur->next 就形象与一个箭头,而后面的temp->next则表示cur的下一个节点,这样连起来理解的话,就是cur伸出来一个箭头,而这个伸出来的箭头就是指向了temp的下一个节点。

设计链表:力扣题目链接
 

基本的链表设置

加深对指针的使用




typedef struct MyLinkedList{
    int val;
    struct MyLinkedList *next;
    int size;
} MyLinkedList;


MyLinkedList* myLinkedListCreate() {
    //初始化链表
    MyLinkedList* head = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    head->next = NULL;
    return head;
}

int myLinkedListGet(MyLinkedList* obj, int index) {
   MyLinkedList *cur = obj->next;
    for (int i = 0; cur != NULL; i++){
        if (i == index){
            return cur->val;
        }
        else{
            cur = cur->next;
        }
    }
    return -1;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    
     MyLinkedList *newNode = (MyLinkedList *)malloc(sizeof (MyLinkedList));
     newNode->val = val;
     newNode->next = obj->next;
     obj->next = newNode;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
     MyLinkedList *cur = obj;
     while(cur->next != NULL){
        cur = cur->next;
    }
    MyLinkedList *ntail = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    ntail->val = val;
    ntail->next = NULL;
    cur->next = ntail;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
      if (index == 0){
        myLinkedListAddAtHead(obj, val);
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL; i++){
        if (i == index){
            MyLinkedList* newnode = (MyLinkedList *)malloc(sizeof (MyLinkedList));
            newnode->val = val;
            newnode->next = cur->next;
            cur->next = newnode;
            return;
        }
        else{
            cur = cur->next;
        }
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
      if (index == 0){
        MyLinkedList *tmp = obj->next;
        if (tmp != NULL){
            obj->next = tmp->next;
            free(tmp);     
        }
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL && cur->next != NULL; i++){
        if (i == index){
            MyLinkedList *tmp = cur->next;
            if (tmp != NULL) {
                cur->next = tmp->next;
                free(tmp);
            }
            return;
        }
        else{
            cur = cur->next;
        }
    }
}

void myLinkedListFree(MyLinkedList* obj) {
     while(obj != NULL){
        MyLinkedList *tmp = obj;
        obj = obj->next;
        free(tmp);
    }
}

/**
 * Your MyLinkedList struct will be instantiated and called as such:
 * MyLinkedList* obj = myLinkedListCreate();
 * int param_1 = myLinkedListGet(obj, index);
 
 * myLinkedListAddAtHead(obj, val);
 
 * myLinkedListAddAtTail(obj, val);
 
 * myLinkedListAddAtIndex(obj, index, val);
 
 * myLinkedListDeleteAtIndex(obj, index);
 
 * myLinkedListFree(obj);
*/

后面还需要多多复习数据结构!

翻转链表:力扣题目链接

力扣上的示意图:

算法训练营Day3_第3张图片

最容易想到的当然是头尾值依次交换,那么就可以用双指针。

一个指针指向头节点,一个指针指向null(为什么不指向最后一个,也就是上图中的5?

因为要去指向最后一个节点的话,就要依次遍历,才能找到它了。(而且也达不到翻转的目的

画了一个草图利于理解:

算法训练营Day3_第4张图片

代码思路如下:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *cur =head;
    struct ListNode *pre = NULL;
    while(cur != NULL){
        //由于节点没有引用其前一个节点,因此必须事先存储其前一个节点。
        struct ListNode *temp = cur->next;
        cur->next = pre;
        //这里注意:要先移动pre再移动cur
        //如果先移动cur的话,pre移动过来就重合了
          pre = cur;
          cur = temp;
    }
    return pre;
}

精髓和关键就在于:pre与cur指针,类似于一个在前一个在后,你追我赶,而temp相当于一个临时变量,防止进行完第一步,cur与pre这两个指针就找不到位置移动了。

有了temp,cur就可以移动到temp的位置。

还有一个关键是pre和cur的移动顺序,一定是pre先移动!

意思就是cur要等着pre,等pre到了它才移动,不然cur跑太快了,pre就要一次跳两格。(一个形象化理解,可以根据图来理解)

今天再熟悉回顾一下链表的基本抽象操作,再试一下递归解答翻转链表!

“林花谢了春红,太匆匆。

无奈朝来寒雨晚来风。

胭脂泪,留人醉,几时重。

自是人生长恨水长东。

林花谢了春红,凄凄惨惨,往事东流.....”

Fighting!

你可能感兴趣的:(java,算法,leetcode,链表,c语言)