slice可以动态添加项（使用append()函数），但是没有删除项的函数。变通方法，可以使用slice重新组合的方式删除一个或多个项，slice是引用类型，存的是指针，性能上不会有太多影响，示例如下：package mainimport "fmt"func main() { s := []int{11, 22, 33, 44, 55, 66} // 原始slice i := 2 // 待删除项索引 s = append(s[:i], s[i+1:]...) // 最后面的“...”不能省略 fmt.Println(s) // 数据结果 [11 22 44 55 66]} 有人回答的很好： 这样是可以实现。不过从slice这种数据结构来看，本身并不适合做删除操作。抛开语言，只谈数据结构，我们...阅读全文
1）swift，貌似官网的推荐 2）extern "C" 我使用后者，用起来比较爽，上代码 c.h 1 #pragma once 2 3 #ifdef __cplusplus 4 extern "C" { 5 #endif 6 void test(); 7 #ifdef __cplusplus 8 } 9 #endif c.c 1 #include "cplus.hpp" 2 #include "c.h" 3 4 void test() { 5 A *a = new B(); 6 a->test(); 7 } cplus.hpp 1 #pragma once 2 3 class A { 4 public: 5 virtual void test(); 6 }; 7 class B: publ...阅读全文
我们知道defer会在函数结束时执行，那么首先思考两个问题： 如果有多个defer，执行顺序是怎样的？ defer是在return之前还是之后执行的？如果defer执行的内容对返回值进行了修改，return结果是否会改变？ 多个defer的执行顺序 通过下面这个个例子，我们看下defer的执行顺序： package main import ( "fmt" ) func main() { defer fmt.Println("main defer1") test() defer fmt.Println("main defer2") } func test() () { defer func() { fmt.Println("test defer1") }() defer func() { fm...阅读全文
``` func main() { src := `{"iss":"magic-ios-1.0.0","iat":1487000471,"jti":"4861ed10","rbd":"dbac2c5f","uri":"/auth/hello","ttu":""}` var params interface{} err := json.Unmarshal([]byte(src), ¶ms) if err != nil { fmt.Printf("%v\n", err) return } p, _ := json.Marshal(params) fmt.Printf("%v, %s\n", params, p) } ``` 问题描述： ...阅读全文
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列查找过程：首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。算法要求：1.必须采用顺序存储结构。2.必须按关键字大小有序排列。要求：请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ,输入一个数看看该数组是否存 在此数,并且求出下标,如果没有就 ...阅读全文
import ( "errors" ) //循环队列结构体(顺序存储) type CirularQueue struct { elem []ElemType //储存的数据 front int //头指针 rear int //尾指针 } //初始化循环队列 func InitCQueue() *CirularQueue { cqueue := new(CirularQueue) cqueue.elem = make([]ElemType, MAXSIZE) cqueue.front = 0 cqueue.rear = 0 return cqueue } //清空循环队列 func (cqueue *CirularQueue) ClearCQueue() { cqueue.front = 0...阅读全文
package testPackage func init() { println("init one") } func init() { println("init two") } ----------------------------------------------------------------------------------------- package main import ( _ "balabala/output/testPackage" "fmt" ) func main() { fmt.Println("???") fmt.Println("???") } func init() { println(1111) } func init() { println(...阅读全文
package main import ( "errors" "fmt" ) //循环队列 const ( MaxSize int = 20 // 存储空间初始分配量 ) type QElemType int // QElemType类型根据实际情况而定，这里假设为int // 循环队列的顺序存储结构 type SqQueue struct { data [MaxSize]QElemType front int //头指针 rear int //尾指针 } //初始化队列 func (q *SqQueue) InitQueue() { q.front = 0 q.rear = 0 } //清空队列 func (q *SqQueue) ClearQueue() { q.front = 0 q....阅读全文
```go func main() { runtime.GOMAXPROCS(1) var wg sync.WaitGroup wg.Add(2) go func() { defer wg.Done() fmt.Println("a") }() go func() { defer wg.Done() fmt.Println("b") }() wg.Wait() } ``` 为什么总是先打印b后打印a, groutine首次执行有顺序吗...阅读全文
package main import ( "fmt" "sync" "time" ) var waiter sync.WaitGroup func print5(i int) { j := i for j < i+5 { fmt.Println(j) j++ } waiter.Done() } func main() { fmt.Println("Start print 75") waiter = sync.WaitGroup{} waiter.Add(15) for i := 1; i < 75; i += 5 { go print5(i) time.Sleep(1 * time.Nanosecond) } waiter.Wait() fmt.Println("End print 75"...阅读全文
目的 因为最近工作中碰到了一些关于数据结构的问题，发现有些生疏了，所以想重新自己再理一遍，就当是给自己的记录，之所以用golang主要也是因为对goalng比较感兴趣，写起来也比较顺手。本意也不是想分享关于什么是数据结构，因为这种概念性的东西没有什么太大意义，其实最重要的是让自己能看懂自己写了些什么，但是代码中写了非常详细的注释，所以基本都是以代码为主 线性表之顺序存储结构 以下代码是线性表中的顺序存储结构，基本略去了些容错的考虑，还是以实现功能为主 package main //线性表中的顺序存储结构 import ( "fmt" ) // 线性表中存储的数据类型 type Elem int type SqList struct { //最大长度 maxsize int // 当前长度 l...阅读全文
看介绍说，go的select与switch类似。但其实有很大不同 switch执行是顺序的，而select是随机选择： package main import ( "fmt" ) func main() { c1:=make(chan int,1024) c2:=make(chan int,1024) for i:=0;i<1000;i++{ c1<-1 c2<-1 fmt.Println("i===",i) select{ case <-c1: fmt.Println("from c1") case <-c2: fmt.Println("from c2") } } } 结果： i=== 0 from c1 i=== 1 from c2 i=== 2 from c1 i=== 3 from ...阅读全文
package main import ( "fmt" "sync" ) func printOdd(ch chan byte, wg *sync.WaitGroup) { defer wg.Done() for i := 1; i <= 9; i += 2 { fmt.Println(i) ch <- 1 <-ch } } func printEven(ch chan byte, wg *sync.WaitGroup) { defer wg.Done() for i := 2; i <= 10; i += 2 { <-ch fmt.Println(i) ch <- 1 } } func main() { ch := make(chan byte) var wg sync.WaitGroup...阅读全文
c++ extern "c" c.h 1 #pragma once 2 3 #ifdef __cplusplus 4 extern "C" { 5 #endif 6 void test(); 7 #ifdef __cplusplus 8 } 9 #endif c.c 1 #include "cplus.hpp" 2 #include "c.h" 3 4 void test() { 5 A *a = new B(); 6 a->test(); 7 } cplus.hpp 1 #pragma once 2 3 class A { 4 public: 5 virtual void test(); 6 }; 7 class B: public A { 8 public: 9 void test();...阅读全文
/*按顺序打印数字/import ("fmt""sync""time") var Number struct {num intlock sync.RWMutex} var ch = make(chan int) func main() {// fun 1for i := 0; i < 10; i++ {go PirntNum()}time.Sleep(2 * time.Second)fmt.Println("------------------------")// fun2for i := 0; i < 10; i++ {go print2(i)ch <- i}} func PirntNum() {Number.lock.Lock()fmt.Println(Number.num)Number...阅读全文
为什么每次运行结果都一样的顺序 index: 4 ; value: 5 index: 0 ; value: 1 index: 1 ; value: 2 index: 2 ; value: 3 index: 3 ; value: 4 ...阅读全文
package main import "fmt" func fibonacci(c, quit chan int) { x, y := 1, 1 for { select { case c <- x: x, y = y, x+y case <-quit: fmt.Println("quit") return } } } func main() { c := make(chan int) quit := make(chan int) go func() { for i := 0; i < 10; i++ { fmt.Println(<-c) } quit <- 0 }() ...阅读全文
设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) -- 将元素 x 推入栈中。 pop() -- 删除栈顶的元素。 top() -- 获取栈顶元素。 getMin() -- 检索栈中的最小元素。 示例: MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.getMin(); --> 返回 -3. minStack.pop(); minStack.top(); --> 返回 0. minStack.getMin(); --> 返回 -2. 使用两个栈来实现，一个栈来按顺序存储push进来的数据，另...阅读全文
总结一下init方法的定义和执行顺序，做个笔记 在同一个go文件中，可以定义多个init方法 在同一个文件中的多个init方法，按照在代码中编写的顺序依次执行不同的init方法 在同一个package中，可以多个文件中定义init方法 在同一个package中，不同文件中的init方法的执行按照文件名先后执行各个文件中的init方法 // A/a1.go package A func init() { println("a1") } var A1 = "" // A/a2.go package A func init() { println("a2") } var A2 = "" // B/b1.go package B func init() { println("b1") } var B...阅读全文
golang不定长传参，三个点... 可以很灵活的传入多个参数，给两个例子，一看就明白了 1、int类型不定长传参 package main import "fmt" func main() { fmt.Println(Sum(1, 4, 6, 7, 8, 9, 100, 200)) } func Sum(numbers ...int) int { result := 0 for _, n := range numbers { result += n } return result } go run test1.go 335 2、map类型不定长传参 package main import "fmt" func main() { fmt.Println(SumMap(map[string]s...阅读全文
package main import ( "fmt" "sync" ) func main() { var wg sync.WaitGroup print5 := func(c *chan int, i int) { defer wg.Done() for j := i; j < i+5; j++ { *c <- j } } for i := 1; i < 75; i += 5 { wg.Add(1) ch := make(chan int, 5) go print5(&ch, i) for j := 0; j < 5; j++ { fmt.Println(<-ch) } } wg.Wait() } 输出如下， image.pn...阅读全文
分析该缓冲通道wrote和read的数字的顺序 package main import ( "fmt" "time" ) func write(ch chan int) { for i := 0; i < 5; i++ { ch <- i fmt.Println("successfully wrote", i, "to ch") } close(ch) } func main() { ch := make(chan int, 2) go write(ch) time.Sleep(2 * time.Second) for v := range ch { fmt.Println("read value", v, "from ch") time.Sleep(2 * time.Second) } }...阅读全文
