go语言学习 11/5/2019

闭包非递归斐波那契：

package main

import "fmt"

func main() {
	var result = fibonacci()
	for i := 0; i <= 10; i++ {
		fmt.Printf("fibonacci(%d) is: %d\n", i, result(i))
	}
}

func fibonacci() func(int) int {
	a = 0

	return func(delta int) int {
		defer func() {
			a,b = b, a+b
		}()
		return b
	}
}

 斐波那契闭包调试代码：

func fibonacci() func(int) int {
	a,b := 0,1

	return func(delta int) int {
		defer func() {
			a,b = b, a+b
		}()
		_, file, line, _ := runtime.Caller(1)
		log.Printf("%s:%d", file, line)
		return b
	}

}

　　

 

 

 可以看到for循环中闭包调试的代码并不是同步的，中间的原理就不得而知了

 

计算运行时间

start := time.Now()
fibonacci()
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)

　　快速排序：

func quickSort(nums []int,left,right int) {
	if left >= right{
		return
	}
	index :=partition(nums,left,right)
	quickSort(nums,left,index - 1)
	quickSort(nums,index + 1,right)
}
func partition(nums []int,left,right int) int{
	baseNum := nums[left]
	for left < right{
		for (nums[right] >= baseNum && right > left){
			right--
		}
		nums[left] = nums[right]
		for (nums[left] <=baseNum && right > left) {
			left++
		}
		nums[right] = nums[left]
	}
	nums[right] = baseNum
	return right
}

　　

-给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

func twoSum(nums []int, target int) []int {
	var mapNeed map[int]int
	mapNeed = make(map[int]int)

	for num0:=0;num0<=len(nums);num0++{
		var num = target - nums[num0]
		if v,ok :=mapNeed[num];ok{
			return []int{v,num0}
		}else{
			mapNeed[nums[num0]]=num0

		}
	}
	return []int{}
}

　　

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

var c int
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
	if l1==nil&&l2==nil&&c==0{
		return nil
	}
	if l1!=nil{
		c+=l1.Val
		l1=l1.Next
	}
	if l2!=nil{
		c+=l2.Val
		l2=l2.Next
	}
	var cur ListNode
	cur.Val= c%10
	c=c/10
	cur.Next=addTwoNumbers(l1,l2)
	return &cur
}

　　给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度

func lengthOfLongestSubstring(s string) int {
	var maxsize,base int
	var dict = [256]int{}
	for key:=0;key<len(s);key++{
		var i = s[key]
		if dict[i] >base{
			base = dict[i]
		}
		dict[i] = key + 1
		if maxsize<key-base+1{
			maxsize	 =  key-base+1
		}
	}
	return maxsize
}