算法相关

·  阅读 203

算法是解决问题的一系列步骤,使用复杂度来衡量算法的效率。时间复杂度(time complexity)就是指令执行的次数,也就是执行消耗的时间。空间复杂度(space complexity)就是消耗存储空间。

创新思维: 1、用5升、7升桶获取6升水。首先,用7升桶装满水,倒入5升桶,剩余2升。5升倒掉,2升倒入5升桶。然后,7升桶装满水,倒入5升倒满,7升桶剩余4升水。5升倒掉,4升倒入5升桶。最后,7升桶装满,倒满5升,7升桶剩余6升水。

使用大O表示法估算时间复杂度:忽略常数、系数、低阶。常数估算为O(1);n+3估算为O(n);n^2+n估算为O(n^2); n^3+n^2估算为O(n^3);对数估算为O(logn);n+nlogn估算为O(nlogn);2^n估算为O(2^n)。 常见的复杂度比较:O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)。n代表数据规模。多个数据规模 O(n+k)。一般情况下,均摊复杂度等于最好复杂度。 常见的时间复杂度:递归复杂度是O(2^n),类似二叉树,1+2+4+8+….=2^0+2^1+2^2+2^3+…+2^n=2^(n+1)-1 => O(2^n); 求第N个斐波那契数迭代法复杂度为O(n),一个for循环;使用数学公式复杂度为O(1);while ((n=n/2) > 0) 执行次数log2^n;

(数学计算:logn是以10为底n的对数,log2^n = log2^9 * log9^n,所以log2^n、log9^n都转换为:常数*logn;) (常见的执行次数计算:while ((n=n/2) > 0) {} ,除了多少次2,执行次数=log2^n, log 以2为底n的对数,如果是除以5,就是以5为底。2的多少次方等于n,就是以2为底n的对数,O(logn)。)

递归: 是为了简化解决问题的思路,让代码更加简洁,而不是为了求得最优解。 思想:拆解问题,大规模问题拆解为小规模问题,小规模问题变成更小规模问题。很多链表、二叉树相关的问题可以使用递归。 套路:先明确函数的功能,明确原问题和子问题的关系,。 递归调用的空间复杂度 = 递归深度 * 每次调用所需要的辅助空间。 二叉树遍历:空间复杂度就是O(h),最坏情况,就是链表h=n,O(n)。

求和公式:1+2+3+……+n = n*(1+n) / 2 : func sum(n int) { if n<=1 return n Return n + sum(n-1) }

func sum(n int) { if n<=1 return n return (n + 1) * n >> 2 }

求第N个斐波那契数 0 1 1 2 3 5 8 13….

算法一使用递归:
n<=1 return n;
fib(n) = fib(n-1)+ fib(n-2);
return fib(n);
复杂度 1+2+4+8+….=2^0+2^1+…….+2^n = 2^(n+1)-1=>O(2^n),二叉树,后面是前面的两倍。
算法二使用迭代法:
first := 0; second := 1;
for I:=0; I<n-1; I++ {
sum := first + second; first = second; second = sum;
} return second;。
算法三使用数学公式实现复杂度O(1)。

递归会出现很多重复计算,如何避免重复计算:可以使用数组来进行优化,存储index的计算,每个index只计算一次。时间复杂度可以优化到O(n),空间复杂度还是O(n),递归的深度*O(1)=O(n)。

func fib(n int) int {
//迭代
if n == 0 {
return 0
}
first := 0 second := 1 for i:=1; i<n; i++ {
sum := first + second
first = second
second = sum
}
return second
}

// 递归 func fib1(n int) int {
if n <= 1 {
return n
}
return fib(n-1) + fib(n-2)
}

动态数组:会造成内存空间大量浪费,可以使用缩容技术解决,缩容比例设置不当会导致复杂度震荡,但开辟、销毁内存空间的次数相对较少;扩容问题,底层数组空间不足,需要对底层数组扩容;删除、插入元素会出现元素内存挪动;清空数组要把所有对象元素置为nil;元素内存地址是连续的。

扩容:底层数组容量已经存满,需要重新创建一个新的更大容量的数组,把之前数组的元素挪动到新数组中,扩容可以是旧容量的1.5倍,即:oldCap + (oldCap >> 1),右移1就是0.5倍。X/2等价于x>>1。查看a的第b个数值为多少,(a>>b)&1。

缩容:如果内存使用比较紧张,动态数组有比较多的剩余空间,可以考虑进行缩容操作。如果扩容倍数、缩容时机设计不得当,有可能会导致复杂度震荡。

(动态数组接口:clear、size、isEmpty、contains(e)、add(e)、get(index)、set(index, e)、add(index, e)、remove(index)、indexOf(e)、arrayList(capacity)。)

NSMutableArray 底层包含:_used计数、_list缓冲区指针、_size缓冲区的大小、_offset是缓冲区的数组的第一个元素索引。__NSArrayM 使用了环形缓冲区 circular buffer。在头尾两端插入或删除不用移动内存;访问使用index+offset来获取值;在中间插入,会根据最少移动内存的方式插入;删除中间元素也是会最少移动内存的方式移动内存;删除头部或尾部元素不会进行内存移动;环形缓冲区满了就会进行扩容。使用链表来实现环形缓冲区比较好,扩容的时候不需要进行大量的内存移动,使用数组的话扩容的时候就需要大量内存移动。

__CFDictionary 结构体:内部有_keys、_values分别存储keys和values两个数组,数组的长度一致。根据key计算出哈希值h,空箱子数组容量n,计算index=h%n。hash冲突使用拉链法或寻址法解决。哈希表扩容,需要重哈希rehash。

1、原地删除有序数组中的重复项:给你一个有序数组nums,原地删除重复出现的元素,使每个元素只出现一次,返回删除后数组的新长度。不要使用额外的数组空间,必须在原地修改输入数组并在使用O(1)额外空间的条件下完成。 利用双指针。判断len(nums)是否为0。初始化pre指针pre=0,for循环遍历数组元素,判断nums[pre] != nums[i], pre++ , 就交换:nums[pre], nums[i] = nums[I], nums[pre]。遍历结束,返回长度 pre+1。

func removeDuplicates(nums []int) int {
if len(nums) == 0 {
return 0
}\

left := 0
for right:=0; right<len(nums); right++ {
    if nums[left] != nums[right] {
        left++
        nums[left] = nums[right]
    }
}
return  left+1
复制代码

}

删除有序数组中的重复项II:原地,每个元素最多出现两次。

func removeDuplicates(nums []int) int {
pre := 0
for i:=0; i<len(nums); i++ {
if pre < 2 || nums[pre-2] != nums[i] {
nums[pre] = nums[i]
pre++
}
}
return pre
}

2、整数数组nums,判断是否存在重复元素。存在就返回true。 借助字典map。初始化字典dict := make(map[int]int),遍历nums,判断字典中是否包含nums[I]为key的元素,_, ok := dict[nums[k]],如果没有就nums[i]为key,i为value存储到字典dict中。如果有返回true,就代表有重复。最后也没有查找到就返回false。

func containsDuplicate(nums []int) bool {
dict := make(map[int]int)
for i:=0; i<len(nums); i++ {
_, ok := dict[nums[i]]
if ok {
return true
} dict[nums[i]] = i
}
return false
}

借助set集合,把数组元素存储到set集合中,如果有重复,会被覆盖。最后比较set的长度和nums的长度是否相等,如果不等就有重复。

存在重复元素:给定一个整数数组和一个整数k,判断数组中是否存在两个不同的索引i和j,使得nums[i] = nums[j],并且i和j差的绝对值至多为k。

func containsNearbyDuplicate(nums []int, k int) bool {
dict := make(map[int]int)
for i:=0; i<len(nums); i++ {
v, ok := dict[nums[i]]
if ok {
if i - v <= k {
return true
}
}
dict[nums[i]] = i
}
return false
}

3、买卖股票的最佳时机:一个数组prices,prices[i]代表第i天的股票价格。设计一个算法能获取最大利润。

只能买卖一次。选择某一天买入这只股票,并选择在未来的某一天卖出该股票。计算能获取的最大利润。

func maxProfit(prices []int) int {
minPrice := prices[0]
profit := 0
for i:=1; i<len(prices); i++ {
if prices[i] < minPrice {
minPrice = prices[i]
} else if profit < prices[i] - minPrice {
profit = prices[i]-minPrice
}
}
return profit
}

可以尽可能的完成更多的交易,多次买卖股票,必须在再次购买前出售掉之前的股票。 使用贪心算法。计算的过程并非买卖的过程。初始化利润profit:=0。遍历prices,初始化I:=1,如果prices[I]>prices[i-1],那么就profit = profit + prices[I]-prices[I-1]。最终返回利润 profit.

func maxProfit(prices []int) int {
//贪心算法 profit := 0
for i:=1; i<len(prices); i++ {
if prices[i] > prices[i-1] {
profit = profit + prices[i] - prices[i-1]
}
}
return profit }

4、旋转数组:一个数组,将数组元素右移k个位置,其中k是非负数。空间复杂度为O(1)的原地算法。 解法一:遍历。复杂度 O(kn)。右移一位,就是把尾部元素插入到0的位置,也就是暂存last元素,然后从尾部遍历挪动其他元素,最后赋值暂存元素到首元素 nums[0]=last。 解法二:利用翻转。先对整个数组进行翻转,然后再对0到k元素,k到last元素分别进行翻转。

func rotate(nums []int, k int) {
n := k % len(nums)
reverse(nums)
reverse(nums[:n])
reverse(nums[n:])
}

数组元素翻转:遍历数组nums,结束条件 len(nums)>>1 。 //翻转

func reverse(nums []int) {
l := len(nums);
for i:=0; i<(l>>1); i++ {
nums[i],nums[l-i-1] = nums[l-i-1], nums[i]
} }

5、只出现一次的数字。一个非空数组nums,除了某个元素只出现过一次,其他每个都出现两次。找出只出现一次的元素。具有线性时间复杂度O(n)。不借助外部存储空间。 异或^运算:0^b=b;0^0=0; 1^1=0; a^a=0;
满足交换律和结合律:a^b^a=(a^a)^b=b。 声明value=0,遍历数组,数组元素^value,赋值给value。最终的值就是要查找的元素。 相同元素异或等于0;一个非0元素异或上0等于它自己;异或遵循交换律和结合律;

func singleNumber(nums []int) int {
n := 0
for _, v := range nums {
n ^= v
}
return n
}

6、加一。一个整数数组nums,表示一个非负整数,在该数的基础上加1。

7、移动零。整数数组nums,将所有的0移动到末尾,同时保持非0元素的稳定性,即相对顺序。 双指针,left,right,循环条件right<length,nums[right] != 0 交换left、right并 left++。外层right++。

8、两数之和。整数数组nums,整数目标值target,在数组nums中找出和为目标值的两个整数,并返回它们的下标。 利用字典。遍历数组,获取元素值v,计算出x=target-v,

9、两个数组的交集。给定两个数组,计算它们的交集。nums1=[12341], nums2=[2116], 交集就是 [112]。可以有多个重复元素。 利用字典。先遍历len较小的数组nums1,把元素存储到字典中,key是元素值,value是出现的次数,dict[v]++。然后遍历nums2,如果元素在dict中存在,且值取出来是大于0的,那么就存储到结果数组result中,然后对dict[v]—。

func intersect(nums1 []int, nums2 []int) []int {
if len(nums1) > len(nums2) {
return intersect(nums2, nums1)
}
dict := make(map[int]int)
for _, v := range nums1 {
dict[v]++
}
result := make([]int, 0)
for _, v := range nums2 {
i, ok := dict[v]
if ok && i>0 {
result = append(result, v)
dict[v]--
}
}
return result
}

两个数组的交集。输出结果每个元素唯一。关键map删除元素:delete(dict, v)。 func intersection(nums1 []int, nums2 []int) []int { if len(nums1) > len(nums2) { return intersection(nums2, nums1) } dict := make(map[int]int) for i,v := range nums1 { dict[v] = i } result := make([]int,0) for _,v := range nums2 { _, ok := dict[v] if ok { result = append(result, v) delete(dict, v) } } return result }

10、山脉数组的峰顶索引。找出峰值元素:一个数组,元素先升序,再降序,超出其中的峰值元素。 利用二分搜索,迭代遍历,初始化left=0,right=len-1,然后遍历,结束条件left<right。mid = (left + right) >> 1。判断如果是nums[mid] > nums[mid+1] 那么就right= mid。否则 left = mid + 1,最终返回left。

func peakIndexInMountainArray(arr []int) int { // 时间复杂度:O(logn) left,right := 0, len(arr)-1 for left < right { mid := (left+right) >> 1 if arr[mid] > arr[mid+1] { right = mid } else { left = mid + 1 } } return left }

func peakIndexInMountainArray(arr []int) int { // 时间复杂度:O(n) maxIndex := 0 for i:=0; i<len(arr); i++ { if arr[i] > arr[maxIndex] { maxIndex = i } }
return maxIndex }

func findPeakElement(nums []int) int { left, right := 0, len(nums)-1 for left < right { mid := (left + right) >> 1 if nums[mid] > nums[mid+1] { right = mid } else { left = mid + 1 } } return left }

二分搜索BinarySearch:有序整型数组nums和一个目标值target,写一个函数搜索nums中target,如果存在返回下标,否则返回-1。 12345 func search(nums []int, target int) int { // [left right) 区间的元素总个数 right-left     left, right := 0, len(nums)     for left < right {         mid := (right + left) >> 1         if nums[mid] == target { //问题:如果有多个重复的值,返回的下标是不固定的             return mid         } else if target < nums[mid] {             right = mid         } else {             left = mid+1         }     }     return -1 }

11、找出数组中比左边大比右边小的元素。该元素比在它左边的元素都大,比它右边的所有元素都小。 时间复杂度O(n)。 先从右往左遍历,求所有元素的右边最小数,存放到一个数组rightMin中。然后从左往右遍历判断当前元素是否大于左边元素,如果是则和右边最小数rightMin中元素比较,如果小于则满足条件存储到结果数组中。

func find(nums []int) []int { l := len(nums)

var rightMins = make([]int, l)
rightMin := nums[l-1]
for i:=l-1; i>=0; i-- {
    if nums[i] < rightMin {
        rightMin = nums[i]
    }
    rightMins[i] = rightMin
}
var result = make([]int, 0)
leftMax = nums[0]-1
for i:=0; i<l; i++ {
    if leftMax < nums[i] && nums[i] < rightMins[i] {
        leftMax = nums[i]
        result := append(result, nums[i])
    }
}
return result
复制代码

}

12、多数元素。长度为n的数组nums,找到其中多数元素。多数元素指在数组中出现次数大于[n/2]的元素。 多数元素大于n/2个,也就是比其他所有元素加起来还多。假设temp为众数,count为它出现的次数,当遇到和它不同的元素就count-1,相同元素就count+1,当count==0的时候,就转换count为当前元素,最终会temp会转换为多数元素。

// 方法一: func majorityElement(nums []int) int { // 时间复杂度O(n) 空间复杂度O(1) if len(nums) == 1 { return nums[0] } // 众数 temp := nums[0] count := 1 for i:=1; i<len(nums); i++ { if count == 0 { temp = nums[i] } if nums[i] == temp { count++ } else { count-- } } return temp }

// 方法二:先排序,再记录比较count `func majorityElement1(nums []int) int {

if len(nums) == 1 {
    return nums[0]
}

//排序
sort.Ints(nums)
//遍历
temp := nums[0]
count := 1
for i:=1; i<len(nums); i++ {
    if nums[i] == temp {
        count++
        if count > (len(nums)>>1) {
            return temp
        }
    } else {
        temp = nums[i]
        count = 1
    }
}
return -1
复制代码

}

13、乘积最大子数组。整数数组nums,找出数组中乘积最大的连续子数组。子数组最少包含一个数字。返回该子数组对应的乘积。

输入:[2,3,-2,4] 输出:6,子数组 [2,3] 输入:[-2,0,-1] 输出:0

func maxProduct(nums []int) int { imax, imin, max := nums[0],nums[0],nums[0] for i:=1; i<len(nums); i++ { if nums[i] < 0 { imax,imin = imin,imax } imax = maxFunc(imax * nums[i], nums[i]) //-2 * 3 -2 = -2 8 imin = minFunc(imin * nums[i], nums[i]) // -2 * 3 -2 = -6 -4 max = maxFunc(imax, max) // -2 } return max }

func maxFunc(x, y int) int { if x > y { return x } return y }

func minFunc(x, y int) int { if x > y { return y } return x }

字符串相关 : 1、一个字符串/a/b/../c/./d,是目录层级 .. 代表回到上一级,. 当前目录,b代表a的子目录。简化目录。先切割成数组,数组元素a、b、..、c、. 、d,然后遍历,查看元素如果是字母,直接入栈,如果是..,舍弃当前元素,并出栈,如果是. ,就舍弃当前元素。最终栈中的元素就是简化后的。

2、回文数。验证整数x是否是回文整数。

func isPalindrome(x int) bool { y := x p := 0 for y > 0 { tail := y%10 y = y/10 p = p*10 + tail } if p == x { return true } return false }

3、最长回文串。给一个字符串,包含大消息字母,找到通过这些字母构成的最长的回文串。区分大小写,返回长度。

无重复字符的最长子串: 涉及到次数,需要用到散列表。构造子串,散列表存储下标。涉及子串,考虑滑动窗口。

单向链表是链式存储数据的,使用多少就申请多少内存空间,不会造成内存空间的浪费。LinkedList成员size、first,first是指向头节点。每个节点都包含一个next指针,指向下一个节点(Node)。链表根据index查询节点复杂度 O(n),添加节点那一刻复杂度是 O(1),添加之前需要查找,整体复杂度是 O(n)。 虚拟头结点:在头结点head前面增加的结点,不存储数据。让代码更精简,统一所有节点的处理逻辑。

单向链表:插入、删除某个节点,需要找到这个节点的上一个节点;边界为空的情况:head头节点、尾结点、尾结点的前一个节点;遍历链表for(node!=nil) {node = node.next};删除单向链表中给定的某个节点:让下一个节点存储的值依次覆盖上一个节点存储的值,且去掉最后一个重复的节点。

单向链表使用场景:哈希表。

(可以引出二叉树,只有右子树的二叉树就是单向链表……)

1、翻转链表,使用迭代法:首先创建newHead=nil,遍历,创建temp并移动到head的next,接着head的next指向newHead,然后newHead移动到head,最后head移动到temp。 /**

  • Definition for singly-linked list.
  • type ListNode struct {
  • Val int
    复制代码
  • Next *ListNode
    复制代码
  • }

*/ func reverseList(head *ListNode) *ListNode { var newHead *ListNode var temp *ListNode for head != nil { temp = head.Next head.Next = newHead newHead = head head = temp } return newHead }

2、环形链表,判断链表是否有环:创建慢指针slow、快指针fast,慢指针slow走一步slow=slow.Next,快指针fast走两步fast=fast.Next.Next,当慢指针和快指针相遇slow==fast就说明链表有环。

func hasCycle(head *ListNode) bool { var slow *ListNode fast := head for fast != nil && fast.Next != nil { if slow == fast { return true } fast = fast.Next.Next

    if slow == nil {
        slow = head
    } else {
        slow = slow.Next
    }
}

return false
复制代码

}

3、移除链表元素,移除值为val的节点:创建newHead,last,遍历,如果newHead为空且head值不为val,初始化newHead、last为head,继续遍历head=head.Next,判断如果head的值不为val,设置last.Next为head,移动last到last的next,继续循环以上操作,最后处理尾结点。

func removeElements(head *ListNode, val int) *ListNode { newHead := &ListNode{} temp := newHead for head != nil { if head.Val != val { temp.Next = head temp = temp.Next } head = head.Next } temp.Next = nil

return newHead.Next
复制代码

}

删除中间节点:链表中的某个节点既不是头结点,也不是尾结点,就叫中间节点。 给一个中间节点,将此节点从链表中删除。 /**

  • Definition for singly-linked list.
  • type ListNode struct {
  • Val int
    复制代码
  • Next *ListNode
    复制代码
  • }

*/ func deleteNode(node *ListNode) { for node.Next != nil { node.Val = node.Next.Val

    if node.Next.Next == nil {
        node.Next = nil
        break
    }
    
    node = node.Next
}
复制代码

}

func deleteNode(node *ListNode) { *node = *node.Next }

4、删除排序链表中的重复元素,使得每个元素只出现一次:同删除链表元素差异判断条件,判断head的值不等于last的值,设置last.Next为head,移动last到last的next。

func deleteDuplicates(head *ListNode) *ListNode { newHead := &ListNode{} last := newHead for head != nil { if last == newHead { last.Next = head last = last.Next } else { if last.Val != head.Val { last.Next = head last = last.Next } } head = head.Next } last.Next = nil return newHead.Next }

5、删除排序链表中的重复元素,只保留没有重复出现的数字:创建虚拟头结点,循环遍历,先判断last的next的值不等于head的值,然后如果last的next的next节点为head(last->2->3head),则last移动到last的next,如果last的next的next节点不为head(last->2->2->3head),设置last的next指针为head。最后移动head到head的next。也就是last 指针是走一步,还是last的next指针走到head。

创建虚拟头结点 newHead := &ListNode{}; newHead.Next = head; last=newHead; for head != nil { if last.Next.Val != head.Next.Val { if last.Next.Next == head { last = last.Next } else { last.Next = head }} head = head.Next}

func deleteDuplicates(head *ListNode) *ListNode { newHead := &ListNode{} newHead.Next = head last := newHead for head != nil { // last>1>1>2 last>1>2 if last.Next.Val != head.Val { //如果last 和 head值相等,head指针走一步 //last -> 2 ->2 -> 3 head //last -> 2 -> 3 head if last.Next.Next == head { //head是 last.Next.Next 节点,last > 2 > 3 head last = last.Next // last指针走一步 } else { // last直接走到head, last > 2 > 2 > 3 head last.Next = head } } head = head.Next }

//清除尾部元素
if last.Next != nil && last.Next.Next != nil {
    last.Next = nil
}

return newHead.Next
复制代码

}

6、链表的中间节点,如果是两个返回第二个节点:使用map或者数组。map把链表index为key,节点为value,通过中间的index,取出中间节点;数组把链表元素一次存入数组,通过数组下标取出中间节点。

不借助其他存储空间:快慢指针。 slow = slow.Next; fast = fast.Next.Next; fast走完,slow刚好走一半。

func middleNode(head *ListNode) *ListNode { left := &ListNode{} left.Next = head right := head // 1 2 3 // 1 2 3 4 for right != nil && right.Next != nil { right = right.Next.Next left = left.Next } return left.Next }

7、链表的倒数第几个节点,使用快慢指针法,或者链表转为数组或map来直接获取。

删除链表倒数第N个节点:

func removeNthFromEnd(head *ListNode, n int) *ListNode { dummy := &ListNode{} dummy.Next = head slow := dummy fast := head for i:=0; i<n; i++ { fast = fast.Next }

for ;fast != nil; fast = fast.Next {
    slow = slow.Next
}

//移除 slow.Next
slow.Next = slow.Next.Next

return dummy.Next
复制代码

}

8、回文链表。判断一个链表是否是回文链表。 首先找到链表的中间节点 firstHalfEnd ,然后翻转后半部分链表。遍历两个链表比对元素,如果不相等就返回false,判断是否回文

func isPalindrome(head *ListNode) bool { //先拿到中间节点,及长度 //在翻转后面节点 1221 -> 1212 //遍历比对 summy := &ListNode{} summy.Next = head slow := summy fast := head // 1 > 2 > 1 // 1 > 2 > 2 > 1 for fast != nil && fast.Next != nil { fast = fast.Next.Next slow = slow.Next if fast != nil && fast.Next == nil { slow = slow.Next } }

// 翻转
var newHead *ListNode
var temp *ListNode
halfNode := slow.Next //head
for halfNode != nil {
    temp = halfNode.Next
    halfNode.Next = newHead
    newHead = halfNode
    halfNode = temp
}

for newHead != nil {
    summy = summy.Next
    if summy.Val != newHead.Val {
        return false
    }
    newHead = newHead.Next
}

return true
复制代码

}

双向链表:比单向链表多了一个pre指针,head的pre指向nil,提升了链表的综合性能。适合的场景:频繁在头部、尾部、任意位置进行添加和删除元素的场景;如果是频繁查询,随机访问使用数组。

单向循环链表:尾结点的next指向head。 双向循环链表:head的pre指向尾结点,尾结点的next指向head。可以增加:current;reset让current移动到头结点;next 让current往后走一步current=current.Next。约瑟夫环问题。 静态链表:使用数组来模拟,数组元素struct,next是下标。

栈:只能在一端进行操作,入栈push向栈中添加元素,出栈pop移除栈顶元素,获取栈顶元素Top。

1、使用切片或数组来模拟栈,切片首元素为栈底,末尾元素为栈顶。 切片的 last 元素就是栈顶元素。push操作就是在尾结点append追加元素。

2、浏览器的前进和后退,后退就是从第一个栈中pop掉栈顶元素,并把元素push到第二个栈中,前进把第二个栈的栈顶元素pop掉,并push到第一个栈中;

3、涂鸦的撤销、恢复功能。

4、有效括号:只包含’{’,’}’,’(’,’)’,’[’,’]’ 的字符串,判断有效性,左括号用相同的右括号闭合,闭合顺序正确。创建map[byte]byte{},左括号为key右括号为value,创建栈make([]byte,0)用切片模拟栈,遍历字符串,判断字符是否在map的key中,如果在map的key中就入栈push,不在就判断该字符和栈顶元素从map中取出的value是否相等,不等就返回fase。最后判断stack元素为空返回true。

5、用栈来实现队列:入队push到inStack中,出队判断outStack为空就将inStack所有元素逐一pop并push到outStack,outStack弹出栈顶元素。如果outStack不为空,outStack弹出栈顶元素。

6、使用堆来模拟栈

队列:入队enQueue从队尾rear添加元素,出队deQueue从队首front移除元素,获取队的头元素front。队列是从首尾操作元素,优先使用双向链表来实现。peekFirst查看队列的头元素。peekLast查看队列的尾元素。

(用两个栈来实现队列…)

用动态数组实现队列:enQueue直接向数组最后面追加元素elements=append(elements, e),deQueue取切片elements=elements[1:],front始终是0,判断size不等于0。

循环队列CircleQueue:底层使用数组实现。正常情况下,队首元素front是数组前面的index,队尾是数组尾部方向的元素。队首元素front数组的index,队列长度size。队尾入队enQueue计算队尾插入位置index是(front+size)%capacity,0123->(3+2)%4=1;头部出队deQueue计算新的队首元素index是 front = (front + 1)%capacity,0123->(3+1)%4=0;遍历获取元素在数组中的真实的索引:(front + i) % capacity;扩容需要把front放在新数组0的位置; 计算真实索引index:之前的索引对容量capacity取模就能获取到真实的索引,抽出方法 (front+index)%capacity。

双端循环队列:两端都可以进行删除、添加操作。增加了从头部入队enQueueFront,(-1 + front)如果是负数,索引为 (-1 + front)+capacity,为正数索引是(-1 + front)%capacity;从尾部出队deQueueRear,索引算法和头部入队相同(size-1 + front)判断负数。头部front,尾部是rear=(front+size-1) % capacity。

乘法、除法、取模、浮点数运算效率较低。

优化取模运算:a%b,如果a小于b,则a对b取模就是a;如果a大于等于b,且a不大于b的二倍,a对b取模就是a-b。提取代码:a-(a>=b?b:0)。也就是:index-(capacity > index ? 0 : capacity) ,如果为负数,就 index+capacity。

与动态数组的优化类似。

用队列来实现栈:

优先级队列,Priority Queue:使用二叉堆BinaryHeap实现。 使用:线程调度,。

(二叉堆….)

树 -> 二叉树(度最大为2)-> 真二叉树(度为0或2)-> 满二叉树(度为0或2且叶子节点在最后一层)-> 完全二叉树(从上到下、从左到右)。

树Tree:一棵树最多只有一个根节点,也可以只有根节点,也可以是空树没有节点的。 节点的度degree就是:节点子树的个数,度为0的节点叫叶子节点leaf。 层数level:根节点在第1层,根节点的子节点在第2层,以此类推。 节点的深度depth:从根节点到当前节点的唯一路径上的节点总数。节点深度的最大值就是树的深度。 节点的高度height:从当前节点到最远叶子节点的路径上的节点总数。节点高度的最大值就是树的高度。树的深度等于树的高度。 森林:由m棵互不相交的树组成的集合,m大于等于0。

树Tree可以大大提高效率。

二叉树BinaryTree:每个节点的度(子树数量)最大为2,左子树和右子树是有顺序的。特殊二叉树:空树、一个节点树、只有右子树就是单向链表。

真二叉树Proper BinaryTree:没有度为1的节点。(度为0或2)

满二叉树Full BinaryTree:没有度为1的节点,且所有叶子节点都在最后一层。满二叉树一定是一棵完全二叉树。

完全二叉树:从上到下,从左到右,节点排满。叶子节点只能出现最后两层;最后1层的叶子节点都靠左对齐;度为1 的节点只有左子树;度为1的节点最多只有1个;完全二叉树从根节点到倒数第2层是一棵满二叉树;同样节点数量的二叉树,完全二叉树的高度最小。

二叉搜索树效率高:添加、删除、搜索的最坏时间复杂度均可优化至 O(logn)。 有序动态数组二分搜索最坏时间复杂度为:O(logn);添加、删除、遍历查找的平均时间复杂度是O(n);

二叉搜索树Binary Search Tree,BST:任意一个节点的值,都大于这个节点左子树的所有节点值,都小于这个节点右子树的所有节点值;二叉搜索树的左右子树也是一棵二叉搜索树;二叉搜索树存储的元素必须具备可比较性,指定比较方式;不能为nil;没有索引,元素和添加顺序无关。

接口设计:size、isEmpty、clear、add(e)、remove(e)、搜索contains(e)。节点Node包含:left、right、parent。

添加节点:先找到父节点parent,然后创建新节点node,比较值大小,如果新节点比父节点小就赋值为左子树parent.left = node,如果新节点比父节点大就赋值为右子树parent.right = node;如果相等,就直接覆盖;初始化的时候传入比较器block或闭包,或者传入对象支持协议方法,也可以两者都支持。

性质1,求叶子节点数:所有二叉树叶子节点个数n0等于度为2的节点个数n2加1,即n0=n2+1。 推导: 节点总数n = n0+n1+n2; 总边数=n-1; 度为0的节点边数为0,度为1的节点边数为1,度为2的节点边数为2,总边数=n1+2*n2。

(叶子节点个数n0,度为1的节点个数n1,度为2的节点个数n2)

性质2,完全二叉树,求总结点数n的完全二叉树的叶子节点数: 如果一棵完全二叉树有768个节点,求叶子节点的个数: 推导: 总结点数为n,叶子节点数为n0,度为1的节点数n1,度为2的节点个数n2。 n = n0 + n1 + n2; n0 = n2 + 1; => n = 2 * n0 + n1 - 1; 因 n1 = 0 或 1; 当 n1 = 1 时,那么n = 2 * n0,n 是偶数,n0=n/2,非叶子节点数 == n - n0 == n/2; 当n1 = 0时,那么n = 2 * n0 - 1,n 是奇数,叶子节点个数n0等于(n + 1) / 2,非叶子节点个数 = n - n0 == (n-1)/2。 叶子节点的个数为 (n+1)/2 向下取整,也是(n+1) >> 1 ;非叶子节点个数为 n/2 向下取整。

性质3,满二叉树第i层节点数量是:2^(i-1) 。

性质4,高度为h的满二叉树叶子节点数量是:2^(h-1),总结点数量是:2^h - 1 = 2^0+2^1+….+2^(h-1)。在同样高度的二叉树中,满二叉树的叶子节点数量最多,总结点数量最多。

(公式:2^0+2^1+…….+2^n = 2^(n+1)-1)

性质5,完全二叉树,求总结点数n的完全二叉树的高度:高度为h的完全二叉树(h>=1),那么至少有2^(h-1)个节点=2^0+2^1+…+2^(h-2)+1。最多就是满二叉树2^h - 1个节点。总结点数就在2^(h-1) 和 2^h 之间,2^(h-1) <= n < 2^h,分别取对数 h-1<log2^n<h,然后log2^n < h < log2^n + 1,h就等于log2^n向下取整加1。

性质6,求完全二叉树第i个节点的父节点索引和子节点索引: 有n个节点,n>0,从上到下、从左到右对节点从1开始进行编号,对任意第i个节点: 如果i=1,它是根节点; 如果i>1,它的父节点编号为floor(i/2)向下取整; 如果2i <= n,它的左子节点编号为2i,也就是2i如果不大于总结点数,2i就是节点i的左子节点数,如果大于总结点数就是没有左子节点; 同样右子节点数为2*i+1。

(二叉堆……..) (二叉堆使用这个性质,二叉堆是一个完全二叉树,使用数组实现,需要求某个二节点的子节点,父节点)

二叉树翻转:入参root节点,判断root节点为nil返回,不为nil,交换root节点的left、right节点,然后递归翻转root节点的左右子节点root.Left,root.Right。

线性数据结构的遍历分为正序遍历、逆序遍历。两个方向。

二叉树的遍历:(不是二叉搜索树特有的)

前序遍历PreorderTraversal:依次遍历根节点、左子树、右子树。 给你一个二叉树的根节点root,返回它节点值的前序遍历,递归实现:先新建切片result,判断根节点不为空,数据存储到切片中,然后递归调用,传入根节点的左子树,返回数据切片,不为空追加切片元素到切片result中,接着继续递归调用,传入根节点的右子树,返回数据切片,不为空追加切片元素到切片result中,最终返回切片result。

中序遍历InorderTraversal:依次遍历左子树、根节点、右子树。二叉搜索树中序遍历的结果是升序;后序遍历PostorderTraversal:依次遍历左子树、右子树、根节点; 根节点前面遍历就是前序,中间遍历就是中序,后面遍历就是后序。

层序遍历LevelOrderTraversal访问顺序:从上到下、从左到右依次访问每一个节点。(重要)

思路:使用队列。首先将根节点入队,然后将队首元素A出队访问,并将A的左、右子节点依次入队,继续循环,直到队列为空为止。

实现过程:首先创建队列,并把root根节点入队deQueue,queue := []TreeNode{root},结果二维数组result = make([][]int, 0) ,创建每层结果数组level=make(int[],0),创建当前层节点数量size=1只有根节点,下一层节点数存储nextSize := 0,然后循环判断队列queue是否为空,如果为空,就结束循环。如果不为空就循环,队首元素出队deQueue,判断左右节点是否为nil,不为nil把左节点、右节点依次存入队列中,把出队的元素的Val存入到level数组,level = append(level, root.Val),每次循环size- - ,如果有左右节点,就nextSize++,如果size==0,就代表本层结束,把level存入到result二维切片中,清空level,size =nextSize,清空nextSize。下一层的元素个数,就是当本层元素遍历完成,队列的size。可以计算二叉树的高度,二维数组包含一维数组的个数就是层高。

遍历应用1,利用层序遍历,判断一棵树是否为完全二叉树:如果树不为nil,开始层序遍历二叉树(用队列)。如果node.left != nil,将node.left 入队;如果node.left==nil && node.right != nil,返回false;如果node.right != nil,将node.right入队;如果node.right==nil,那么后面遍历的节点都为叶子节点才是完全二叉树,否则返回false。 四种情况组合:左右子节点为空不为空。

遍历应用2,利用层序遍历计算二叉树的高度。

遍历应用3,利用前序遍历打印二叉树:入参root,locationStr,prefix,首先拼接占位文案locationStr = locationStr + prefix,打印占位文案locationStr、root.Val,然后递归打印左子节点、右子节点。

遍历应用4,利用中序遍历对二叉搜索树元素升序排列。

遍历应用5,利用后序遍历对一些先子后父的操作。

前驱节点predecessor:中序遍历时的前一个节点。 后继节点successor:与前驱相反,中序遍历时的后一个节点。 二叉搜索树的删除用到前驱和后继。

对于二叉搜索树:前驱节点就是前一个比它小的节点,也就是左子树的最大节点; 如果 node.left != nil,那么前驱节点prodecessor = node.left.right.right…… ,终止条件:right == nil; 如果 node.left == nil && node.parent != nil,prodecessor=node.parent.parent.parent…. 遍历node=node.parent,终止条件node在parent的右子树中node==node.parent.right,如果没有右子树,就没有前驱节点; 如果node.left == nil && node.parent == nil,那么就没有前驱节点;

二叉搜索树删除节点:删除叶子节点,判断是父节点的左右子节点,通过父节点删除node.parent.left=nil;删除度为1的节点,用子节点替代原节点位置child.parent=node.parent,node是左子节点就把node.parent.left=child,如果是右子节点就把node.parent.right=child,如果是根节点root=child,child.parent=nil;删除度为2的节点,;

二叉搜索树的复杂度是:O(h) == O(logn)。二叉搜索树退化成链表后复杂度:O(h)==O(n)。当n比较大的时候,这两种情况性能差异比较大。比如n=一百万次约为2^20,二叉搜索树最小搜索20次,最多一百万次。 添加、删除节点的时候,二叉搜索树都可能会退化成链表。 防止二叉搜索树退化成链表:让添加、删除、搜索的复杂度维持在O(logn)。 平衡 Balance:当节点的数量固定的时候,左右子树的高度越接近,这棵二叉树越平衡(高度越低)。 改进二叉搜索树:节点的添加、删除顺序是无法限制的,可以认为是随机的。所以改进方案:在节点添加、删除操作之后,用尽量少的调整次数达到适度平衡即可,想办法让二叉搜索树恢复平衡(减小树的高度)。

平衡二叉搜索树 Balanced Binary Search Tree,BBST:一棵达到适度平衡的二叉搜树。常见的平衡二叉搜索树:AVL树,Windows NT内核中广泛使用。红黑树:C++ STL(比如map、set);JAVA的TreeMap、TreeSet、HashMap、HashSet;Linux的进程调度;Nginx的timer管理; AVL树、红黑树也叫自平衡二叉搜索树,Self-balancing Binary Search Tree。

AVL树: 平衡因子,Balance Factor:某节点的左右子树的高度差。叶子节点左右子树的高度差是0,所以叶子节点的平衡因子是0。 AVL树的特点:每个节点的平衡因子只可能是1、0、-1(绝对值<=1,如果超过1,称之为失衡);每个节点的左右子树高度差不超过1;搜索、添加、删除的时间复杂度是O(logn);

AVLTree、RBTree继承自BST,BST继承自 Binary Tree。

AVL树添加元素:可能会导致所有祖先节点都失衡;只要让高度最低的失衡点恢复平衡,整棵树就恢复平衡,仅需O(1)次调整。 AVL树删除元素:只可能会导致父节点失衡;让父节点恢复平衡后,可能会导致更高层次的祖先节点失衡,最多需要O(logn)次调整。 平均时间复杂度:搜索O(logn);添加O(logn),仅需要O(1)次的旋转操作;删除O(logn),最多需要O(logn)次的旋转操作;

LL - 右旋转(单旋),RR-左旋转(单旋),LR - RR左旋转,LL右旋转(双旋),RL - LL右旋转,RR左旋转(双旋)。

红黑树 Red Black Tree:一种自平衡的二叉搜索树。也叫平衡二叉B树 Symmetric Binary B-tree。红黑树必须满足以下5条性质:1、节点是Red或者Black。2、根节点是Black。3、叶子节点(外部节点,空节点)都是Black。4、Red节点的子节点都是Black。Red节点的parent都是Black。从根节点到叶子节点的所有路径上不能有2个连续的Red节点。5、从任一节点到叶子节点的所有路径都包含相同数目的Black节点。

B树:一种平衡的多路搜索树,多用于文件系统、数据库的实现。 B树特点:1个节点可以存储超过2个元素、可以拥有超过2个子节点。拥有二叉搜索树的特点。平衡,每个节点的所有子树高度一致。比较矮。 m阶B树就是每个节点最多有m个子树。

二叉堆,BinaryHeap:提供三个接口,添加元素,获取最大值,删除最大值。 使用动态数组或双向链表,获取、删除最大值复杂度是O(n),添加元素复杂度是O(1)。 有序动态数组或双向链表,需要全排序,从小到大,获取最大值、删除最大值复杂度是O(1),添加元素复杂度是O(n)。 BBST红黑树,获取最大值,删除最大值,添加元素复杂度都是O(logn)。 堆,获取最大值O(1),删除最大值、添加元素都是O(logn)。

Top K问题:从海量数据中找出前K个数据。比如,从100万个整数中查找最大的100个整数。解法一:可以用堆来解决。

堆(Heap),一种树状的数据结构。不要跟内存模型中的堆空间混淆。常见的堆实现有:二叉堆Binary Heap也叫完全二叉堆,等其他。 堆的特点:任意节点的值总是大于等于>=或小于等于<=子节点的值。 如果任意节点的值总是大于等于>=子节点的值,称为大顶堆。 如果任意节点的值总是小于等于<=子节点的值,称为小顶堆。 必须具有可比较性,和二叉搜索树一样。

二叉堆的逻辑结构就是一棵完全二叉树,所以也叫完全二叉堆,比完全二叉堆多了一个比较,大顶堆是根节点值大于子节点,小顶堆是根节点的值小于子节点。 二叉堆底层一般使用数组实现。

二叉堆实现接口:size、comparator、isEmpty、clear、add、get、remove、replace

大顶堆为例。 添加元素实现:先把元素追加到数组中,然后判断新元素和父节点大小,比父节点大就和父节点交换位置,循环。如果是比父节点小或没有父节点结束循环。这个比较的过程叫做上滤siftUp。

比较排序Comparison Sorting:冒泡、选择、插入、归并、快速、希尔、堆排序。

冒泡排序Bubble Sort:从头开始比较相邻的两个元素,如果第一个数大于第二个数进行交换。优化1:全部有序;优化2:局部有序;平均、最坏时间复杂度O(n^2)。最好时间复杂度:O(n)。

/// 冒泡排序 func bubbleSort(s []int) { for end := len(s)-1; end > 0; end-- { for begin := 1; begin <= end; begin++ { if s[begin] < s[begin-1] { //稳定性,等于不要交换 //交换 temp := s[begin] s[begin] = s[begin-1] s[begin-1] = temp } } } fmt.Println("s:", s) }

排序算法的稳定性Stability:如果相等的2个元素,在排序前后的相对位置保持不变,它就是稳定的。

原地算法In-place Algorithm:不依赖额外的资源或者少数的额外资源,仅依靠输出来覆盖输入。空间复杂度比较低,空间复杂度为O(1)。

选择排序Selection Sort:从序列中找出最大元素的下标maxIndex,然后与最末尾的元素交换位置。最好、最坏、平均时间复杂度O(n^2)。获取最值可以使用堆来处理,时间复杂度可以达到O(logn)。

/// 选择排序 func selectionSort(s []int) { for end := len(s)-1; end > 0; end-- { maxIndex := 0 for begin := 1; begin <= end; begin++ { if s[maxIndex] <= s[begin] { //保持稳定性 maxIndex = begin } } temp := s[maxIndex] s[maxIndex] = s[end] s[end] = temp }

fmt.Println("s:", s)
复制代码

}

堆排序Heap Sort:对选择排序的一种优化。1、对数组进行原地建堆,shiftDown、shiftUp。2、交换。

插入排序 Insertion Sort:扑克牌排序。把数据分为两部分:有序的头部和待排序的尾部。从头开始扫描每一个元素,每当扫描到一个元素,就将它插入到头部合适的位置,使得头部数据保持有序。 插入排序的复杂度与逆序对 Inversion 成正比关系,逆序对越多,复杂度越大。逆序对就是比较需要交换的两个数就是一对逆序对。 平均、最坏复杂度是O(n^2)。最好复杂度是O(n)。 当逆序对数量极少的时候,插入排序的效率特别高,甚至速度比O(nlogn)级别的快速排序还要快。 数据量不是很大的时候,插入排序效率也是很高的。

// 插入排序 func InsertionSort(nums []int) []int { for begin := 1; begin < len(nums); begin++ { cur := begin for cur > 0 && nums[cur] < nums[cur-1] { //稳定排序 temp := nums[cur] nums[cur] = nums[cur-1] nums[cur-1] = temp cur-- } } return nums }

优化1:将 交换 修改为 挪动。首先,对待插入的元素备份,然后遍历有序数据,判断元素比插入元素大,元素就朝尾部挪动1个位置,直到元素比插入元素小,停止遍历,把待插入元素放到最终的位置。

func InsertionSort2(nums []int) []int { for begin := 1; begin < len(nums); begin++ { cur := begin temp := nums[cur] for cur > 0 && temp < nums[cur-1] { nums[cur] = nums[cur-1] cur-- } nums[cur] = temp } return nums }

二分搜索BinarySearch:有序整型数组nums和一个目标值target,写一个函数搜索nums中target,如果存在返回下标,否则返回-1。

func search(nums []int, target int) int { // [begin end) 区间的元素总个数 end-begin     begin, end := 0, len(nums)     for begin < end {         mid := (end - begin) >> 1         if nums[mid] == target { //问题:如果有多个重复的值,返回的下标是不固定的             return mid         } else if target < nums[mid] {             end = mid         } else {             begin = mid+1         }     }     return -1 }

优化2:使用二分搜索来优化插入排序。使用二分搜索来搜索插入位置。 二分搜索,当target < nums[mid]的时候,从左边搜索,其他的从右边搜索,最终返回要插入位置的下标。减少了比较次数,插入排序的平均时间复杂度没有变化O(n^2)。

// 插入排序 - 优化:二分查找 -> 挪动 -> 插入 func InsertionSort3(nums []int) []int { for begin := 1; begin < len(nums); begin++ { temp := nums[begin] // 二分查找 -> 查找到位置 insertIndex := searchIndex(nums, begin)

    // 元素挪动
    for i := begin; i > insertIndex; i-- {
        nums[i] = nums[i-1]
    }
    nums[insertIndex] = temp
}
return nums
复制代码

} // 时间复杂度:O(logn) func searchIndex(nums []int, index int) int { begin, end := 0, index for begin < end { mid := (begin + end) >> 1 if nums[index] < nums[mid] { end = mid } else { begin = mid + 1 } } return begin }

归并排序Merge Sort:O(nlogn)。 快速排序 Quick Sort:最快。

网络:

计算机之间通信是依据对方的IP地址,网卡地址MAC地址,传送的数据最终被网卡接收。传输的数据包括:源IP地址、目标IP地址、源MAC地址、目标MAC地址。如果网卡发现目标MAC地址是自己,就会将数据传递给上一层进行处理。

首先发送一个ARP广播协议,获取对方的MAC地址,在同一个网段中传播。一个完整的ARP请求,分三次:首先计算机0发送广播,获取计算机1的mac地址,然后计算机0发送给计算机1,计算机1回复。ARP是有缓存的。

网线、同轴电缆、集线器有冲突域。什么是冲突域? 网桥Bridge:有两个接口,能够通过学习知道每个电脑的MAC地址在网桥的哪一侧,从而起到隔绝冲突域的作用。 交换机:相当于接口更多的网桥,全双工通信,是局域网解决方案。交换机在发送ARP广播的时候会记录局域网中所有计算机的MAC地址,就不会把数据传输给其他的计算机。比集线器安全,因为集线器不知道其他的计算机的MAC地址,会把数据发给所有人。全球网络的话,使用交换机,ARP广播就会全球发送,会引起广播风暴,也是比较浪费,就有了路由器。 路由器:可以在不同网段之间转发数据,隔绝广播域。同一个网段就是同一个广播域。

MAC地址 Media Access Control Address,有6字节(48bit)。前三个字节:OUI,组织唯一标识。后三个字节:网络接口标识。48位全为1代表广播MAC地址FFFF.FFFF.FFFF。

IP地址Internet Protocol Address:互联网上的每一个主机都有一个IP地址。IPV4 32bit,4字节,1个字节8位算是一部分,共四部分。IPV6 128bit,16字节。IP地址功能分为2部分:网络标识,即网络ID,主机标识,即主机ID。

网段就是:IP地址按位与&子网掩码。 IP地址:193.168.1.1 子网掩码:255.255.255.0 1100 0000.1010 1000.0000 0001.0000 1010 IP地址 & 1111 1111.1111 1111.1111 1111.0000 0000 子网掩码

1111    1111.1111   1111.1111     1111.0000   0000     网段
192.168.1.0     网段
复制代码

IP地址:139.168.1.1 子网掩码:255.255.0.0 网段就是:139.168.0.0

A类地址:子网掩码255.0.0.0,第一部分对应网络ID,后面三部分对应主机ID。第一部分必须以0开头,所以网络ID范围:二进制7个0到7个1,十进制0到127。127作为保留网段。127.0.0.1 是本地回环地址Loopback,代表本机地址。网络ID第一部分是1到126就是A类地址。后面三部分的取值是 0 到255。主机部分,全0代表网段,全1代表广播地址,所以某个A类网段能容纳的主机数256256256 - 2 =2^24-2。

B类地址:子网掩码 255.255.0.0,前两部分是网络ID,第一部分必须是以10开头。每一部分有8位。 C类地址:默认子网掩码255.255.255.0,前三部分是网络ID,第一部分必须是以110开头。

123.210.100.200/16,代表子网掩码有16个1,也就是255.255.0.0,每一部分8位。

合理进行子网划分,解决的问题是:避免IP地址浪费。

私网IP访问Internet需要进行NAT转换为公网IP,NAT,Network Address Translation,由路由器来完成。节约网络IP资源,隐藏内部真实IP。

在实际的使用中,一般都是把网络划分为五层:应用层、传输层、网络层、数据链路层、物理层。

集线器工作在:物理层,没有智商,不会判断原mac地址、目标mac地址。 网卡是工作在:物理层、数据链路层。 交换机工作在:物理层、数据链路层,会判断原Mac地址、目标Mac地址。 路由器工作在:物理层、数据链路层、网络层。

物理层Physical:发送比特流Bits,定义接口标准,线缆标准,传输速率,传输方式等。

数据链路层Data Link:发送数据帧Frame,至少64字节,加上原Mac地址,目的Mac地址。首部+数据+尾部,数据部分是上一层传下来的。 链路:一个节点到相邻节点的一段物理线路,路由器到路由器或交换机,就是链路。

wireshark抓包是Ethernet II,以太网帧。 wireshark看不到数据链路层的尾部,只能看到首部。

网络层Network:发送数据包Packet,由首部、数据两部分组成。数据部分很多时候是由传输层传递下来的数据段Segment。首部有20个字节是固定的,一共五行,每行占用四个字节,每行是0到31位共32位。 以太网帧首部和网络层首部是挨在一起的。网络层首部可变部分最多是40个字节。 网络层数据太大,会分片传给数据链路层,转成多个数据链路层的帧,接收方在网络层会把数据组合起来。如何合并起来的,怎么区分是一个数据包?

网络层首部,标识Identification占16位,数据包的ID,当数据包过大进行分片时,同一个数据包的所有片的标识都是一样的。有一个计数器专门管理数据包的ID,每发出一个数据包,ID就加1。 如果数据包太大,超过了ID最大值,就会重头从1开始算起。有片偏移Fragment Offset来定位这个片在哪个位置,片偏移有13位,为了能够表示更多的偏移,所以这里存储的不是真实的字节偏移,片偏移乘以8才是字节偏移,Wireshark抓包出来的是已经乘过8的。

网络层首部,Flags标记是否有更多分片:More fragments: Set 1 有更多分片。

网络层首部,协议Protocol:占8位,表明所封装的数据是使用了什么协议。 ICMP : 1,IP:4,TCP:6,UDP:17,IPV6:41。

网络首部,校验和Header Checksum:用于检查首部是否有错误。

有些协议直接工作在网络层:ARP、IP、ICMP,就没有上面的应用层、传输层。 ICMP没有传输层的哪些可靠控制、流量控制、拥塞控制,所以是在网络层。

网络层首部,生存时间TTL:占8位,每个路由器在转发之前会将TTL减1,一旦发现TTL减为0,路由器会返回错误。观察ping命令后的TTL,能够推测出对方的操作系统,及中间经过了多少个路由器。 生存时间TTL是由操作系统默认的:Windows是 128,Linux 2.0.x kernel是64,Mac OS 是64。

ping /? 查看ping的用法 ping ip 地址 -I 数据包大小, sudo ping ke.qq.com -l 4000 ping ip地址 -f 不允许网络层分片

Wireshark抓包可以看到网络层:Internet Protocol Version 4,Src发送方IP,Dst接收方的IP。

传输层Transport:发送数据段Segments,使用TCP、UDP协议,保证可靠传输,发现某一段数据传输失败,重传。

TCP和UDP的区别,报文格式:

TCP,Transmission Control Protocol,传输控制协议:面向连接的;可靠传输,不丢包;首部占用空间大;传输速率慢;资源消耗大;应用场景:浏览器、文件传输、邮件发送; 对应的应用层协议:HTTP、HTTPS、FTP、SMTP、DNS。

UDP,User Datagram Protocol,用户数据报协议:无连接的;不可靠传输,尽最大努力交付,可能丢包;首部占用空间小;传输速率快;资源消耗小;应用场景:音视频通话、直播,注重实时的传输; 对应的应用层协议:DNS。

UDP是无连接的,减少了建立和释放连接的开销;尽最大能力交付,不保证可靠交付;不需要维护一些复杂的参数,首部只有8个字节,TCP至少20个字节。 UDP首部8个字节包括:16位源端口号、16位目的端口号、16位UDP长度、16位UDP检验和Checksum。

UDP首部: UDP端口号:占用2个字节,可推测出端口号取值范围:0~65535。 客户端的源端口是临时开启的随机端口。

UDP长度:16位2个字节:首部长度+数据的长度。

检验和Checksum:16位2个字节:伪首部+首部+数据。 伪首部12个字节包括:源IP地址,目的IP地址,UDP协议17,UDP长度。伪首部pseudo-header不会传递给网络层。

Wireshark抓包显示:User Datagram Protocol,src Port: ,Dst Port。

netstat -an 查看被占用的端口 netstat -anb 查看被占用的端口、占用端口的应用程序

TCP: 数据偏移:占4位,乘以4是首部的长度Header Length。因为有20个字节的固定首部,所以数据偏移至少是5,取值范围是0x0101到0x1111,最大是60个字节。和网络层首部一样。理解为:首部的长度就是数据向右边偏移了多少。

Reserved 保留位。

使用首部的一些字段保证可靠传输。

TCP/UDP的数据长度,完全可以由网络层IP数据包的首部推测出来: 传输层的数据长度 = 网络层的总长度 - 网络层的首部长度 - 传输层的首部长度。 网络层的数据部分就是传输层(传输层首部+传输层数据)。

TCP首部标志位Flags: URG,Urgent,当URG=1的时候,紧急指针字段才有效,表示当前报文段中有紧急数据,在TCP数据段前面的多少位是紧急数据,应优先尽快传送; ACK,Acknowledgment确认,当ACK=1的时候,确认号字段才有效; PSH,Push; RST,Reset,当RST=1的时候,表明连接中出现严重差错,必须释放连接,然后再重新建立连接; SYN,Synchronization,当SYN=1、ACK=0时,表明这是一个建立连接的请求,告诉服务器我想和你建立连接。如果对方同意建立连接,则回复SYN=1,ACK=1; FIN,Finish,当FIN=1的时候,表明数据已经发送完毕,要求释放连接。

Seq序号Sequence Number:占4个字节。在传输过程中的每个字节都有一个编号。连续的字节,编号是连续的。在建立连接后,序号代表:这一次传给对方的TCP数据部分的第一个字节的编号。建立连接的时候是0。

确认号,Acknowledgment Number:占4个字节,在建立连接后,确认号代表:期望对方下一次传过来的TCP数据部分的第一个字节的编号。

可靠传输: 停止等待ARQ协议,自动重传请求 Automatic Repeat-reQuest: A发送数据M1给B,B等待接收M1完成后,告诉A确认接收完成,然后A接收到确认,继续发送M2。 情况1:A发送M1给B的过程中出现超时,会重传M1,B就丢弃上次超时错误的报文。 情况2:A发送M1给B成功,B告诉A确认M1接收完成,确认M1的过程中超时,A会重传M1,B接收到重复的M1会丢弃,并重传确认M1。或者过了很长时间,B接收到了第一次迟到的确认M1,B什么都不做,丢掉。超时重传。

效率比较低。

改进:连续ARQ协议+滑动窗口协议。 连续ARQ指一次发送连续的几个数据。 A发送窗口中有4个分组M1、M2、M3、M4,发送完成后,停止发送,等待B的确认。B收到全部数据M1、M2、M3、M4,确认M4。M1、M2、M3、M4是连续的,所以只确认M4就行。A收到确认M4后,窗口滑动到M5、M6、M7、M8,发送窗口中的数据,发送完成后,停止发送,等待B的确认。

异常情况: 如果接收窗口最多能接收4个包,但发送方只发了2个包。 接收方如何确认后面还有2个包? 等待一定时间后没有第3个包,就会返回确认收到2个包给发送方。

滑动窗口:窗口大小是由接收端B端告诉你,由接收端决定。B端接收缓存有多大,就告诉A滑动窗口多大,可以发送多少个字节。接收端B端给A端发送确认消息的时候,会告诉A端B当时可以接收的数据缓存大小,也就是滑动窗口大小,滑动窗口可能每次的大小不一样。

窗口Window:占2字节,这个字段有流量控制功能,用以告知对方下一次允许发送的数据大小,单位是字节。

SACK 选择性确认 Selective Acknowledgment: 在TCP通信过程中,会出现发送序列中间某个数据包丢失的情况,比如M1、M2、M3、M4中丢失了M3。 如果没有SACK的情况,TCP会重传最后确认的分组后续的分组,最后确认的是M2,会重传M3、M4。这样就会导致已经正确传输的M4也重新发送,降低了TCP性能。 有了SACK,接收方B会告诉发送方A哪些数据丢失,哪些数据已经提前收到,这样TCP只重新发送丢失的包M3,不用发送后续已经正确传输的分组M4。
 TCP首部的选项最多40个字节。 SACK使用了TCP首部的选项: Kind,占1个字节,Kind=5代表是SACK选项; Length,占1个字节,表示SACK整个选项一共占用多少字节。 Left Edge,占4个字节,左边界。 Right Edge,占4个字节,右边界。 最多带4组边界信息,一组占用8个字节,再加上Kind的1个字节,Length的1个字节,所以SACK选项的最大占用字节数是34=4*8+1+1。

客户端从服务端下载大文件:应用层文件很大,会在传输层对文件进行切割,传给网络层。 为什么在传输层进行分割数据,而不是在网络层进行分片传输? 传输层重传可以提高重传的性能。 只有传输层才有可靠传输,也就是可靠传输是在传输层进行控制。 如果在传输层不分段,一旦出现数据丢失,整个传输层的数据都得重传。 如果在传输层分了段,一旦出现数据丢失,只需要重传丢失的那些段即可。

TCP流量控制:

问题: 如果接收方的缓存区满了,发送方还在疯狂发送数据,接收方只能把收到的数据包丢掉。 解决:大量丢包极大的浪费网络资源,所以要进行流量控制。让发送方的发送速率不要太快,让接收方来得及接收处理。发送方和接收方之间的问题,点对点。

原理:通过确认报文中窗口Window字段来控制发送方的发送速率,Window字段告诉对方下一次允许发送的数据大小,字节为单位。发送方发送窗口大小,不能超过接收方给出的窗口大小。当发送方收到接收窗口大小为0的时候,发送方就会停止发送数据。

特殊情况: 一开始,接收方给发送方发送了0窗口的报文段。后面,接收方又有了一些存储空间,给发送方发送的非0窗口的报文段丢失了。发送方的发送窗口一直为0,双方陷入僵局。 解决:当发送方收到0窗口通知时,这个时候发送方停止发送报文。并且同时开启一个定时器,隔一段时间就发个测试报文去询问接收方最新的窗口大小。如果接收的窗口大小还是0,则发送方再次刷新启动定时器。

拥塞控制: 防止过多的数据注入到网络中。避免网络中的路由器或链路过载。 拥塞控制是一个全局性的过程,涉及到所有主机、路由器,以及降低网络传输性能有关的所有因素,大家共同努力的结果。相比,流量控制是点对点通信的控制。

拥塞控制方法:慢开始slow strart,拥塞避免congestion avoidance,快重传fast retransmit,快恢复fast recovery。

MSS,Maximum Segment Size:每个段最大的数据部分大小,在建立连接的时候确定。 cwnd,congestion window:拥塞窗口。 rwnd,receive window:接收窗口。 swnd,send window:发送窗口,是拥塞窗口和接收窗口的最小值swnd = min(cwnd, rwnd)。

慢开始slow start:cwnd的初始值比较小,然后随着数据包被接收方确认,收到ACK,cwnd就会成倍增长,指数级。

拥塞避免congestion avoidance:ssthresh, sow start threshold,慢开始阈值,cwnd达到阈值后,以线性方式增加。使用加法增大,拥塞窗口慢慢增大,以防止网络过早出现拥塞。 当增大到一定程度,就是网络拥塞,这个时候需要使用乘法减小,把ssthresh减半。之后,新旧版本处理方式不同。旧版本,会同时执行慢开始算法,cwnd又恢复到初始值。新版本,会使用快恢复,在阈值的地方使用加法增大,而不是回到初始值。 当网络出现频繁拥塞时,ssthresh值就下降的很快。

如何知道网络拥塞? 当发送方连续收到三个重复确认,就说明网络拥塞,就执行乘法减小算法,把ssthresh减半。 与慢开始不同之处是不执行慢开始算法,也就是cwnd不恢复到初始值,而是把cwnd值设置为ssthresh减半后的值。然后开始执行拥塞避免算法,加法增大,使拥塞窗口缓慢地线性增大。

连接管理:建立连接,三次握手、释放连接,四次挥手。 三次握手建立连接:客户端发送序号SYN=1,确认号ACK=0给服务端;服务端回复TCP序号SYN=1,确认号ACK=1给;客户端回复序号SYN=0,确认号ACK=1。前两次序号SYN都是1。

序号就是当前发送的包第多少个字节。ACK是告诉对方从哪个序号开始发送。 原生值和相对值,发送的实际是原生值,相对值是计算出来的。

原生值的情况: 首先是三次握手,第一步,客户端发送序号seq=s1, ack=0 给服务器,s1是客户端生成随机值。 第二步,服务器回应序号seq=s2,ack=s1+1 给客户端,s2是服务器生成随机值,ack确认的是上一步客户端的发送,也是告诉客户端下一次发送的序号。 第三步,客户端发送seq=s1+1,ack=s2+1 给服务器,数据长度为0。连接建立完成。 第四步,客户端发送数据seq=s1+1,ack=s2+1 给服务器,和第三步不一样的是有数据长度k,都是回复的第二步,所以seq和ack一样。 第五步,服务器发送数据M1、M2、M3给客户端。发送M1数据seq=s2+1,ack=s1+k+1,数据长度b1。发送M2数据seq=s2+b1+1,ack=s1+k+1,数据长度b2。发送M3数据seq=s2+b1+b2+1,ack=s1+k+1,数据长度b3。 第六步:客户端发送seq=s1+k+1,ack=s2+b1+b2+b3+1。客户端ack确认上一次服务器的发送,上一次服务器的seq+数据长度b3+1。

TCP-建立连接-状态: 首先客户端Client处于关闭Closed状态,服务器Server处于监听Listen状态,等待Client连接。 客户端发起连接请求 SYN=1,ACK=0,seq=x,此时客户端进入同步已发送SYN-SENT状态。 服务器接收到客户端的连接请求,服务器进入同步已接收 SYN-RCVD状态。服务器发送连接请求确认 SYN=1,相对ACK=1,seq=y,真实ack=x+1给客户端。 客户端收到服务器确认,并发送收到确认 ACK=1,seq=x+1,ack=y+1 给服务器,客户端进入连接已经建立established 状态。服务器收到确认也进入连接已经建立established 状态。

建立连接前两次握手:SYN都是1,TCP头部的长度一般是32字节。数据部分的长度前三次都是0。 TCP头部固定是20字节,选项部分是12字节。 前两次握手会交换确认一些信息:比如MSS,是否支持SACK,Window scale窗口缩放系数等。这些数据都会放在了TCP头部的选项部分中12字节。

为什么要进行三次握手,两次不行吗?三次主要目的是:防止服务端server一直等待,浪费资源。 如果建立连接只需要2次握手,可能会出现情况:假如客户端client发出的一个连接请求报文段1,因为网络延迟,客户端迟迟没有得到回复判断请求1失效,并又发送了一个新的连接请求2正常建立连接,发送数据,释放连接2。在连接释放以后的某个时间连接请求1才到达服务器server,服务器收到失效的连接1,误认为客户端重新发送了一个新的连接请求,于是服务器就向客户端发出确认报文,同意建立连接。如果不采用三次握手,只要服务器发出确认连接,新的连接就建立成功。由于客户端并不想连接服务器,因此不会对服务器的确认做响应,也不会向服务器发送数据。但服务器却认为新的连接已经建立,并一直等待客户端发送数据,这样服务器的资源就浪费了。

采用三次握手,就可以防止这种现象发生,客户端没有想服务器发送确认,服务器收不到确认,就知道客户端并没有要求建立连接。

第三次握手失败,会怎么处理:此时服务器的状态为SYN-RCVD,若等不到客户端的ACK,服务器会重新发送SYN=1,ACK=1包。如果服务器多次重发SYN=1,ACK=1包,都等不到客户端的ACK,就会发送RST包,强制关闭连接。

TCP释放连接,四次挥手:

长连接和短连接的区分:以socket为例,建立连接后立刻close就叫短连接。等一段时间后再close就是长连接。

应用层Application:FTP、HTTP、DNS。报文,用户数据。

域名Domain Name:为了解决IP地址不方便记忆且不能表达组织的名称和性质的问题。最终还是需要知道目标主机的IP地址。 为什么不直接使用域名,放弃IP:IP地址固定4个字节,域名占用数据比较大,浪费流量,增加路由器负担。 根据域名级别:分为顶级域名TLD,Top-level Domain。二级域名。

通用顶级域名General Top-level Domain,gTLD:.com公司,.net网络机构,.org组织机构,.edu教育,.gov政府部门,.int国际组织等。 国际及地区顶级域名 Country Code Top-level Domain,ccTLD:.cn中国,.jp日本,.uk英国。 新通用顶级域名,New Generic Top-level Domain,New gTLD:.vip,.xyz、.top,.club,.shop等 
二级域名:顶级域名之下的域名。在通用顶级域名下,一般指域名注册人的名称,例如google、baidu等。一般域名 baidu.com 是由顶级域名和二级域名组成。baidu 是二级域名,.com是顶级域名。 从右向左数,第一个是顶级域名,第二个.是二级域名,依次三级四级。

DNS,Domain Name System:利用DNS协议,将域名解析成对应的IP地址。DNS可以基于UDP协议,也可以基于TCP协议,服务器占用53端口。

ipconfig /displaydns: 查看DNS缓存记录 ipconfig /flushdns: 清空DNS缓存记录 ping 域名 nslookup 域名

DNS服务器:访问www.baidu.com,客户端首先访问最近的一台DNS服务器(客户端自己配置的DNS服务器),然后这台最近的DNS服务器会请求根域名服务器,根域名服务器返回对应顶级域名的DNS服务器IP,包含.com的IP。接着这台最近的DNS服务器向根域名DNS服务器发起请求,返回baidu.com所在的DNS服务器IP,二级域名DNS服务器IP。最后最近的这台DNS服务器向二级域名DNS服务器发起请求获取baidu.com对应的IP。

所有DNS服务器都记录了DNS根域名服务器的IP地址。 上级DNS服务器记录了下一级DNS服务器的IP地址。 全球一共13台IPv4的DNS根域名服务器、25台IPv6的DNS根域名服务器。

IP分配方式分为:静态IP地址、动态IP地址。 动态IP地址:从DHCP服务器自动获取IP地址。移动设备、无限设备等。

DHCP,Dynamic Host Configuration Protocol,动态主机配置协议。基于UDP协议,客户端端口68,服务器端口67。DHCP服务器会从IP地址池中挑选一个IP地址给客户端一段时间,时间到期就会回收。 家里上网的路由器就充当了DHCP服务器。

DHCP分配IP地址的4个阶段:discover,发现服务器。发广播包,源IP是0.0.0.0,目标IP是255.255.255.255,目标MAC地址是FF:FF:FF:FF:FF:FF;offer提供租约。服务器返回可以租用的IP地址,以及租用期限,子网掩码、网关、DNS等信息。可能会有多个服务器提供租约;request,选择IP地址。客户端选择一个offer,发送广播包进行回应;ackNowledge,确认。被选中的服务器发送ACK数据包给客户端,IP地址分配完毕。

DHCP服务器可以跨网段分配IP地址吗?DHCP服务器、客户端不在同一个网段:可以借助DHCP中继代理,DHCP Relay Agent 实现跨网段分配IP地址。

自动续约:客户端会在租期不足的时候,自动向DHCP服务器发送Request信息申请续约。 ipconfig /all : 可以看到DHCP相关的详细信息,比如租约过期时间、DHCP服务器地址等。 ipconfig /release: 释放租约。 ipconfig /renew: 重新申请IP地址、申请续约(延长租期)。

HTTP,Hyper Text Transfer Protocol,超文本传输协议。最初用来发布和接收HTML,使用URI标识具体资源。 HTML,Hyper Text Markup Language ,超文本标记语言。

1991年HTTP/0.9只支持GET获取文本数据HTML。 1996年HTTP/1.0支持POST、HEAD等请求,支持请求头、响应头,支持更多种数据类型,不再局限于文本数据,并且浏览器每次请求需要与服务器建立一个TCP连接,请求处理完毕立即断开TCP连接。 1997年HTTP/1.1,最经典、使用最广泛的版本,支持PUT、DELETE等请求方式,采用持久连接Connection: keep-alive,多个请求可以共用同一个TCP连接。 2015年HTTP/2.0 2018年HTTP/3.0

HTTP标准RFC,Request For Comments,请求意见稿。使用ABNF语言描述HTTP请求格式。 报文格式:0A换行CR,0D回车LF,20空格。

请求行 -> 请求头 -> 请求体。

GET:常用于读取的操作,请求参数直接拼接在URL的后面,浏览器或服务器会对URL长度有限制。 POST:常用于添加、修改、删除的操作,请求参数可以放在请求体中,没有大小限制。 HEAD:请求得到与GET请求相同的响应,但没有响应体。使用场景:在下载一个大文件前,先获取其大小,再决定是否要下载,以此可以节约带宽资源。 OPTIONS:用于获取服务器(目的资源)所支持的通信选项,比如服务器支持的请求方法。OPTIONS * HTTP/1.1 。

PUT:用于对已存在的资源进行整体覆盖。 PATCH:用于对资源进行部分修改,资源不存在会创建新资源。 DELETE:用于删除指定的资源。 TRACE:请求服务器回显其收到的请求信息,主要用于HTTP请求的测试或诊断。 CONNECT:可以开启一个客户端与所请求资源之间的双向沟通的通道,可以用来创建隧道tunnel,可以用来访问采用了SSL/HTTPS协议的站点。

头部字段Header Field,分为四种:请求头字段 Request Header Fields、响应头字段 Response Header Fields、实体头字段 Entity Header Fields、通用头字段 General Header Fields。实体头字段 、通用头字段在请求头和响应头字段中包含。

请求头字段 Request Header Fields:User-Agent 浏览器的身份标识字符串;Host 服务器的域名、端口号;Date 发送该消息的日期和时间;Content-Type 请求体的类型;Content-Length 请求体的长度,单位字节;Referer:表示浏览器所访问的前一个页面。也就是这个页面从哪个页面点击跳转过来的,可以用来防止倒链,防止图片倒链;Accept 能够接受的响应内容类型 Content-Types,Accept: text/plain;Accept-Charset 能够接受的字符集, Accept-Charset: GB2312,utf-8;q=0.7,*;q=0.7 使用逗号隔开,q是权重优先级,没有设置是1.0最大;Accept-Encoding 能够接受的编码方式列表,Accept-Encoding: gzip, deflate;Accept-Language 能够接受的响应内容的自然语言列表,Accept-Language: en-US;Range 仅请求某个实体的一部分,字节偏移以0开始,Range: bytes=500-900,多线程断点下载;Connection 该浏览器想要优先使用的链接类型,Connection: keep-alive;

响应头字段 Response Header Fields:Date 发送该消息的日期和时间;Server 服务器的名字;Content-Type 响应体的类型,Content-Type: text/html; charset=UTF-8;Content-Encoding 内容所使用的编码类型 Content-Encoding: gzip;Content-Length 响应体的长度,字节为单位,Content-Length: 348;Content-Disposition 指定数据是文件类型,不要在浏览器中展示,直接进行下载,可以指定文件名,Content-Disposition: attachment; filename=“fname.jpg” ;Connection 针对该连接所预期的选项,Connection: close ;

状态码 Status Code 分为五类:信息响应100199,成功响应200299,重定向300399,客户端错误400499,服务器错误500~599。

100 Continue :服务器会根据请求头来判断是否接受客户端的请求,客户端先发送请求头,服务端判断接收请求,返回100 Continue,然后客户端再发送请求体,服务端接收请求体。 200 OK:请求成功。 302 Found:重定向,请求的资源被暂时移动到了由Location头部指定的URL上。 304 Not Modified:不需要再次传输请求的内容,也就是可以使用缓存的内容。 400 Bad Request:由于语法无效,服务器无法理解该请求。 401 Unauthorized:由于缺乏目标资源要求的身份验证凭证。 403 Forbidden:服务器端有能力处理该请求,但是拒绝授权访问。 404 Not Found:服务器端无法找到所请求的资源。 405 Method Not Allowed:服务器禁止了使用当前HTTP方法的请求。 406 Not Acceptable:服务器端无法提供与Accept-Charset以及Accept-Language 指定的值相匹配的响应。

500 Internal Server Error:所请求的服务器遇到意外的情况并阻止其执行请求。 501 Not Implemented:请求的方法不被服务器支持,因此无法被处理,服务器必须支持的方法只有GET和HEAD,也就是只有GET和HEAD方法不会返回这个状态码。 502 Bad Gateway:作为网关或代理角色的服务器,从上游服务器中接收的响应是无效的。 503 Service Unavailable:服务器尚未处于可以接受请求的状态,由于服务器停机维护或已超载。

form提交,常用属性: action,请求的URI;method,请求方法,GET、POST;enctype,POST请求时,请求体的编码方式,有application/x-www-form-urlencoded默认值,会用&分隔参数,用=分隔键和值,字符用urlencoded进行编码。还有文件上传必须使用multipart/form-data,变化是请求头Content-Type:multipart/form-data;boundary=,请求体会变复杂;

跨域问题的出现解决的问题:为了安全,不允许任意一个请求来源都能访问服务器资源。

请求头的 Origin 和响应头里面的 Access-Control-Allow-Origin 用于跨域:浏览器有个同源策略 Same-Origin Policy,规定默认AJAX异步请求只能发送同源的URL,同源指协议、域名/IP、端口相同。img、script、link、iframe、video、audio等标签不受同源策略影响。

解决AJAX跨域请求的常用方法:CORS,Cross-Origin Resource Sharing,跨域资源共享。CORS的实现需要客户端和服务器同时支持。客户端所有浏览器都支持,IE10以上。服务器需要返回响应头Access-Control-Allow-Origin,告诉浏览器这个请求允许跨域访问,也就是指定哪些来源网站可以跨域访问这个资源,Access-Control-Allow-Origin: *。 请求头Origin:告诉服务器我发起的请求的源头是什么,Origin:www.baidu.com。后端可以更加这个判断这个请求是否可以跨域。

请求头的Cookie和响应头里面的 Set-Cookie :HTTP是无状态的,每次请求是独立的,无法判断每个请求是否来自同一个浏览器。 Cookie和session是一起使用的,Cookie是存储在浏览器,session存储在服务器。 Set-Cookie: JSESSIONID=; 浏览器关闭 或者到了时间Cookie就会清除。请求中如果没有JSESSIONID 服务器就会创建新的Session对象,如果有JSESSIONID就会直接获取到Session对象。如果请求的cookie数据服务器判断有问题,就可以返回302重定向Location到登录页面。

代理服务器 Proxy Server :转发上下游的请求和响应,对于下游是服务器,对于上游是客户端。 正向代理:代理的对象是客户端。反向代理:代理的对象是服务器。 正向代理作用:隐藏客户端身份、绕过防火墙、访问权限控制、数据过滤。Fiddler、Charles等抓包工具是在客户端启动了正向代理服务。 反向代理作用:隐藏服务器身份、安全防护、负载均衡。

Wireshark的原理:通过底层驱动,拦截网卡上流过的数据。

网络安全:截获、中断、篡改、伪造。 网络层的ARP欺骗,ARP攻击: DoS攻击,拒绝服务攻击 Denial-of-Service attack:使目标电脑的网络或系统资源耗尽 ,使服务暂时中断或停止,导致其他正常用户无法访问。 DDoS攻击,分布式拒绝服务攻击,Distributed Denial-of-Service attack:黑客使用网络上两个或以上被攻陷的电脑作为僵尸/肉鸡向特定目标发动DoS攻击。

DoS攻击分为两类: 带宽消耗型:UDP洪水攻击、ICMP洪水攻击。 资源消耗型:SYN洪水攻击、LAND攻击。 SYN洪水攻击:攻击者发送一些列的SYN请求到目标,然后让目标因收不到ACK第3次握手而进行等待、消耗资源。 LAND攻击:。

防御方式使用防火墙:设置规则,拒绝特定通讯协议、端口或IP地址;拒绝攻击源IP发出的通信; 防火墙比较靠后,恶意攻击流量在到达防火墙之前,在到达路由器的时候已经被攻击。

应用层 DNS劫持:篡改了域名解析结果。使用比较靠谱的DNS服务器 114.114.114.114 。 HTTP劫持:对HTTP数据包进行拦截处理,比如插入JS代码,莫名的出现弹窗广告。

HTTP协议的安全问题:采用明文传输,有很大安全隐患。 提高安全的方法:对通信内容进行加密后再传输。

encrypt 加密、decrypt 解密、plaintext 明文、ciphertext 密文。 单向散列函数 One-way hash function:可以根据消息内容计算出散列值。散列值的长度和消息的长度无关,无论消息多大10M还是100G,都能计算出固定长度的散列值。单向不可逆。 也叫消息摘要函数 message digest function,哈希函数 hash function。输出的散列值也叫消息摘要 message digest,指纹 fingerprint。

单向散列函数的应用:防止数据被篡改;密码加密。

AES,Advanced Encryption Standard:取代DES的对称加密算法。长度有128、192、256bit三种。

如何解决对称秘钥配送问题:事先共享秘钥;秘钥分配中心;非对称加密 Asymmetric Cryptography;

非对称加密 Asymmetric Cryptography:公钥 public key、私钥 private key。加密解密速度比较慢。有:RSA。

A、B发送消息,A下发自己的公钥给B,B下发自己的公钥给A。当A给B发送消息,就使用自己的私钥加密消息,B收到后使用A下发的公钥解密,消息可能被其他人获取,但无法被篡改。B给A发送消息同样使用B自己的私钥。

混合密码系统:结合对称加密和非对称加密。为什么要结合使用:非对称加密效率不高,比较慢,但安全,对称加密快,但不安全,所以结合起来使用。

会话密钥 session key: 为某次通信随机生成的临时对称秘钥,用于加密消息,对称秘钥提高速度。

非对称加密步骤:首先,消息发送者获取消息接受者的公钥。然后生成会话密钥,对称密钥,加密消息。用消息接收者的公钥加密会话密钥。将前面生成的加密消息、公钥加密的会话密钥一起发送给消息接收者。 解密步骤:消息接收者使用公钥解密出会话密钥,然后使用会话密钥解密加密消息。

问题:消息接收者如何确定消息的真实性,如何识别篡改、伪装、否认? 解决方案:数字签名。

既然是加密,肯定是不希望别人知道我的消息,所以只有我才能解密。公钥负责加密,私钥负责解密。

数字签名过程: 生成签名:消息发送者通过 “签名密钥/私钥” 生成。 验证签名:消息接收者通过 “验证密钥/公钥” 验证。 如何保证这个签名是消息发送者自己签的?用消息发送者的私钥进行签名。

数字签名的过程: 消息发送者A使用自己的私钥对消息摘要进行加密,这个加密内容就是签名,发送消息、签名、公钥给消息接收者B。消息接收者B获取到消息,获取消息摘要,使用A的公钥解密签名,然后比对摘要是否相同。 签名解决的问题是:确认消息的完整性,识别消息是否被篡改,防止消息发送人否认。 数字签名中,任何人都可以使用公钥进行验证签名。

对消息摘要进行非对称加密,而不是直接对消息进行非对称加密。

既然是签名,肯定是不希望有人冒充我发消息,所以只有我才能签名。私钥负责签名,公钥负责验签。

非对称加密过程,公钥的合法性问题:遭到中间人攻击,公钥可能被伪造。 解决:证书 Certificate。公钥证书 Public-key Certificate,PKC,跟驾驶证类似。 包含姓名、邮箱等个人信息,以及公钥。由认证机构 Certificate Authority,CA添加数字签名,使用CA的私钥进行添加的数字签名。

CA就是能够认定 “公钥确实属于此人” 并能够生成数字签名的个人或组织。

证书的使用流程:消息接收者B生成秘钥对,B从CA注册自己的公钥,然后CA使用自己的私钥对B的公钥施加数字签名并生成证书。消息发送者A从CA获取证书,带有数字签名和B的公钥。A使用CA的公钥验证数字签名,确认B的公钥的合法性。然后A用B的公钥加密消息并发送给B。B接收到消息使用自己的私钥解密得到A的消息。

证书的注册和下载流程: 消息接受者B,也就是公钥注册者,拿着自己的公钥去CA注册。CA使用自己的私钥对B的公钥进行签名认证,生成证书。证书包括B的公钥、CA生成的数字签名、B的信息。证书保存到证书仓库,消息发送者A,也就是证书使用者,去证书仓库下载证书。

CA 的公钥,默认已经内置在浏览器和操作系统中。

HTTPS,HyperText Transfer Protocol Secure:默认端口443。在HTTP基础上加上 SSL/TLS 安全套接层,防止窃听和中间人攻击。

TLS,Transport Layer Security,前身是SSL,Secure Sockets Layer。SSL/TLS还可以用在其他协议上:FTPS、邮件协议 SMTPS。SSL/TLS 工作在应用层和传输层之间。SSL/TLS 分为:Handshake Layer层、Record Layer层。

OpenSSL是SSL/TLS协议的开源实现。可以使用OpenSSL构建一套自己的CA,自己给自己颁发证书,自签名证书。

生成私钥:openssl genrsa - out my.key 生成公钥:openssl rsa -in my.key -pubout -out my.pem

HTTPS 的通信过程,分为三大阶段: 1、TCP三次握手 2、TLS的连接 3、HTTP请求和响应

HTTP是明文传输。HTTPS就是在HTTP基础上加了,即HTTP->TLS/SSL->TCP->IP。https可以防止信息窃听、篡改、劫持,对信息进行加密、完整性校验和身份验证。https标准端口443。https基础传输层,http是基于应用层。

HTTPS主要作用:对数据进行加密,并建立一个信息安全通道,来保证传输过程中的数据安全;对网站服务器进行真实身份认证;

TCP:是面向连接、可靠的字节流服务。建立TCP连接需要三次握手。可靠基础是提供了:超时重发、丢弃重复数据、检验数据、流量控制,保证数据能从一端到另一端。 UDP:用户数据报协议,面向数据报的运输层协议。面向非连接的协议,不用与对方建立连接,直接把数据包发送过去。不需要建立连接,传输数据量少,没有超时重发机制,所以传输速度很快。

TCP三次握手:第一次,客户端发送syn包到服务器,并进入SYN_SEND状态,等待服务器确认;第二次,服务器收到syn包,必须确认客户的SYN,ack=j+1,同时自己也要发送一个SYN包,syn=k,即SYN+ACK包,此时服务器进入SYN_RECV状态;第三次,客户端收到服务器的SYN+ACK包,向服务器发送确认包ACK,ack=k+1,此包发送完毕,客户端和服务器进入established建立状态,完成三次握手。

客户端、服务端都可以主动发起断开TCP连接的请求。断开连接的四次挥手。

Socket:是一套完成TCP,UDP协议的接口。http是基于socket之上的。HTTP协议是基于TCP链接的。tcp协议:对应于传输层。IP协议:对应于网络层。TCP/IP主要解决数据在网络中如何传输;HTTP是应用层协议,主要解决如何包装数据。 Socket:是对TCP/IP协议的封装,Socket本省并不是协议,而是一个调用接口,通过Socket,我们才能使用TCP/IP协议。

HTTP连接:短连接,客户端向服务端发送一次请求,服务器响应后,主动释放连接。 Socket连接:长连接,客户端和服务端建立连接后,非异常情况不会断掉。异常情况有:服务端或客户端异常崩溃,网络故障,长时间没有数据传输,网络防火墙可能断开连接释放网络资源。所以当一个socket长连接中没有数据的传输时,为了维持连接需要发送心跳消息。

Socket建立网络连接的步骤:建立socket连接需要一对socket,一个运行在客户端ClientSocket,一个运行在服务端ServerSocket。第一,服务器监听,ServerSocket处于等待连接的状态,实时监控网络状态,等待客户端的链接请求;第二,客户端发送请求,ClientSocket连接服务端ServerSocket。客户端需要描述要连接的ServerSocket,包括地址、端口号;第三,连接确认,当ServerSocket监听到ClientSocket的连接请求,就响应客户端请求,建立一个新的线程,把ServerSocket的描述发送给ClientSocket,一旦双方确认了此描述,就正式建立连接。而ServerSocket继续处于监听状态,继续接收其他ClientSocket的连接请求;

问题:IM软件能够长时间在线,或者短时间内掉线,最好可以用户无感知。让IM软件维持在线的状态。用到了断线重连机制。 Socket 编程中的断线重连机制,GCDAsyncSocket,实现: IM软件能够始终尽可能的保持跟服务器的链接,客户端维护已登录状态,以便断线重连。从逻辑层次上来说,断线重连的逻辑是基于登录逻辑的,首次登录成功后,都有可能断线重连。步骤:第一,使客户端断线;第二,让客户端重连服务器。

客户端断线重连服务器情况:网络连接失败,网络不可用,收到iOS系统”网络可用”的通知;网络切换wifit->4G/5G情况;心跳失败,心跳超时,说明当前客户端和服务器连接已经损坏,或当前用户身份有变化。心跳失败后首先将客户端离线,然后进行断线重连操作,避免心跳失败和网络错误事件一并发生,造成两次登录;客户端重新启动,提前加载用户缓存的最近会话数据;IM软件后台运行被系统终止的情况,切换到前台;为了避免重复登录,在网络可用或者切换到前台的时候,IM处于登录成功、连接中、已注销等状态时,客户端不要重新连接。

心跳:客户端定时向Server发一个信令包,表示客户端还活着。心跳终止:1、Server主动断开socket,Server只接收客户端发起的心跳。Server长时间没有收到客户端的心跳,认为客户端已死,主动断开连接。此时客户端可能就是假在线;2、客户端断开socket,客户端多长时间发送一次心跳,客户端发送一次心跳,服务端长时间没有回应,网络不好,客户端需要主动离线,超时时间一般60秒。

远程推送APNS的过程:1、客户端将用户UUID和app的bundleID发送给APNS服务器,进行注册,ANPS将加密后的device Token返回给app;2、app获得device Token后,上传到公司服务器;3、当需要推送通知时,公司服务器会将推送内容和device Token 一起发送给APNS服务器;4、APNS再将推送内容推送到相应的客户端app上;

GET产生一个TCP数据包;POST产生两个TCP数据包,GET方式的请求,浏览器会把http header和data一并发送出去,服务器响应200(返回数据);POST,浏览器先发送header,服务器响应100 continue,浏览器再发送data,服务器响应200 ok(返回数据)。

分类:
iOS
标签:
分类:
iOS
标签:
收藏成功!
已添加到「」, 点击更改