Levon's Blog

微信: L6241425

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 3.4k 阅读时长 ≈ 3 分钟

1. 云服务器带宽

1.1 定义

云服务器的带宽就像是连接服务器的“公路”的宽度。

  • 公路越宽（带宽越大）：同一时间内能通过的“车辆”（数据）就越多，数据传输速度就越快。
  • 公路越窄（带宽越小）：同一时间内能通过的“车辆”就越少，数据传输速度就越慢，在高“车流”（高访问量）时会发生“堵车”（访问延迟、卡顿）

技术定义：带宽是指在单位时间内，网络线路能够传输的数据量的最大值。通常用 Mbps（Megabits per second，兆比特每秒）作为单位。

例如，一个 5Mbps 带宽的服务器，理论上意味着它每秒钟最多可以传输 5兆比特的数据。

阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 2k 阅读时长 ≈ 2 分钟

Object 和 Function

首先在 javascript 中 我们要明确Object 和 Function两个概念:

  • 万物皆对象

  • 所有对象都是函数创建出来

仔细琢磨这两句话, 其实说的 Object 和 Function 是一个鸡生蛋还是蛋生鸡的问题. 为什么这么讲呢? 因为函数也是一个对象, 但对象又是函数创建出来的.

其实原型链的一切江湖恩怨都是围绕着Function和Object两大家族展开的.

阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 4.3k 阅读时长 ≈ 4 分钟

“一句话”类比

图片格式就像是打包和运送货物的不同类型的箱子：

  • JPEG 像一个真空压缩袋，专门装衣服（照片），能把体积压到最小，但衣服拿出来会有点皱（质量有损）。
  • PNG 像一个带格子的精密仪器箱，专门装易碎品（Logo、图表），保护得完好无损（质量无损），但箱子本身又大又重。
  • SVG 则根本不是箱子，而是一张“如何制作”的图纸，你可以根据图纸随时用原材料制作出任意大小、完美无瑕的物品（矢量图形）。
阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 5k 阅读时长 ≈ 5 分钟

想在公网上实现视频通信，需要下面3个核心元素：

  1. 一个是NAT穿透服务器(ICE Server)，实现内网穿透。
  2. 基于WebSocket的信令服务器(Signaling Server)，用于建立点对点的通道。
  3. Web客户端。通过H5的WebRTC特性调用摄像头，进行用户交互。
阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 4.5k 阅读时长 ≈ 4 分钟

1. NAT

1.1 介绍

NAT(Network Address Translation)指的是网络地址转换。

网络分为私网和公网两个部分，NAT网关设置在私网到公网的路由出口位置，私网与公网间的双向数据必须都要经过NAT网关。

组织内部的大量设备，通过NAT就可以共享一个公网IP地址，解决了IPv4地址不足的问题。同时NAT也起到隐藏内部设备，安全防护的作用。

下图所示，有两个组织，每个组织的NAT分配一个公网IP，分别是1.2.3.4以及1.2.3.5。

img
阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 1.4k 阅读时长 ≈ 1 分钟

1. 动态规划

看个小故事:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
*writes down "1+1+1+1+1+1+1+1 =" on a sheet of paper*

"What's that equal to?"

*counting* "Eight!"

*writes down another "1+" on the left*

"What about that?"

*quickly* "Nine!"

"How'd you know it was nine so fast?"

"You just added one more"

"So you didn't need to recount because you remembered there were eight!Dynamic Programming is just a fancy way to say 'remembering stuff to save time later'"
阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 1.6k 阅读时长 ≈ 1 分钟

1. LRU 缓存机制(中等)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
type LRUCache struct {
    Capacity int
    Map map[int]int
    List []int
}


func Constructor(capacity int) LRUCache {
  return LRUCache{
        Capacity : capacity,
        Map : make(map[int]int, 0),
        List : make([]int, 0),
    }
}

func DelKey(a []int, key int) []int{
    for i := 0; i < len(a); i++ {
		if a[i] == key {
            return append(a[:i], a[i+1:]...)
		}
	}
	return a[1:len(a)]
}

func (this *LRUCache) Get(key int) int {
    if val, ok := this.Map[key]; ok{
        this.List = DelKey(this.List, key)
        this.List = append(this.List, key)
        return val
    }
    return -1
}


func (this *LRUCache) Put(key int, value int)  {

    if _, ok := this.Map[key]; ok{
        this.Map[key] = value
        this.List = DelKey(this.List, key)
        this.List = append(this.List, key)
        return 
    }

    if len(this.Map) >= this.Capacity{
        delKey := this.List[0]      
        this.List = DelKey(this.List, key)
        delete(this.Map, delKey)
    }

    this.Map[key] = value
    this.List = append(this.List, key)
}
阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 5.4k 阅读时长 ≈ 5 分钟

1. 查找

1 二分查找(简单)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"

func search(nums []int, target int) int {
	left := 0
	right := len(nums) - 1

	for left <= right { // 这里是小于等于
		mid := (left + right) / 2
		if nums[mid] > target {
			right = mid - 1
		} else if nums[mid] < target {
			left = mid + 1
		} else {
			return mid
		}
	}
	return -1 // 找不到 return -1
}

func main() {
	arr := []int{1, 3, 11, 150, 201, 800}
	fmt.Println(search(arr, 11)) // 2(下标)
}

阅读全文 »

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 744 阅读时长 ≈ 1 分钟

+ 翻转单词顺序(简单)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func reverseWords(s string) string {

    s = strings.TrimSpace(s)

    j := len(s)-1
    i := j
    res := []string{}
    for i >= 0 {
        for i >= 0 &&  s[i] != ' '{
            i--
        }
        res = append(res, s[i+1:j+1])
        for i >= 0 &&  s[i] == ' '{
            i--
        }
        j = i

    }

    return strings.Join(res," ")
}

+ 罗马数字转整数(简单)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func romanToInt(s string) int {
  res := map[string]int{
        "I": 1,
        "V": 5,
        "X": 10,
        "L": 50,
        "C": 100,
        "D": 500,
        "M": 1000,
    }
    sum := 0
    for i := 0; i < len(s); i++ {
        val := res[string(s[i])]
        if i < len(s)-1 && val < res[string(s[i+1])] {
            sum -= val
        } else {
            sum += val
        }
    }
    return sum
}

发表于 更新于 分类于 ， 阅读次数： Waline： 本文字数： 9.1k 阅读时长 ≈ 8 分钟

两个套路，一个是递归遍历二叉树traverse() 无返回值 ，一个是分解处理子数，有返回值。

综上，遇到一道二叉树的题目时的通用思考过程是：

1、是否可以通过遍历一遍二叉树得到答案？如果可以，用一个 traverse 函数配合外部变量来实现。

2、是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值。

3、无论使用哪一种思维模式，你都要明白二叉树的每一个节点需要做什么，需要在什么时候（前中后序）做。

阅读全文 »
0%