力扣刷题第十一天--链表篇

前言

感冒发烧休息了四天。心心念念的博客也断更了，题当然没写。现在看，放弃确实是件容易的事，坚持很难。过了这么久怎么才写十篇文章啊，断更四天，竟然一眨眼就过去了。学习状态还没有恢复，计划也被打乱。无奈，抓紧恢复，把进度补回来吧！

内容

一、删除链表的倒数第N个结点

19.删除链表的倒数第N个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

链表数组变换

把链表添加到数组，然后删掉倒数第n个元素，再把新数组变成链表  0ms 2.14MB

func removeNthFromEnd(head *ListNode, n int) *ListNode {
      arr:=[]int{}
      for ;head!=nil;head=head.Next{
          arr=append(arr,head.Val)
      }
      length:=len(arr)
      index:=length-n
      arr=append(arr[:index],arr[index+1:]...)


      dummy := &ListNode{Next: nil}  
    prev := dummy  
    for _, val := range arr {  
        node := &ListNode{Val: val}  
        prev.Next = node  
        prev = node  
    }  
    return dummy.Next
}

栈 

栈的思想 建一个空列表 找到要删除的节点的前一个节点 由于stack列表的最后一个元素是dummy（值为0），所以倒数第n个节点在列表中的索引是len(stack)-1-n  //0ms 2.11MB  

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    stack:=[]*ListNode{}
    dummy:=&ListNode{0,head}
    for node:=dummy;node!=nil;node=node.Next{
        stack=append(stack,node)
    }
    prev:=stack[len(stack)-1-n]
    prev.Next=prev.Next.Next
    return dummy.Next

}

双指针 

cur先走n步 这样同时移动的时候pre才能指向删除节点的上一个节点 i>n说明已经遍历过n个结点 此时同时移动双指针  //0ms 2.02MB  空间复杂度：O(1)

func removeNthFromEnd(head *ListNode, n int) *ListNode {
   dummy:=&ListNode{0,head}
   cur:=head
   pre:=dummy
   i:=1
   for cur!=nil{
       cur=cur.Next
       if i>n{
         pre=pre.Next
       }
       i++
   }
   pre.Next=pre.Next.Next
   return dummy.Next
}

二、两两交换链表中的节点

24.两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

递归

其实不太懂   空间复杂度：O(n)，其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间 递归调用需要使用栈来保存每个递归调用的状态

func swapPairs(head *ListNode) *ListNode {
    //递归的终止条件
    if head==nil||head.Next==nil{
        return head
    }
    //假设链表是 1->2->3->4
	//这句就先保存节点2
   temp:=head.Next
    //继续递归，处理节点3->4
	//当递归结束返回后，就变成了4->3
	//于是head节点就指向了4，变成1->4->3  将除第一个节点之外的所有节点进行交换
    head.Next=swapPairs(temp.Next)
    //将2节点指向1
   temp.Next=head
    return temp
}

迭代

想到创建哑结点，通过迭代的方式实现两两交换链表中的节点，交换之前的节点关系是 temp -> node1 -> node2，交换之后的节点关系要变成 temp -> node2 -> node1 空间复杂度：O(1)

func swapPairs(head *ListNode) *ListNode {
    dummy:=&ListNode{0,head}
    temp:=dummy
    
    for temp.Next!=nil&&temp.Next.Next!=nil{
          node1:=temp.Next
         node2:=temp.Next.Next
   
     temp.Next=node2
     node1.Next=node2.Next
     node2.Next=node1

     temp=node1//将temp设置为node1。这样，在下一次循环迭代中，我们可以处理下一对要交换的节点。
     
    
    }
    return dummy.Next
}

最后

不确定的事很多，在能把握的时候，好好把握！