数据结构与算法系列

1空间复杂度

1.java中常见占内存：

 2.一字节byte等于8位bit

1B（byte，字节）= 8 bit

1KB（Kibibyte，千字节）=1024B= 2^10 B；

1MB（Mebibyte，兆字节，百万字节，简称“兆”）=1024KB= 2^20 B；

1GB（Gigabyte，吉字节，十亿字节，又称“千兆”）=1024MB= 2^30 B；

3.计算机访问内存的方式都是一次一个字节：（一字节等于8位）

4.一个引用需要8个字节表示：

2算法分析-时间复杂度分析

1.时间复杂度分析分为：

（1）事后复杂度分析：

（2）事前复杂度分析：

2.函数渐进增长：

随着输入规模的增大，算法的常数操作可以忽略不记

随着输入规模的增大，与最高次项相乘的常数可以忽略

最高次项的指数大的，随着n的增长，结果也会变得增长特别快

结论：

（1）算法函数中常数可以忽略

（2）算法函数中最高次幂的常数因子可以忽略

（3）算法函数中最高次幂越小，算法效率越高

3.算法时间复杂度：

大O记法：

T（n）=O（f(n)）

执行次数=执行时间

4.大O记法的规则：

假如算法执行3次，则时间复杂度大O记法为：O(1)

假如算法执行n+3次，则时间复杂度大O记法为：O(n)

假如算法执行n^2+2次，则时间复杂度大O记法为：O(n^2)

5.算法中常见的大O阶：

（1）线性阶：单层for循环

（2）平方阶：两层嵌套循环

（3）立方阶：三层嵌套循环

（4）对数阶：时间复杂度为：O(logn)

 (5)常数阶：时间复杂度O(1)

5.时间复杂度总结：

 6.函数调用的时间复杂度分析：

（1）之前，我们分析的都是单个函数内算法代码的时间复杂度，接下来我们分析函数调用过程中时间复杂度：

（2）最坏情况

3 leetcode题目：

1【每日一练】Golang---leetcode算法----两数之和

package main

import "fmt"

func main() {
	nums := []int{3, 2, 4}
	target := 6
	result := twoSum(nums, target)
	fmt.Println("符合条件的元素索引为", result)

	result2 := twoSum2(nums, target)
	fmt.Println("符合条件的元素索引为", result2)

}

//暴力算法:时间复杂度O(n^2);空间复杂度：1
func twoSum(nums []int, target int) []int {
	if len(nums) < 2 {
		return nil
	}
	for i := 0; i < len(nums); i++ {
		for j := i + 1; j < len(nums); j++ {
			if nums[i]+nums[j] == target {
				return []int{i, j}
			}
		}
	}
	return nil
}

//哈希表算法:时间复杂度O(n);空间复杂度：n -----在go里面，map数据结构就是哈希表的一种实现
func twoSum2(nums []int, target int) []int {
	if len(nums) < 2 {
		return nil
	}
	hash := make(map[int]int)
	for i := 0; i < len(nums); i++ {
		index, ok := hash[target-nums[i]]
		if ok {
			return []int{index, i}
		} else {
			hash[nums[i]] = i
		}
	}
	return nil
}

下图为两种算法耗时对比