Golang常见面试题目解析

  • 更新时间:
  • 3423人关注
  • 点击下载

这是一个不错的Golang面试题类学习资源,由闻安然提供,主要知识点是关于Golang面试题、Golang、Golang面试题的内容,已被404人关注,同类资源中评分为8.1分。

资源详情相关推荐
  • 大小:16.7 MB
  • 类别:Golang面试题
  • 格式:PDF
  • 编辑:融傲蕾
  • 热度:704
  • Golang 修养之路
  • Golang入坑之旅
  • 大厂Golang开发工程师面试题集锦
  • 从Java到Golang快速入门
  • Golang Gin框架开发实践
  • 精选笔记:python/golang 删除链表中的元素

    21小时6分钟前回答

    先用使用常规方法,两个指针:

    golang实现:

    type Node struct {
      value int
      next *Node
    }
    
    type Link struct {
      head *Node
      tail *Node
      lenth int
    }
    
    // 向链表中添加元素
    func (link *Link) add(v int) {
      if link.lenth == 0 { // 当前链表是空链表
        link.head = &Node{v, nil}
        link.tail = link.head
        link.lenth = 1
      } else {
        newNond := &Node{v, nil}
        link.tail.next = newNond
        link.tail = newNond
        link.lenth += 1
      }
    }
    
    // 删除链表中的元素(双指针)
    func (link *Link) remove(v int) {
      if link.lenth == 0 {
        fmt.Println("空链表,不支持该操作")
        return
      }
      var previous *Node = nil
      for current := link.head; current != nil; current = current.next {
        if current.value == v {
          if current == link.head { // 要删除的是头节点
            link.head = current.next
          } else if current == link.tail { // 要删除的是尾节点
            previous.next = nil
            link.tail = previous
          } else { // 要删除的是中间的节点
            previous.next = current.next
          }
          link.lenth -= 1
          break
        }
        previous = current
      }
    }
    
    // 打印链表
    func (link *Link) printList() {
      if link.lenth == 0 {
        fmt.Println("空链表")
        return
      }
      for cur := link.head; cur != nil; cur = cur.next {
        fmt.Printf("%d ", cur.value)
      }
      fmt.Println()
    }
    
    

    python实现:

    class Node:
      def __init__(self, value, next):
        self.value = value
        self.next = next
    
      def __str__(self):
        return str(self.value)
    
    class Link:
      def __init__(self):
        self.head = None
        self.tail = None
        self.lenth = 0
    
      # 向链表中添加元素
      def add(self, v):
        if self.lenth == 0: # 当前链表是空链表
          self.head = Node(v, None)
          self.tail = self.head
          self.lenth = 1
        else:
          new_node = Node(v, None)
          self.tail.next = new_node
          self.tail = new_node
          self.lenth += 1
    
      # 打印链表
      def print(self):
        if self.lenth == 0:
          print('空链表')
          return
        cur = self.head
        while True:
          if cur == None:
            print()
            break
          print(cur, end=' ')
          cur = cur.next
    
      # 删除链表中的元素
      def remove(self, v):
        if self.lenth == 0:
          return
        cur = self.head
        pre = None
        while True:
          if cur.value == v:
            if cur == self.head: # 要删除的是头节点
              self.head = cur.next
            elif cur == self.tail: # 要删除的是尾节点
              pre.next = None
              self.tail = pre
            else: # 要删除的是中间的节点
              pre.next = cur.next
            self.lenth -= 1
            break
          pre = cur
          cur = cur.next
          if cur == None:
            print("未找到", v)
            break

    只使用使用一个指针实现链表的删除:

    golang实现:

    func (link *Link) remove_with_one_pointer(v int) {
      if link.lenth == 0 {
        return
      }
      if link.tail.value == v { // 要删除的节点是尾节点,需特殊处理
        if link.lenth == 1 { // 如果链表只有一个节点
          link.head = nil
          link.tail = nil
        } else { //大于一个节点
          cur := link.head
          for ; cur.next.next != nil; cur = cur.next {
          } //找到尾节点的前一个节点
          cur.next = nil
          link.tail = cur
        }
        link.lenth -= 1
        return
      }
      //要删除的节点在头部/中间 的常规情况
      for cur := link.head; cur != nil; cur = cur.next {
        if cur.value == v {
          cur.value = cur.next.value
          cur.next = cur.next.next
          link.lenth -= 1
          return
        }
      }
      fmt.Println("未找到", v)
    }

    python实现:

    def remove_with_one_pointer(self, v):
      if self.lenth == 0:
        return
      if self.tail.value == v: # 要删除的节点是尾节点,需特殊处理
        if self.lenth == 1: # 如果链表只有一个节点
          self.head = None
          self.tail = None
        else: # 大于一个节点
          cur = self.head
          while True:
            if cur.next.next is None: # 找到尾节点的前一个节点
              break
            else:
              cur = cur.next
          cur.next = None
          self.tail = cur
        self.lenth -= 1
        return
      # 要删除的节点在头部/中间 的常规情况
      cur = self.head
      while True:
        if cur.value == v:
          cur.value = cur.next.value
          cur.next = cur.next.next
          self.lenth -= 1
          break
        cur = cur.next
        if cur is None:
          print('未找到', v)
          break

    以上就是python/golang 删除链表中的元素的详细内容,更多关于python/golang 链表的资料请关注码农之家其它相关文章!

    展开阅读
    精选笔记:Golang中参数传递方式方法

    16小时20分钟前回答

    参数传递是指在程序的传递过程中,实际参数就会将参数值传递给相应的形式参数,然后在函数中实现对数据处理和返回的过程,下面这篇文章主要给大家介绍了关于Golang中参数传递的相关资料,需要的朋友可以参考下。

    前言

    本文主要给大家介绍了关于Golang参数传递的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧。

    关于参数传递,Golang文档中有这么一句:

    after they are evaluated, the parameters of the call are passed by value to the

    function and the called function begins execution.

    函数调用参数均为值传递,不是指针传递或引用传递。经测试引申出来,当参数变量为指针或隐式指针类型,参数传递方式也是传值(指针本身的copy)

    Slice是最常用的数据结构之一,下面以Slice为例,解释Golang的参数传递机制。

    Slice数据结构如下:

    Golang中参数传递方式方法

    示例代码:


    package main
    
    import "fmt"
    
    func main(){
     slice := make([]int, 3, 5)
     fmt.Println("before:", slice)
     changeSliceMember(slice)
     fmt.Println("after:", slice)
    }
    
    func changeSliceMember(slice []int) {
     if len(slice) > 1 {
     slice[0] = 9
     }
    }

    函数执行结果为:


    befor:[0 0 0]
    after:[9 0 0]

    解释:

    从数据结构图中可看出,Slice可以理解成结构体类型,包含底层数组首元素地址、数组len、容量三个字段,slice对象在参数传值过程中,把三个字段的值传递过去了,实际上changeSliceMember函数内slice在内存中的地址和main中的slice内存地址不一样,只是字段值是一样的,而第一个字段Pointer的值就是底层数组首元素地址,因此可以直接改变元素内容

    可以与下面代码做对比,理解:


    package main
    
    func main() {
     value := new(int)
     modifyFunc(value)
     println("main:", value)
    }
    
    func modifyFunc(value *int) {
     value = nil
     println("modifyFunc:", value)
    }

    执行结果:


    modifyFunc: 0x0
    main: 0xc820049f30

    可以看出,即使传值为指针,仍未改变变量value在main中的值,因为modifyFunc中value的值为指针,和main中的value值一样,但是俩对象本身是两个对象,读者可以细细体会

    以上就是Golang中参数传递方式方法的详细内容,更多请关注码农之家其它相关文章!

    展开阅读

    相关资源

    • Android高级开发面试题以及答案整理

      Android知识点的总结,可以以此为参考复习知识!

      大小:13.99 MBAndroid面试题

      立即下载
    • 2020Java面试题整理

      2020Java面试题整理

      《2020Java面试题整理》 面试题含有redis,netty,mysql,kafka,并发编程,spring,dubbo,以及思维导图学习笔记,适合20k以上突击。 本文的宗旨是为读者朋友们整理一份详实而又权威的面试清单,详细的介绍了redis,netty,mysql,kafka,并发编程,spring等Java知识点,以及各大企业面试笔试中的特性与侧重点,面试的高频题目,反复出现在近5年各大公司的笔试和面试中,对面试备考有着极强的参考价值,相信你了解和掌握之后一定会有所提高。让我们一起来看看

      大小:62.5 MBJava面试

      立即下载
    • 嵌入式C语言面试题汇总

      嵌入式C语言面试题汇总

      本文档归纳了嵌入式软件开发工程师、C/C++工程师在面试过程中常考问题,整个文档对各大论坛出现的面试题进行了一定的汇总,做到了内容细,答案准,需要的朋友可下载试试! 现在发展最快的也就是IT行业了,嵌入式就是其中之一,很多刚学出来的去找工作,一般都会是被面试题给难住了,与理想工作失之交臂,该文档总结出了一点规律,一般C语言是必考的,题里面必有的,希望可以帮到你。 第一部分:基本概念及其它问答题 第二部分:程序代码

      大小:272 KBC语言

      立即下载
    • unity面试题及答案总结

      unity面试题及答案总结

      1. 请简述值类型与引用类型的区别 答:区别: 1. 值类型存储在内存栈中,引用类型数据存储在内存堆中,而内存单元中存放的是堆中存放的地址。 2. 值类型存取快,引用类型存取慢。 3. 值类型表示实际数据,引用类型表示指向存储在内存堆中的数据的指针和引用。 4. 栈的内存是自动释放的,堆内存是 .NET 中会由 GC 来自动释放。 5. 值类型继承自 System.ValueType, 引用类型继承自 System.Object 。 2.C# 中所有引用类型的基类是什么 答:引用类型的基类是 Syste

      大小:20 KBunity面试

      立即下载
    • 程序员面试手册:概念、编程问题及面试题

      程序员面试手册:概念、编程问题及面试题

      这书是朝向程序猿招聘面试的教材,书中包揽了各种各样程序编写解决方法,能够 用于合理地解决招聘面试、考题及校招。内容包括了代码、架构模式、数据库系统、数据结构及优化算法等关

      大小:139.5 MB程序员面试

      立即下载
    • 大厂Golang开发工程师面试题集锦

      大小:307 KBGolang

      立即下载
    • Python面试合集(史上最全面Python面试题和详解)

      Python面试合集(史上最全面Python面试题和详解)

      本文件内含10个文档,文档格式为md,需要用Markdown打开,该软件搜索即可下载。内容如题,全面的Python面试题和详解,需要的朋友可下载试试! 包含:2019 Python最新面试题及答案16道题、110道Python面试题(上)、最常见的 35 个 Python 面试题及答案(2018 版)、整理的最全 python常见面试题(基本必考)等!

      大小:141 KBPython面试

      立即下载

    学习笔记

    23小时45分钟前回答

    详解Golang中switch语句和select语句的用法

    这篇文章主要给大家介绍了关于Golang中switch和select的用法教程,文中通过示例代码将switch语句与select语句的使用方法介绍的非常详细,对大家具有一定的参考学习价值,需要的朋友们下面跟着小编一起来学习学习吧。 本文主要给大家介绍了关于Golang中switch和select用法的相关内容,分享出来供大家参考学习,下面来一起看看详细的介绍: 一、switch语句 switch语句提供了一个多分支条件执行的方法。每一个case可以携带一个表达式或一个类型说明符。前者又可被简称为case表达式。因此,Go语言的switch语句又分为表达式switch语句和类型switch语句。 1、表达式switch语句 var name string ... switch name { case Golang: fmt.Print……

    6小时53分钟前回答

    python/golang实现循环链表的代码

    循环链表就是将单链表的末尾指向其头部,形成一个环。循环链表的增删操作和单链表的增删操作 区别不大。只是增加时,需要考虑空链表增加第一个节点的特殊情况;删除时需考虑删除节点是头/尾节点,和链表中只有一个节点的特殊情况。 golang实现: type Node struct { value int next *Node}type Circle struct { tail *Node lenth int}// 增加节点:func (c *Circle) add(value int) { newNode := Node{value, nil} if c.lenth == 0 { //空链表中添加节点 c.tail = newNode c.tail.next = newNode } else { newNode.next = c.tail.next c.tail.next = newNode c.tail = newNode } c.lenth += 1 c.printCircle()}// 删除节点:func (c *Circle) remove(v int) { if c.lenth == 0 { fmt.Println(空环) return } else if c.len……

    18小时34分钟前回答

    python/golang实现循环链表的示例代码

    循环链表就是将单链表的末尾指向其头部,形成一个环。循环链表的增删操作和单链表的增删操作 区别不大。只是增加时,需要考虑空链表增加第一个节点的特殊情况;删除时需考虑删除节点是头/尾节点,和链表中只有一个节点的特殊情况。 golang实现: type Node struct { value int next *Node}type Circle struct { tail *Node lenth int}// 增加节点:func (c *Circle) add(value int) { newNode := Node{value, nil} if c.lenth == 0 { //空链表中添加节点 c.tail = newNode c.tail.next = newNode } else { newNode.next = c.tail.next c.tail.next = newNode c.tail = newNode } c.lenth += 1 c.printCircle()}// 删除节点:func (c *Circle) remove(v int) { if c.lenth == 0 { fmt.Println("空环") return } else if c.l……