go語言快速刷《程序員面試金典》（3）

編寫程序以 x 爲基準分割鏈表，使得所有小於 x 的節點排在大於或等於 x 的節點之前。如果鏈表中包含 x，x 只需出現在小於 x 的元素之後(如下所示)。分割元素 x 只需處於“右半部分”即可，其不需要被置於左右兩部分之間。

示例:

輸入: head = 3->5->8->5->10->2->1, x = 5
輸出: 3->1->2->10->5->5->8

一趟分離，然後連起來即可。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func partition(head *ListNode, x int) *ListNode {
    if head == nil{
        return nil
    }
    dummnyhead1,dummnyhead2 := &ListNode{-1,nil},&ListNode{-1,nil}
    cur1,cur2 := dummnyhead1,dummnyhead2
    cur := head
    for cur != nil{
        if cur.Val <x{
            cur1.Next = cur
            cur = cur.Next
            cur1 = cur1.Next
        }else if cur.Val >=x{
            cur2.Next = cur
            cur = cur.Next
            cur2 = cur2.Next
        }
    }
    cur2.Next = nil
    cur1.Next = dummnyhead2.Next
    return dummnyhead1.Next
}

---

給定兩個用鏈表表示的整數，每個節點包含一個數位。

這些數位是反向存放的，也就是個位排在鏈表首部。

編寫函數對這兩個整數求和，並用鏈表形式返回結果。

 

示例：

輸入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
輸出：2 -> 1 -> 9，即912
進階：假設這些數位是正向存放的，請再做一遍。

示例：

輸入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
輸出：9 -> 1 -> 2，即912

模擬豎式計算即可。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    up:=0;
    ans:= &ListNode{-1,nil};
    temp:=ans;
    for l1!=nil || l2!=nil{
        a,b:=0,0;
        if(l1!=nil){
            a=l1.Val;
        }    
        if(l2!=nil){
            b=l2.Val;
        }
        temp.Next=&ListNode{(a+b+up)%10,nil};
        up=int((a+b+up)/10);
        temp=temp.Next;
        if(l1!=nil){
            l1=l1.Next;
        }
        if(l2!=nil){
            l2=l2.Next;
        }
    }
    if(up!=0){
        temp.Next=&ListNode{up,nil};
    }
    return ans.Next;
}

---

編寫一個函數，檢查輸入的鏈表是否是迴文的。

 

示例 1：

輸入： 1->2
輸出： false 
示例 2：

輸入： 1->2->2->1
輸出： true 

其實最優解應該原地反轉一半，判斷完再反轉回去，我這個題是爲了連一下go的列表。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func isPalindrome(head *ListNode) bool {
	s:=make([]int,0)
	for head!=nil{
		s= append(s, head.Val)
		head=head.Next
	}
	for i:=0;i< len(s)/2;i++{
		if s[i]!=s[len(s)-1-i]{
			return false
		}
	}
	return true
}

---

給定兩個（單向）鏈表，判定它們是否相交併返回交點。請注意相交的定義基於節點的引用，而不是基於節點的值。換句話說，如果一個鏈表的第k個節點與另一個鏈表的第j個節點是同一節點（引用完全相同），則這兩個鏈表相交。

示例 1：

輸入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
輸出：Reference of the node with value = 8
輸入解釋：相交節點的值爲 8 （注意，如果兩個列表相交則不能爲 0）。從各自的表頭開始算起，鏈表 A 爲 [4,1,8,4,5]，鏈表 B 爲 [5,0,1,8,4,5]。在 A 中，相交節點前有 2 個節點；在 B 中，相交節點前有 3 個節點。

思路：調到長度一樣以後，看能否走到一樣的節點即可。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
    a,b:=0,0;
    for temp:=headA;temp!=nil;temp=temp.Next{
        a++;
    }
    for temp:=headB;temp!=nil;temp=temp.Next{
        b++;
    } 
    if(a>b){
        for i:=a-b;i>0;i--{
            headA=headA.Next;
        }
    }else if(a<b){
        for i:=b-a;i>0;i--{
            headB=headB.Next;
        }
    }
    for headA!=nil && headB!=nil{
        if(headA==headB){
            return headA;
        }
        headA=headA.Next;
        headB=headB.Next;
    }
    return nil;
}