输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

package main
/*
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
解：思路同合并两个有序数组，三个指针对应三个链表，两个链表的值进行比较后加入新链表中
 */
import "fmt"

func main() {
   node6 := Node{11,nil}
   node5 := Node{9,&node6}
   node4 := Node{7,&node5}
   node3 := Node{5,&node4}
   node2 := Node{3,&node3}
   node1 := Node{1,&node2}

   node16 := Node{data:16}
   node15 := Node{14,&node16}
   node14 := Node{12,&node15}
   node13 := Node{10,&node14}
   node12 := Node{8,&node13}
   node11 := Node{6,&node12}
   node10 := Node{4,&node11}
   node9 := Node{2,&node10}

   //test
   node := solution(node1, node9)
   //print
   for ; nil != node; {
      if nil == &node.data {
         fmt.Println("data is empty")
      } else {
         fmt.Println(node.data)
      }

      if nil != node.next {
         node = node.next
      } else {
         break
      }
   }
}

type Node struct {
   data int
   next *Node
}

func solution(node1 Node, node2 Node) *Node {
   //空判断
   if nil == &node1 || nil == &node2 {
      return &node1
   }

   if nil == &node1 {
      return &node2
   }

   if nil == &node2 {
      return &node1
   }
   //链表达到边界标识符
   var node1boder = false //链表达到边界标识符
   var node2boder = false

   var noderes *Node //链表指针
   var nodepre *Node //链表头指针

   for i := 0; !node1boder || !node2boder; i++ {
      var node3 Node //临时变量
      /边界操作
      if node1boder {
         nodepre.next = &node2
         return noderes
      }

      if node2boder {
         nodepre.next = &node1
         return noderes
      }
      /边界操作
      /非边界进行比较加入链表
      if node1.data < node2.data {
         node3.data = node1.data
         if nil != node1.next {
            node1 = *node1.next
         } else {
            node1boder = true
         }
      } else {
         node3.data = node2.data
         if nil != node2.next {
            node2 = *node2.next
         } else {
            node2boder = true
         }

      }
      /非边界进行比较加入链表
      if i == 0 { //链表头部处理
         nodepre = &node3
         noderes = nodepre //head
      } else {
         nodepre.next = &node3
         nodepre = nodepre.next
      }
   }
   return noderes
}