移除链表元素|设计链表|反转链表|链表常见操作

题目

移除链表元素

设计链表

反转链表

重点

链表基础知识应用

一，移除链表元素

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

示例 1：

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

输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1

输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7

输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内

1 <= Node.val <= 50

0 <= val <= 50

删除单链表元素时，由每个结点只能得知下一个结点的位置，因此在找到val所在结点的同时，要知道上一个结点位置，代码实现如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
   //这里的头结点有数据，设置新头指针来使用
        struct ListNode *a=(struct ListNode*)malloc(sizeof(struct ListNode));
        a->next=head;
        struct ListNode *p=a;
        while(p->next!=NULL)
        {
            if(p->next->val==val)
            {
                struct ListNode*temp=p->next;
                p->next=temp->next;
               // free(temp);
            }else{
                p=p->next;
            }
        }
      
   
    return a->next;
}

二，设计链表，链表的常见操作

我在做时总是忘记判断该结点的下一个结点是否为空

学到的小技巧 在删除第n个节点时，可以在遍历的时候设定i=1开始，如此在i==n时，此时指针p为第n个结点之前的结点便能快捷删除

注意这道题的第0个有意义！

题目：

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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

提示：

0 <= index, val <= 1000

请不要使用内置的 LinkedList 库。

get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

代码：

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


MyLinkedList* myLinkedListCreate() {//创造头指针
    MyLinkedList *p=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p->next=NULL;
    return p;
}

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

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

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

}

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


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


void myLinkedListFree(MyLinkedList* obj) {
    while(obj!=NULL)//头指针的释放
    {
        MyLinkedList *tp=(MyLinkedList*)malloc(sizeof(MyLinkedList));
        tp=obj;
        obj=obj->next;
        free(tp);
        
    }
}

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

三，反转链表，双指针及递归思想应用

我最开始想要用数组来保存结点的值，然后再从头遍历更新结点的值，但是不对，恳请大佬指点

题目：

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

示例 1：

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

输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]

输出：[2,1]

示例 3：

输入：head = []

输出：[]

提示：

链表中节点的数目范围是 [0, 5000]

-5000 <= Node.val <= 5000

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
        int a[10000];
        int i;
        struct ListNode*p=head->next;
        if(p!=NULL)
        {
            for( i=0;p!=NULL;i++)
            {
                a[i]=p->val;
                p=p->next;
            }
        }
        p=head->next;
        if(p!=NULL)
        {
            for(i;i>=0;i--)
            {
                p->val=a[i];
                p=p->next;
            }
        }
        return head;
}

然后就是双指针解法和递归

主要再加深一下递归思想

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

//双指针

// struct ListNode* reverseList(struct ListNode* head){
//         struct ListNode *t;
//        struct ListNode *a=NULL;
//         while(head)
//         {
//             t=head->next;//保存后一结点

//            head->next=a;//翻转
//            //更新head和a;
//            a=head;
//            head=t;
//         }
//         return a;
// }
//递归
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverse(struct ListNode*pre,struct ListNode*cu)
{
    //递归结束出口
    if(!cu)
    return pre;
    //单层递归逻辑
    struct ListNode *t=cu->next;
    cu->next=pre;//翻转
    //调用自身 
    return reverse(cu,t);
}

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