OJ中go语法整理

对比Java需要注意的语法细节：

1)没有++i,只能i++;无while循环，可以用“for 条件”替代，无法定义不使用的变量；没有整型变量的max,min，abs函数；
2)数组的大小不是常量的话，需要通过make关键字定义slice进行替代;没有类只有func,类可以通过struct关键字替代。
3)go中没有初始化的slice，map,channel用nil关键字进行判断

go中特殊关键字：

// range语法,其中，i是索引，num是元素值
for i, num := range nums {}

基本模板

package main
import "fmt"
import "sort"
//import "math"
//import "strings"

func main(){
    var N,K int
    fmt.Scanf("%d %d",&N,&K)
    arr := make([]int,N)
    for i := 0;i < N;i++{
        fmt.Scan(&arr[i])
    }
    sort.Ints(arr)
    
    maxv := 0
    fmt.Printf("%d",maxv);
    
    
}

func min(a, b int) int { if b > a { return a }; return b }
func max(a, b int) int { if b > a { return b }; return a }
func abs(a int) int { if a > 0 { return a}; return -a }

1 输入输出（OJ）

• fmt package document

官方标准库手册组成

package fmt主要有四部分组成，分别是Constants、Variables,Functions,Types,其中
前面三个是包中定义的常量、变量、函数，较为容易理解。最后的Types定义了这个包中的inteface。

输入函数

• 输入输出需要引入fmt包

fmt.Scan(&N)
-----------------------------
var cap,val [3]int
for i := 0;i < 3;i++{
	fmt.Scanf("%d %d",&cap[i],&val[i])
}
----------------------------------------

package main
import "fmt"
func main(){
    var N int
    var s string
    fmt.Scan(&N)
    fmt.Scan(&s)
    arr := []byte(s)
    fmt.Printf("%d\n",maxv)
}


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

2 字符串

var a = []byte("hello boy")   // string转换字符数组
var b = string(a)             // 字符数组转String

• go中string是不可变的。

可变字符串

• 类似于Java中的StringBuilder
• 需要依赖strings包

var b strings.Builder
b.WriteString("ignition")  // 写入字符串
b.Len()                    // 返回字符串长度
b.String()                 // 返回String类型字符
b.WriteByte(c byte)        // 写入单个字符

3 数组（slice)

数组使用

runtime/slice.go源码

数组和切片区别:

• The built-in function make(T, args) serves a purpose different from new(T). It creates slices, maps, and channels only, and it returns an initialized (not zeroed) value of type T (not *T)

1)切片时指针类型，数组是值类型 
2)数组的长度是固定的，而切片不是（切片是动态的数组）
3)切片比数组多一个属性：容量（cap) 
4)切片的底层是数组

数组定义

var [3]int              // 定义维度为3的int整型数组    

排序

排序需要引入官方提供的sort包,提供了以下函数：

func Ints(x []int)         // 对整型数组进行升序排序
func Float64s(x []float64) // 对浮点数组进行升序排序
func Strings(x []string)   // Strings sorts a slice of strings in increasing order.
func Slice(x any, less func(i, j int) bool)    // 对slice进行排序，需要自定义bool函数

对自定义结构体排序

• 要实现Less方法（Sort sorts data in ascending order as determined by the Less method. It makes one call to data.Len to determine n and O(n*log(n)) calls to data.Less and data.Swap. The sort is not guaranteed to be stable.）

func Sort(data Interface)    

// 实例：自定义的结构体基于属性v排序
type pair struct{
    op byte
    v int
}
sort.Slice(arr,func(i,j int) bool{
        return arr[i].v < arr[j].v
})

自定义排序规则的两种方法

二维slice的定义

arr := make([][]int, N) 
for i := range arr { arr[i] = make([]int, 3) } 
----------------------------------------------
for i := 1;i <= 3;i++

slice的拷贝

a := b[:]     // 浅拷贝，共享内存
========================================
b := make([]type,len(b)
copy(a,b)                // 深拷贝                
=========================================

4 math package

定义的常量

MaxInt32  = 1<<31 - 1
MinInt32  = -1 << 31
MaxInt64  = 1<<63 - 1
MinInt64  = -1 << 63

5 map的使用

kvs := make(map[string]int,100)      // 定义一个key是string,value是int类型的map
for k,v := range kvs{}               // 通过range关键字遍历map的key和valu
kvs[k]++                             // 让value增1

6 使用slice建立图的邻接表

    g := make([][]int,N+1)
    for i := 1;i <= N;i++{
        g[i] = make([]int,0,10)   //0 表示实际动态数组长度，10表示初始化的容量，len（slice)获取的是0
    }
g[i] = append(g[i],1)             // 为动态数组添加元素

原文地址：http://www.cnblogs.com/kfcuj/p/16879420.html