2.如何选择go语言基础类型——Leetcode习题9

目录

• 本篇前瞻
  
• Leetcode习题9
  
  
  
  • 题目描述
    
  • 原题解析
    
  • 代码编写
    
  • 有符号整形
    
  
  
• 基本数据类型
  
  
  
  • 整形
    
    
    
    • 有符号整形
      
    • 无符号整形
      
    
    
  • 浮点型
    
  • 布尔型
    
  • 字符
    
  
  
• 本篇小结
  
• 下一篇预告
  

本篇前瞻

欢迎来go语言的基础篇，这里会帮你梳理一下go语言的基本类型，注意本篇有参考go圣经，如果你有完整学习的需求可以看一下。另外，go语言的基本类型比较简单，介绍过程就比较粗暴，不过我们需要先从一个例题开始。
Leetcode习题9

先让我们看下这个来自leetcode的例子，这个是一个比较好的例子，里面有一些关于整形的的知识
题目描述

9. 回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
原题解析

注意原题中已经提供了一个go语言的函数

1. func isPalindrome(x int) bool {
2. }

复制代码

为了方便我们编写代码，我们只需要知道这个函数的输入是x，输出是代表是否是回文数（是：true，否：false），return能返回输出。
解题方法：

• 负数必然不是回文数。
  
• 对于非负整数，我们循环x除10，通过x%10获得最低位，并且把最低位当作最高位加入到px中，得到了x的反转过来的数px
  
• 判断px和x是否相等就可以了。
  

代码编写

使用int32来计算px， 将如下代码提交，不行，答案错误，这是因为如果x=2147483647,那么px=7463847412，超出int32的范围了

1. func isPalindrome(x int) bool {
2.         if x < 0 {
3.                 return false
4.         }
6.         x32 := int32(x)
7.         px32 := int32(x)
8.         for x32 != 0 {
9.                 px32 = px32*10 + x32%10
10.                 x32 /= 10
11.         }
12.         return px32 == int32(x)
13. }

复制代码

那么换成int64代码如下，提交通过了，我们花费了28ms，仅仅击败12%的人，时间上有问题吗？

1. func isPalindrome(x int) bool {
2.         if (x < 0) {
3.                 return false
4.         }
5.         x64 := int64(x)
6.         px64 := int64(0)
7.         for x64 != 0 {
8.                 px64 = px64*10 + x64%10
9.                 x64 /= 10
10.         }
11.         return px64 == int64(x)
12. }

复制代码

现在尝试去掉int64的强制转化,居然通过了，只花费4ms，击败了97%的人，这不可思议！

1. func isPalindrome(x int) bool {
2.         if (x < 0) {
3.                 return false
4.         }
5.         x64 := x   //整形
6.         px64 := 0
7.         for x64 != 0 {
8.                 px64 = px64*10 + x64%10
9.                 x64 /= 10
10.         }
11.         return px64 == x //布尔型
12. }

复制代码

有符号整形

这种整形就是可以表示负整数，0和正整数
数据类型占用空间（bit）长度（字节）取值范围int881-2^7 ~ 2^7-1(-128~127)int16162-2^15 ~ 2^15-1(-32768 ~ 32767)int32324-2^32 ~ 2^32-1(-2147483648 ~ 2147483647)int64648-2^64 ~ 2^64-1(-9223372036854775808 ~ 9223372036854775807)int32或644或8同int32或int64注意：int的占用空间取决于你的操作系统是32位或64位
那么利用这三次提交的结果，并结合有符号整形的知识，我们可以得出：

• 变量强制类型转化会耗时
  
• 编程中的变量的取值范围很重要
  
• Leetcode的判题系统是64位的
  

基本数据类型

从上面的例题中我们能发现数据类型的选择在编程过程中有着决定性的作用，虽然这很基础，但是决定了你的编程结果是否正确，选择合适的类型会使你编写的程序运行速度更快，占用内存更小。
注意：由于复数类型不常用的关系，本章节不会介绍该类型。
整形

这个不是韩国的“绝学”——整形术，整形在编程中可以表示一定范围内的整数
注意：int或uint的占用空间取决于你的操作系统是32位或64位
对于整形我们要关注的是数据类型的长度，数据范围
代码如下：

1. package main
3. import (
4.         "fmt"
5.         "math"
6.         "unsafe"
7. )
9. func main() {
10.         fmt.Printf("int8   length: %v range: %v ~ %v\n", unsafe.Sizeof(int8(1)), math.MinInt8, math.MaxInt8)
11.         fmt.Printf("int16  length: %v range: %v ~ %v\n", unsafe.Sizeof(int16(1)), math.MinInt16, math.MaxInt16)
12.         fmt.Printf("int32  length: %v range: %v ~ %v\n", unsafe.Sizeof(int32(1)), math.MinInt32, math.MaxInt32)
13.         fmt.Printf("int64  length: %v range: %v ~ %v\n", unsafe.Sizeof(int64(1)), math.MinInt64, math.MaxInt64)
14.         fmt.Printf("int    length: %v\n", unsafe.Sizeof(int(1)))
16.         fmt.Printf("uint8  length: %v range: 0 ~ %v\n", unsafe.Sizeof(uint8(1)), math.MaxUint8)
17.         fmt.Printf("uint16 length: %v range: 0 ~ %v\n", unsafe.Sizeof(uint16(1)), math.MaxUint16)
18.         fmt.Printf("uint32 length: %v range: 0 ~ %v\n", unsafe.Sizeof(uint32(1)), math.MaxUint32)
19.         fmt.Printf("uint64 length: %v range: 0 ~ %v\n", unsafe.Sizeof(uint64(1)), uint64(math.MaxUint64))
20.         fmt.Printf("uint   length: %v\n", unsafe.Sizeof(uint(1)))
21. }

复制代码

输出：

1. int8   length: 1 range: -128 ~ 127
2. int16  length: 2 range: -32768 ~ 32767
3. int32  length: 4 range: -2147483648 ~ 2147483647
4. int64  length: 8 range: -9223372036854775808 ~ 9223372036854775807
5. int    length: 8
6. uint8  length: 1 range: 0 ~ 255
7. uint16 length: 2 range: 0 ~ 65535
8. uint32 length: 4 range: 0 ~ 4294967295
9. uint64 length: 8 range: 0 ~ 18446744073709551615
10. uint   length: 8

复制代码

有符号整形

这种整形就是可以表示负整数，0和正整数
数据类型占用空间（bit）长度（字节）取值范围int881-2^7 ~ 2^7-1(-128~127)int16162-2^15 ~ 2^15-1(-32768 ~ 32767)int32324-2^32 ~ 2^32-1(-2147483648 ~ 2147483647)int64648-2^64 ~ 2^64-1(-9223372036854775808 ~ 9223372036854775807)int32或644或8同int32或int64无符号整形

这种整形就是可以表示非负整数
数据类型占用空间（bit）长度（字节）取值范围uint8810 ~ 2^8-1(0 ~ 255)uint161620 ~ 2^16-1(0 ~ 65535)uint323240 ~ 2^32-1(0 ~ 4294967295)uint646480 ~ 2^64-1(0 ~ 18446744073709551615)uint32或644或8同uint32或uint64浮点型

浮点型在编程中可以表示一定范围内的实数
注意：对于浮点型我们要关注的是数据类型的长度，数据范围，但更要关注精度。
代码如下：

1. package main
3. import (
4.         "fmt"
5.         "math"
6.         "unsafe"
7. )
9. func main() {
10.         fmt.Printf("float32 length: %v range: %v ~ %v\n", unsafe.Sizeof(float32(1)), -math.MaxFloat32, math.MaxFloat32)
11.         fmt.Printf("float64 length: %v range: %v ~ %v\n", unsafe.Sizeof(float64(1)), -math.MaxFloat64, math.MaxFloat64)
12.         fmt.Printf("after transfer float32 %v\n", float32(1.328))
13.         fmt.Printf("after transfer float64 %v\n", float64(float32(1.328)))
14. }

复制代码

输出：

1. float32 length: 4 range: -3.4028234663852886e+38 ~ 3.4028234663852886e+38
2. float64 length: 8 range: -1.7976931348623157e+308 ~ 1.7976931348623157e+308
3. before transfer float32: 1.328
4. after  transfer float64: 1.3279999494552612

复制代码

你可以看到1.328在float32强制转化为float64反常地失去了一些精度，当然这就是为啥项目和数据库只有高精度实数的原因，你可以想象在这种情况时使用乘法后可怕的结果。
至于这个产生的原因时浮点32型和浮点64型在计算机上表示方式不同，这部分内容你可以查看《计算机程序的构造和解释》。
列表如下：
数据类型占用空间（bit）长度（字节）取值范围float32324-3.4028234663852886e+38 ~ 3.4028234663852886e+38float64648-1.7976931348623157e+308 ~ 1.7976931348623157e+308布尔型

最简单的类型
注意：分支语句中的if后面的表达式的结果值是true或false
代码如下：

1. package main
3. import (
4.         "fmt"
5.         "unsafe"
6. )
8. func main() {
9.         fmt.Printf("bool length: %v %v/%v", unsafe.Sizeof(true), 0 == 0, 0 != 0)
10. }

复制代码

输出：

1. bool length: 1 true/false

复制代码

列表如下：
数据类型占用空间（bit）长度（字节）取值范围bool11true/false字符

注意：byte是包含ascii码，即uint8 ，rune是可以包含utf-8的，即uint32
代码如下：

1. package main
3. import (
4.         "fmt"
5.         "unsafe"
6. )
8. func main() {
9.         fmt.Printf("byte length: %v %v %c\n", unsafe.Sizeof(byte('a')),byte('a'),byte('a'))
10.         fmt.Printf("rune length: %v %v %c\n", unsafe.Sizeof(rune('中')),rune('中'),rune('中'))
11. }

复制代码

输出：

1. byte length: 1 97 a
2. rune length: 4 20013 中

复制代码

列表如下：
数据类型占用空间（bit）长度（字节）取值范围byte810 ~ 2^8-1(0 ~ 255)rune3240 ~ 2^32-1(0 ~ 4294967295)本篇小结

很好，你已经阅读完了go的基本数据类型!看是不是简单？学习go语言其实比较简单，你先通过例题知道了选择基础数据类型的重要性，然后通过基本数据类型，你知道了每个类型都有自己的长度，取值范围和注意点，最后相关代码房子在go语言学习的go-base/2中，你需要编写这些代码来实践一下go语言。
下一篇预告

go语言的控制结构

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！