Go面试编程题目（四）

原文地址：Go面试编程题目（四）

1、斐波那数列？

斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55…，数列从第3项开始，每一项都等于前两项之和，实现代码如下：

package main

import "fmt"

func isFibonacciSequence(i int) int {
  if i <= 1 {
    return 1
  }
  return isFibonacciSequence(i-1) + isFibonacciSequence(i-2)
}
func main() {
  var i int = 10
  var j int = 3
  fmt.Println("第", i+1, "项的值为", isFibonacciSequence(i))
  fmt.Println("第", j+1, "项的值为", isFibonacciSequence(j))
}

打印结果如下：

2、猴子吃桃？

猴子第一天摘了若干个桃子，当即吃了一半，还不解馋，又多吃了一个；第二天，吃剩下的桃子的一半，还不过瘾，又多吃了一个；以后每天都吃前一天剩下的一半多一个，到第10天想再吃时，只剩下一个桃子了，问第一天共摘了多少个桃子？

实现代码如下：

package main

import "fmt"

func f(n int) int {
  if n == 1 {
    return 1 //最后一天只有一个桃子
  } else {
    return 2*f(n-1) + 2
  }
}

func main() {
  sum := (f(10)) //十天前有sum个桃子
  fmt.Printf("第一天摘了%d个桃子", sum)
}

打印结果如下：

3、出售金鱼？

卖家将养的一缸金鱼分五次出售，第一次出售上一次卖出全部的一半加二分之一条，第二次卖出余下的三分之一加三分之一条，第三次卖出余下的四分之一加四分之一条，第四次卖出余下的五分之一加五分之一条，最后卖出余下的11条，问原来的鱼缸中共有几条金鱼？

实现代码如下：

package main

import "fmt"

func main() {
  res := 11
  for j := 4; j >= 1; j-- {
    res = (res*(j+1) + 1) / j
  }

  fmt.Println("原来的鱼缸中共有", res, "条鱼")
}

打印结果如下：

4、无重复字符的最长子串？

给定字符串，求最长的无重复字符的子串，此处是子串，不是子序列，所以必须是连续的，实现代码如下：

package main

import "fmt"

func lengthOfLongestSubstring(s string) int {
  var left, res int
  usedChar := make(map[rune]int)
  for i, v := range s {
    if k, ok := usedChar[v]; ok && left <= k {
      left = k + 1
    } else {
      res = max(res, i-left+1)
    }

    usedChar[v] = i
  }
  return res
}

func max(a, b int) int {
  if a > b {
    return a
  } else {
    return b
  }
}

func main() {
  var t string = "3456789x1234123"
  var m string = "sdkjfisf56789x1234123"
  fmt.Println(lengthOfLongestSubstring(t))
  fmt.Println(lengthOfLongestSubstring(m))
}

打印结果如下：

5、实现单链表？

实现代码如下：

package main

import (
  "fmt"
)

type studentNode struct {
  no   int
  name string
  age  int
  next *studentNode
}

//给链表插入一个结点
//编写第一种插入方法，在单链表的最后加入
func insertStudentNode(head *studentNode, newStudentNode *studentNode) {
  //思路：
  //1.先找到该链表的最后这个结点
  //2.创建一个辅助结点
  temp := head
  for {
    if temp.next == nil { //表示找到最后
      break
    }
    temp = temp.next //让temp不断的指向下一个结点
  }
  //3.将newStudentNode加入到链表的最后
  temp.next = newStudentNode
}

//第二种插入方法，根据no的编号从大到小插入
func sortInsertStudentNode(head *studentNode, newStudentNode *studentNode) {
  //思路
  //1.找到适当的位置
  //2.创建一个辅助结点
  temp := head
  flag := true
  //把newStudentNode.no和temp.next.no作比较
  for {
    if temp.next == nil { //说明已经到链表的最后啦
      break
    } else if temp.next.no > newStudentNode.no {
      //说明newStudentNode就应该插入到temp的后面
      break
    } else if temp.next.no == newStudentNode.no {
      //说明链表中已经有这个no了
      flag = false
      break
    }
    temp = temp.next
  }
  if !flag {
    fmt.Println("已经存在no=", newStudentNode)
  } else {
    newStudentNode.next = temp.next
    temp.next = newStudentNode
  }
}

//删除一个结点
func delStudentNode(head *studentNode, id int) {
  temp := head
  flag := false
  //找到要删除的结点的no，和temp的下一个结点的no比较
  for {
    if temp.next == nil { //说明已经到链表的最后了
      break
    } else if temp.next.no == id {
      //说明我们找到这个要删除的结点了
      flag = true
      break
    }
    temp = temp.next
  }
  if flag {
    temp.next = temp.next.next //要删除这个结点即直接略过这个结点，
    //然后这个被略过的结点会变成垃圾结点，会被链表删除
  } else {
    fmt.Println("要删除的id不存在")
  }
}
func modifyStudentNode(head *studentNode, id int, newStudentNode *studentNode) {
  temp := head
  flag := false
  //思路：
  //1.找到要修改的结点的no，和temp.next.no作比较
  for {
    if temp.next == nil { //说明已经到了链表的最后
      break
    } else if temp.next.no == id {
      //说明我们已经找到这个要修改的结点了
      flag = true
      break
    }
    temp = temp.next
  }
  if flag {
    temp.next = newStudentNode
  } else {
    fmt.Println("要修改的结点不存在")
  }
}

//显示链表的所有结点信息
func listStudentNode(head *studentNode) {
  //1.创建一个辅助结点
  temp := head
  //先判断该链表是不是一个空的链表
  if temp.next == nil {
    fmt.Println("这是一个空链表")
    return
  }
  //2.遍历这个链表
  for {
    fmt.Printf("[%d,%s,%d]==>", temp.next.no,
      temp.next.name, temp.next.age)
    //判断是否是链表的末尾
    temp = temp.next
    if temp.next == nil {
      break
    }
  }

}

func main() {
  //1.先创建一个头结点
  head := &studentNode{}
  //2.创建一个新的studentNode
  stuLisa := &studentNode{
    no:   1,
    name: "Lisa",
    age:  24,
  }
  stuBob := &studentNode{
    no:   2,
    name: "Bob",
    age:  25,
  }
  stuNick := &studentNode{
    no:   3,
    name: "Nick",
    age:  27,
  }
  stuMark := &studentNode{
    no:   4,
    name: "Mark",
    age:  29,
  }
  stuMarket := &studentNode{
    no:   4,
    name: "Market",
    age:  30,
  }
  //3.加入结点
  insertStudentNode(head, stuLisa)
  insertStudentNode(head, stuBob)

  //显示链表
  listStudentNode(head)
  fmt.Println()
  //4.加入结点（第二种方法）
  sortInsertStudentNode(head, stuMark) //no是4
  sortInsertStudentNode(head, stuNick) //no是3
  listStudentNode(head)
  fmt.Println()
  //5.删除结点
  delStudentNode(head, 2)
  //显示链表
  listStudentNode(head)
  fmt.Println()
  //6.修改结点
  modifyStudentNode(head, 4, stuMarket)
  listStudentNode(head)
}

打印结果如下：

至此，本次分享就结束了，后期会慢慢补充。

以上仅为个人观点，不一定准确，能帮到各位那是最好的。

好啦，到这里本文就结束了，喜欢的话就来个三连击吧。

扫码关注公众号，获取更多优质内容。