hello，👏来到我的博客。我的自我定义是一个热爱黑客文化的极客，喜欢折腾各种计算机技术和编程语言。
fmt.Printlnpackage main
import "fmt"
func main() {
fmt.Println("Hello, World!")
num := 10
fmt.Println("The number is", num)
}相信每一个极客，都想拥有自己的博客。大家首先肯定会想到如CSDN类似的平台。但是作为一个极客,这样的平台显然不能满足我们的需求。
首先我心中的博客是什么样的
最开始的选择 https://wordpress.com/zh-cn/
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
如当输入链表{1,2,3}时，经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：
package main
import (
"fmt"
"strconv" "strings")
type Anode struct {
data int
nextNode *Anode
}
func main() {
var input string
var newLink *Anode
fmt.Scanln(&input)
newLink = reserve(toLinkNode(input))
outPrint(newLink)
}
func reserve(head *Anode) *Anode {
if head == nil {
return head
}
var nowNode, preNode, nextNode *Anode
nowNode = head
nextNode = head.nextNode
for nowNode != nil {
nextNode = nowNode.nextNode
nowNode.nextNode = preNode
preNode = nowNode
nowNode = nextNode
}
return preNode
}
func outPrint(linkHead *Anode) {
if linkHead == nil {
fmt.Println("{}")
return
}
var nowNode *Anode
nowNode = linkHead
fmt.Print("{")
for nowNode != nil {
if nowNode.nextNode == nil {
fmt.Printf("%d}", nowNode.data)
break
}
fmt.Printf("%d,", nowNode.data)
nowNode = nowNode.nextNode
}
}
func toLinkNode(inputString string) *Anode {
var headNode Anode
var preNode *Anode
numsString := strings.TrimPrefix(inputString, "{")
numsString = strings.TrimSuffix(numsString, "}")
nums := strings.Split(numsString, ",")
if nums[0] == "" {
return nil
}
for key, data := range nums {
var newNode Anode
if key == 0 {
headNode.data, _ = strconv.Atoi(data)
preNode = &headNode
continue
}
newNode.data, _ = strconv.Atoi(data)
preNode.nextNode = &newNode
preNode = &newNode
}
//fmt.Println(headNode)
return &headNode
}将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
例如：
给出的链表为 1→2→3→4→5→NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,
返回 1→4→3→2→5→NULL1→4→3→2→5→NULL.
func reverseBetween(head *ListNode, m int, n int) *ListNode {
if head == nil {
return head
}
var mNext, nNext *ListNode
var tmpNode *ListNode
var newLinkHead *ListNode
var lastNode *ListNode
tmpNode = head
for i := 1; i <= n; i++ {
if m == 1 {
mNext = nil
newLinkHead = head
}
if i == m-1 {
mNext = tmpNode
newLinkHead = mNext.Next
}
//{1,2,3,4,5}
if i == n {
lastNode = tmpNode
tmpNode = tmpNode.Next
lastNode.Next = nil
break
}
tmpNode = tmpNode.Next
}
nNext = tmpNode
var nowNode, preNode, nextNode *ListNode
nowNode = newLinkHead
nextNode = newLinkHead.Next
for nowNode != nil {
nextNode = nowNode.Next
nowNode.Next = preNode
preNode = nowNode
nowNode = nextNode
}
if mNext != nil {
mNext.Next = preNode
} else {
head = preNode
}
for preNode.Next != nil {
preNode = preNode.Next
}
preNode.Next = nNext
return head
}输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。
如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示
合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。
数据范围：节点总数 0≤n≤50000≤n≤5000，每个节点的val满足 ∣val∣<=1000∣val∣<=1000
要求：时间复杂度 O(nlogn)
输入：
[{1,2,3},{4,5,6,7}]
返回值：
{1,2,3,4,5,6,7}