每日编程（十六）--leetcode

题目：移除链表元素

题目描述：删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5
分析：一开始看题觉得特别简单，也确实简单，只是在提交过程中发现遗漏了多种特殊情况，只有一个元素，该元素是指定值，或者两个元素，都是指定值，如果不考虑就会发生越界（panic），上代码看一下
代码：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeElements(head *ListNode, val int) *ListNode {
    
    for head!=nil && head.Val==val{             //先对链表首部进行排除，直到找到不符合的节点
        head=head.Next                                     
    }
    if head==nil{               //判断是否为空
        return nil
    }
    p:=head
    for p.Next!=nil{
        if p.Next.Val==val{
            p.Next=p.Next.Next
        }else{
            p=p.Next
        }
        
    }
   return head
}

题目：删除链表中的节点

题目描述：请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1:

输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:

输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

分析：这个题貌似看着和上个题没什么区别，而且还非末尾节点，还像是更简单了一些，但是看了代码才发现他考察的点不一样了，先看一下题目

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteNode(node *ListNode) {
}

细心地网友会发现，他给定的参数只有一个节点，这个其实就是要删除的节点，所以这次就不能用p.Next=p.Next.Next的形式来进行节点的删除，而是要用节点的复制，也就是说，把node的下一节点复制给node，怎么复制呢绝对不是node=node.Next,这只是指针的移动，不多说了看代码：
代码：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteNode(node *ListNode) {
    node.Val=node.Next.Val
    node.Next=node.Next.Next
}

题目：分割链表

题目描述：给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。

每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1，也就是说可能有些部分为 null。

这k个部分应该按照在链表中出现的顺序进行输出，并且排在前面的部分的长度应该大于或等于后面的长度。

返回一个符合上述规则的链表的列表。

举例： 1->2->3->4, k = 5 // 5 结果 [ [1], [2], [3], [4], null ]

示例 1：

输入:
root = [1, 2, 3], k = 5
输出: [[1],[2],[3],[],[]]
解释:
输入输出各部分都应该是链表，而不是数组。
例如, 输入的结点 root 的 val= 1, root.next.val = 2, \root.next.next.val = 3, 且 root.next.next.next = null。
第一个输出 output[0] 是 output[0].val = 1, output[0].next = null。
最后一个元素 output[4] 为 null, 它代表了最后一个部分为空链表。
示例 2：

输入:
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
输出: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
解释:
输入被分成了几个连续的部分，并且每部分的长度相差不超过1.前面部分的长度大于等于后面部分的长度。

分析：将制定链表分成k份，不够用空代替，所以肯定要确定链表长度，先进行计算，看每个链表有多少个元素，并且余多少个，再进行添加

代码：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func splitListToParts(root *ListNode, k int) []*ListNode {
    list:=[]*ListNode{}
   
    if k==0{
        return list
    }
    len:=0
    cur:=root
    for cur!=nil{
        cur=cur.Next
        len++
    }
    nums:=len/k
    rem:=len%k
 
    
    for i:=0;i<k;i++{
        temp:=&ListNode{}
        temphead:=temp
        target:=nums       
        if rem>0{             
            rem--
            target++
        }
        for j:=0;j<target && root!=nil;j++{
            temp.Next=root
            root=root.Next
            temp=temp.Next
        }
        temp.Next=nil
        list=append(list,temphead.Next)
    }
    return list
}