精华内容
下载资源
问答
  • 很多人参军的目的就是希望在部队多干些时间,甚至干一辈子。至于怎么干?干什么?怎样才能留住?...现在是两年义务兵制,每月国家发给津贴,注意是津贴不是工资。一个月一千元左右,偏远地区有补...

    af3997320a1226ed48dc52f2bb05db68.png

    很多人参军的目的就是希望在部队多干些时间,甚至干一辈子。至于怎么干?干什么?怎样才能留住?是搞不清楚的,甚至是干部、士官和义务兵都不太清楚。

    以下我用我的大白话解释一下,只是意思到了啊,非官方的,也不够严谨。漏洞很多,别和我较真。

    8342984efe0cc0754991401c2bf3ec03.png

    义务兵:就是国家利用法律形式规定公民在一定的年龄内必须服一定期限的兵役,带有强制性。现在是两年义务兵制,每月国家发给津贴,注意是津贴不是工资。一个月一千元左右,偏远地区有补助,多少我不知道。

    士官:公民凭自愿应招到军队服兵役,并与军方签定服役合同。原来叫志愿兵,现在叫士官了,一期士官一直到六期士官。士官不是“官”,和义务兵一样都是属于战士的。

    385880d2da5a4bf7a160e7d2a6eb988f.png

    军官:其实部队里的更喜欢用“干部”干部这个词,一般与“战士”进行区别,最低级别是排长,最高目前是上将。分为行政干部和专业技术干部,行政干部就是所谓的军事、政工、后勤、装备等身份的干部,主要以带兵打仗,围绕军事行为为中心的,专业技术干部是以某项技术为主要专长的干部,如学校的教员、医院的医生、负责机要技术等。围绕着具体的某项工作为主。

    6228c97de9c32e3e619fba343d0e079c.png

    主要的区别:

    1、服役时间:义务兵一般为2年,士官按照签订的合同不同,服役时间从3年到十几到二十几年不等。军官按照军官法的规定,有年龄与职务的限制,到了一定的年龄升不了职就要退役。如排职30岁,连职35岁,团职45岁。

    2、在部队时的待遇。义务兵有津贴,一千元左右,偏远艰苦地区还有补助。士官有工资,有职务的还有岗位津贴,有探亲路费报销,结婚的还有两地分居补助等,该有的都有。军官有工资等,相对而言是待遇最好的。

    房子的问题,军官符合随军规定的可以分配公寓房,级别高的可以购买军队内部的经济适用房。士官也是可以有军官房子方面的待遇的,但是条件较高,能达到条件的还是少数的。但是,房子即使达到条件也不一定什么情况,有的地方可能很好分,如二三线城市。有的可能给你你还不要,如偏远地区。有的还要排队多年也不一定分得到,如一线大城市。

    3、退役:

    义务兵,两年后退役,有一笔退役费,由退役金、当月的伙食费、津贴,保险等组成。退役后大学生在校生可以在两年内选择复学,也可以改专业等。

    8046f49921076cf3d1f9c1305c08f570.png

    士官,根据签订合同情况,不能晋升为下一级的自动退役。退役金也是有的,要比义务兵高很多,一二期士官除了多拿点钱,其他的没什么了。三期以上的有两种选择,一种是由国家安排工作,这样拿的钱就少,也可以自谋职业,不让国家安排工作,这样可以多拿一些钱,最少几十万吧。具体数额根据服役地区和年限等不一样。如西藏服役的,肯定拿的多,四期肯定比三期拿的多。

    战士有的地区是可以参加政法干警考试的,有的当地会招录部分退役士兵补充到政法部门,具体都是当地的政策。新疆等地也在招聘退役士兵的。

    c1f98b3f5ec66373c8873c734293ded3.png

    军官,根据服役年限和职务的限制进行退役,或者根据单位的具体安排退役。一般情况下,职务低的排连职的干部想转业是有难度的,除非自己真的是不想干了。退役有四种方式,一是转业,由国家安排工作,二是自主择业,服役期达到二十年以上的营团职干部可以选择由国家每月发给退役金,自己再自由选择。我就是自主择业的,正赶上军队改革,18年就可以。三是按照战士复原。这个很少这样的,相当于放弃了干部的身份。有利有弊,根据自己的情况吧,不做判断。四是选择改文职,和部队签合同。这个选择有点别扭的,身份变了,我身边的好多人都不愿改,前几年想让转业的改,好像不太成功,现在正在大批量的进行社会招聘。

    4、晋级之路:

    义务兵,当地或者就读学校报名入伍,按照程序就好了。

    士官,一种是义务兵转改,当完两年义务兵,自己有留队意愿,部队也需要,就可以了。二就是直招士官,招收相关专业的毕业生经过短期培训后到部队直接成为士官,三是招收想入伍成为士官的学生到相应的学习进行学习,毕业后进入部队成为士官。四是义务兵参加士官学校的考试,通过学习后毕业成为士官,这种方式的好处是一般可以确保到达三期。

    现在士官的比例在加大,想留士官的还是比前些年容易很多的,但是对于指挥士官是有瓶颈的,到达三期以后改四期就难度很大了。技术士官倒是要好一些。关于指挥士官和技术士官的区别,字面的意思你应该能看懂,指挥就是带兵的,没有什么专业,当班长、甚至代理排长或者参谋等。

    军官,义务兵第二年或者一期士官第一年考军校,可以参照我以前写的文章。

    煎饼卷带鱼:军校、军校、军校,你关心的军考问题在这里!zhuanlan.zhihu.com
    a695338fe6b3f01d9440ca8a9cb8df26.png

    也可以直接提干,今年2020年开始双一流的学生可以入伍后直接提干,这是新政策,其他的都需要一定的条件了,比如学历、立功情况等,以后有时间再写。以前还有一种方式就是招收国防生,在地方学校学习几年,实习一段时间,毕业后和部队签合同,成为军官。

    军官是有职务的,一级一级的升,要看机遇、能力等很多方面的因素,差别很大,有的在一个职务上干五六年,有的干个一两年,各种条件有能左右的,有的真的没办法。我就在正连的岗位上干了五年,唉!想想真的是不服气的,可是不服气有个屁用。我还见过干七年的呢。

    写在最后:看明白了吗?有的事是不以个人意愿为转移的,你想留队也好、考学也罢,都是要看天时地利与人和!就是一个职务的晋升也要有很大的竞争。自己的能力和表现是一个方面,现实的条件更重要。任何事在想的基础上都是要实干加巧干,再加上一个好的机遇的。

    以上内容基于我自己的理解和记忆,不足之处有很多,不要拿文件来和我理论,真的没有时间,谢谢理解!

    有不明白的欢迎私信我,或者关注我在其他文章里查找我的联系方式,我会尽力回答。

    展开全文
  • 算法题归纳整理-python

    2020-09-04 09:37:25
    先问清题目,各方面各种问,题目是什么意思,希望你干什么,你的api以后要拿到怎么用,给谁用? 确认方法的输入输出,希望收到什么样的参数?如果不是这种参数怎么处理,输出什么样的结果?结果的范围是? 和面试官...


    先问清题目,各方面各种问,题目是什么意思,确认方法的输入输出,希望收到什么样的参数?如果不是这种参数怎么处理,输出什么样的结果?结果的范围是?
    和面试官确认边界条件,上限是什么?下限是什么?corner case要充分讨论
    写代码时最好不断交流,嘴巴里要说,别就只顾着写
    最后要给面试官算法复杂度,注意,这里一定要说清楚是最好、平均、最坏,用词要严谨,这些都是细节

    快排

    最小的k个数

    输入整数数组 arr ,找出其中最小的 k 个数。
    输入:arr = [0, 8, 0, 3, 8, 2, 5], k=4
    输出:[0, 0, 2, 3]
    输入:arr = [0, 0, 1, 3, 4, 5, 0, 7, 6, 7], k=9
    输出:[0, 0, 0, 1, 3, 4, 5, 6, 7]

    若第k小的值出现在左侧向左递归,出现在右侧向右递归。
    时间复杂度,N + N/2 + N/4 + ... + N/N = 2N, 最好O(N),最坏O(n^2)
    
    def smallestK(arr: list, k: int):
        if k == 0:
            return []
        if k == len(arr):
            return arr
    
        left, right = 0, len(arr) - 1
        while left < right:
            pivot = partition(arr, left, right)
            if pivot < k - 1:
                left = pivot + 1
            elif pivot > k - 1:
                right = pivot - 1
            else:
                return arr[:k]
        return arr[:left + 1]
    
    
    def partition(array, left, right):
        pivot = array[right]
        i = left
        for j in range(left, right):
            if array[j] < pivot:
                array[j], array[i] = array[i], array[j]
                i += 1
        array[right], array[i] = array[i], array[right]
        return i
    
    
    最接近原点的 K 个点

    我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。
    输入:points = [[3,3],[5,-1],[-2,4]], K = 2
    输出:[[3,3],[-2,4]]

    复杂度分析:
    时间复杂度 O(N) 
    空间复杂度 O(N)
    
    def kClosest(points, K):
        def dist(i):
            return points[i][0] ** 2 + points[i][1] ** 2
    
        def work(i, j, K):
            if i >= j:
                return
            oi, oj = i, j
            pivot = dist(i)
            basePoint = points[i]
    
            while i < j:
                while i < j and dist(j) >= pivot:
                    j -= 1
                points[i] = points[j]
                while i < j and dist(i) <= pivot:
                    i += 1
                points[j] = points[i]
            points[i] = basePoint
    
            if K < i + 1 - oi:
                work(oi, i - 1, K)
            else:
                work(i + 1, oj, K - (i + 1 - oi))
    
        work(0, len(points) - 1, K)
        return points[:K]
    
    
    

    回溯

    全排列

    输入:s = “abc”
    输出:[‘abc’, ‘acb’, ‘bac’, ‘bca’, ‘cab’, ‘cba’]

    复杂度分析:
    时间复杂度 O(N!) : N 为字符串 s 的长度;时间复杂度和字符串排列的方案数成
    线性关系,方案数为 N * (N-1) * (N-2) … *2 * 1, ,因此复杂度为 O(N!) 。
    空间复杂度 O(N^2): 全排列的递归深度为 N ,系统累计使用栈空间大小为 O(N) ;
    递归中累计存储的字符数量最多为 N + (N-1) + ... + 2 + 1 = (N+1)N/2,占用 
    O(N^2) 的额外空间。
    
    def permutation(s):
        s_list = sorted(s)
        res = []
    
        def backtrack(s_list, tmp):
            if not s_list:
                res.append("".join(tmp))
            for i in range(len(s_list)):
                if i > 0 and s_list[i] == s_list[i - 1]:
                    continue
                backtrack(s_list[:i] + s_list[i + 1:], tmp + [s_list[i]])
    
        backtrack(s_list, [])
        return res
    
    
    组合总和

    给定一个无重复元素的数组 nums 和一个目标数 target ,找出 nums 中所有可以使数字和为 target 的组合。
    nums 中的数字可以无限制重复被选取。
    输入:nums=[2, 3, 6, 7], target=7
    输出:[[2, 2, 3], [7]]

    
    def combinationSum(nums, target: int):
        nums = sorted(nums)
        res = []
    
        def backtrack(s, use, remain):
            for i in range(s, len(nums)):
                if nums[i] == remain:
                    res.append(use + [nums[i]])
                elif nums[i] < remain:
                    backtrack(i, use + [nums[i]], remain - nums[i])
                else:
                    return
    
        backtrack(0, [], target)
    
        return res
    
    

    动态规划

    股票的最大利润

    给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格。
    如果你最多只允许完成一笔交易(即买入和卖出一支股票一次),设计一个算法来计算你所能获取的最大利润。
    输入: [7, 1, 5, 3, 6, 4]
    输出: 5

    复杂度分析:
    时间复杂度 O(N) : 其中 N 为 prices 列表长度,动态规划需遍历 prices 。
    空间复杂度 O(1) : 变量 cost 和 profit 使用常数大小的额外空间。
    
    def maxProfit(prices):
        cost, profit = prices[0], 0
        for price in prices:
            cost = min(cost, price)
            profit = max(profit, price - cost)
        return profit
    
    股票的最大利润II

    给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格。
    你可以尽可能地完成更多的交易(多次买卖一支股票)。设计一个算法来计算你所能获取的最大利润。
    注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。
    输入: [7,1,5,3,6,4]
    输出: 7

    复杂度分析:
    时间复杂度 O(N) : 其中 N 为 prices 列表长度,动态规划需遍历 prices 。
    空间复杂度 O(1) : 变量 cost 和 profit 使用常数大小的额外空间。
    
    def maxProfit(prices):
        profit = 0
        for i in range(1, len(prices)):
            tmp = prices[i] - prices[i - 1]
            if tmp > 0:
                profit += tmp
        return profit
    
    礼物的最大价值

    在一个 m*n 的棋盘的每一格都放有一个礼物,每个礼物都有一定的价值(价值大于 0)。你可以从棋盘的左上角开始拿格子里的礼物,并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值,请计算你最多能拿到多少价值的礼物
    输入:
    [
    [1, 3, 1],
    [1, 5, 1],
    [4, 2, 1]
    ]
    输出: 12

    """
    解题思路:每个位置的最大值等于左侧和上方的最大值加当前值,最后返回右下角的结果即可。
    复杂度分析:
    时间复杂度 O(MN) : M,N分别为矩阵行高列宽,动态规划需遍历整个grid矩阵,使用 O(MN)时间。
    空间复杂度 O(1) : 原地修改使用常数大小的额外空间。
    """
    def maxValue(grid) -> int:
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if i == 0 and j == 0:
                    continue
                if i == 0:
                    grid[i][j] += grid[i][j - 1]
                elif j == 0:
                    grid[i][j] += grid[i - 1][j]
                else:
                    grid[i][j] += max(grid[i][j - 1], grid[i - 1][j])
        return grid[-1][-1]
        
    
    青蛙跳台阶问题

    一只青蛙一次可以跳上1级台阶,也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

    答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。

    复杂度分析:
    时间复杂度 O(N) : 计算 f(n) 需循环 n 次,每轮循环内计算操作使用 O(1) 。
    空间复杂度 O(1) : 几个标志变量使用常数大小的额外空间。
    由于 Python 中整形数字的大小限制取决计算机的内存 (可理解为无限大),因此可不考虑大数
    越界问题。
    
    def numWays(n: int) -> int:
            a, b = 1, 1
            for _ in range(n):
                a, b = b, a + b
            return a% 1000000007
            
    PS : 为什么要模1000000007(跟我念,一,八个零,七)。
    大数相乘,大数的排列组合等为什么要取模
    1000000007是一个质数(素数),对质数取余能最大程度避免结果冲突/重复
    
    
    三步问题

    三步问题。有个小孩正在上楼梯,楼梯有n阶台阶,小孩一次可以上1阶、2阶或3阶。实现一种方法,计算小孩有多少种上楼梯的方式。结果可能很大,你需要对结果模1000000007。
    输入:n = 5
    输出:13

    状态转移方程 f(i)=f(i-1)+f(i-2)+f(i-3)
    时间复杂度 O(N)  
    空间复杂度 O(1) 
    
    def waysToStep(n: int):
        a, b, c = 1, 2, 4
        if n < 3:
            return n
        if n == 3:
            return 4
        for i in range(n - 3):
            a, b, c = b, c, (a + b + c) % 1000000007
        return c
    
    最长不含重复字符的子字符串

    请从字符串中找出一个最长的不包含重复字符的子字符串,计算该最长子字符串的长度。
    输入: “abcabcbb”
    输出: 3

    复杂度分析:
    时间复杂度 O(N): 其中 N 为字符串长度,动态规划需遍历计算 dp 列表。
    空间复杂度 O(1) : 字符的 ASCII 码范围为 0 ~ 127 ,哈希表 dic 最多使用 
    O(128) = O(1)大小的额外空间
    def lengthOfLongestSubstring(s: str):
        dic, res, tmp = {}, 0, 0
        for j in range(len(s)):
            i = dic.get(s[j], -1)  # 获取索引 i
            dic[s[j]] = j  # 更新哈希表
            tmp = tmp + 1 if tmp < j - i else j - i  # dp[j - 1] -> dp[j]
            res = max(res, tmp)  # max(dp[j - 1], dp[j])
        return res
    
    
    复杂度分析:
    时间复杂度 O(N): 其中 N 为字符串长度,遍历计算 dp 列表。
    空间复杂度 O(1) 
    # 双指针
    def lengthOfLongestSubstring(s: str):
        dic, res, i = {}, 0, -1
        for j in range(len(s)):
            if s[j] in dic:
                i = max(dic[s[j]], i)  # 更新左指针 i
            dic[s[j]] = j  # 哈希表记录
            res = max(res, j - i)  # 更新结果
        return res
    
    按摩师

    一个有名的按摩师会收到源源不断的预约请求,每个预约都可以选择接或不接。在每次预约服务之间要有休息时间,因此她不能接受相邻的预约。给定一个预约请求序列,替按摩师找到最优的预约集合(总预约时间最长),返回总的分钟数。

    输入:[2, 7, 9, 3, 1]
    输出: 12
    解释: 选择 1 号、 3 号和 5 号预约,总时长 = 2 + 9 + 1 = 12。

    输入: [2, 1, 4, 5, 3, 1, 1, 3]
    输出: 12
    解释: 选择 1 号、 3 号、 5 号和 8 号预约,总时长 = 2 + 4 + 3 + 3 = 12。

    时间复杂度:O(n),其中 n 为预约的个数。我们有 2n 个状态需要计算,每次状态
    转移需要 O(1) 的时间,所以一共需要 O(2n)=O(n) 的时间复杂度。
    空间复杂度:O(1),只需要常数的空间存放若干变量。
    
    def massage(nums) -> int:
        dp0, dp1 = 0, 0
        for i in range(len(nums)):
            dp0, dp1 = dp1, max(dp0 + nums[i], dp1)
        return dp1
        
    
    零钱兑换

    给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数
    输入:coins = [1, 2, 5], amount = 11
    输出:3

    时间复杂度:O(Sn),其中 S 是金额,n 是面额数。我们一共需要计算 O(S) 个状态,S 为题目所给的总金额。对于每个
    状态,每次需要枚举 n 个面额来转移状态,所以一共需要 O(Sn)的时间复杂度。
    空间复杂度:O(S)。DP 数组需要开长度为总金额 S 的空间。
    
    def coinChange(coins, amount: int) -> int:
        dp = [float('inf')] * (amount + 1)
        dp[0] = 0
    
        for coin in coins:
            for x in range(coin, amount + 1):
                dp[x] = min(dp[x], dp[x - coin] + 1)
        return dp[amount] if dp[amount] != float('inf') else -1
        
    
    零钱兑换 II

    给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

    输入: amount = 5, coins = [1, 2, 5]
    输出: 4
    解释: 有四种方式可以凑成总金额:
    5=5
    5=2+2+1
    5=2+1+1+1
    5=1+1+1+1+1

    时间复杂度:O(N×amount)。其中 N 为 coins 数组的长度。
    空间复杂度:O(amount),dp 数组使用的空间。
    
    def change(coins, amount: int) -> int:
        dp = [0] * (amount + 1)
        dp[0] = 1
    
        for coin in coins:
            for x in range(coin, amount + 1):
                dp[x] += dp[x - coin]
        return dp[amount]
    
        
    

    二分法

    在排序数组中查找数字 I

    统计一个数字在排序数组中出现的次数。
    输入: nums = [5, 7, 7, 8, 8, 10], target=8
    输出: 2

    """复杂度分析:
    时间复杂度 O(log N): 二分法为对数级别复杂度。
    空间复杂度 O(1) : 几个变量使用常数大小的额外空间。"""
    
    def search(nums, target):
        # 搜索右边界right
        i, j = 0, len(nums) - 1
        while i <= j:
            m = (i + j) // 2
            if nums[m] <= target:
                i = m + 1
            else:
                j = m - 1
        right = i
    
        # 搜索左边界 left
        i = 0
        while i <= j:
            m = (i + j) // 2
            if nums[m] < target:
                i = m + 1
            else:
                j = m - 1
        left = j
        
        return right - left - 1
    
    
    旋转数组的最小数字

    把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。输入一个递增排序的数组的一个旋转,输出旋转数组的最小元素。
    输入:[3,4,5,1,2]
    输出:1

    复杂度分析:
    时间复杂度 O(log_2 N) : 在特例情况下(例如 [1, 1, 1, 1],会退化到 O(N)。
    空间复杂度 O(1) : i, j , m 指针使用常数大小的额外空间。
    
    def minArray(numbers: [int]) -> int:
            i, j = 0, len(numbers) - 1
            while i < j:
                m = (i + j) // 2
                if numbers[m] > numbers[j]:
                    i = m + 1
                elif numbers[m] < numbers[j]:
                    j = m
                else:
                    j -= 1
            return numbers[i]
    
    0~n-1中缺失的数字

    一个长度为n-1的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围0~n-1之内。在范围0~n-1内的n个数字中有且只有一个数字不在该数组中,请找出这个数字。
    输入: [0,1,3]
    输出: 2

    时间复杂度 O(log N): 二分法为对数级别复杂度。
    空间复杂度 O(1): 几个变量使用常数大小的额外空间。
    
    def missingNumber(nums) -> int:
        i, j = 0, len(nums) - 1
        while i <= j:
            m = (i + j) // 2
            if nums[m] == m:
                i = m + 1
            else:
                j = m - 1
        return i
    
    
    

    双指针

    两数之和

    输入:nums = [2, 7, 11, 15], target=9
    输出:[2,7] 或者 [7,2]

    时间复杂度 O(N) : N 为数组 numsnums 的长度;双指针共同线性遍历整个数组。
    空间复杂度 O(1) : 变量 i, j 使用常数大小的额外空间。
    
    def twoSum(nums, target):
        i, j = 0, len(nums) - 1
        while i < j:
            s = nums[i] + nums[j]
            if s > target:
                j -= 1
            elif s < target:
                i += 1
            else:
                return nums[i], nums[j]
        return []
    
    时间复杂度 O(N) : N 为数组 numsnums 的长度;
    空间复杂度 O(N) :额外空间
    def twoSum1(nums, target):
        dct = {}
        for i, n in enumerate(nums):
            if target - n in dct:
                return target - n, n
            dct[n] = i
    
    
    调整数组顺序使奇数位于偶数前面

    输入:nums = [1,2,3,4]
    输出:[1,3,2,4] 或 [3,1,2,4]

    复杂度分析:
    时间复杂度 O(N): N 为数组 nums长度,双指针 i, j 共同遍历整个数组。
    空间复杂度 O(1): 双指针 i, j 使用常数大小的额外空间。
    
    def exchange(nums):
        m, n = 0, len(nums) - 1
        while m < n:
            if nums[m] % 2 == 0:
                nums[m], nums[n] = nums[n], nums[m]
                n -= 1
            else:
                m += 1
        return nums
    
    和为s的连续正数序列

    输入一个正整数 target ,输出所有和为 target 的连续正整数序列(至少含有两个数)。
    序列内的数字由小到大排列,不同序列按照首个数字从小到大排列。

    输入:target = 9
    输出:[[2,3,4],[4,5]]

    滑动窗口解法
    复杂度
    时间复杂度 O(target): 终点至少需要遍历到target//2+1
    空间复杂度 O(1): 只使用了几个变量(结果数组使用的空间不计入内)
    
    def findContinuousSequence(target: int):
        i, j, res = 1, 2, []
        while j <= target // 2 + 1:
            # 一个大于1的正整数,总是小于,它的中值加上一个比中值大的数。
            cur_sum = sum(list(range(i, j + 1)))
            if cur_sum < target:
                j += 1
            elif cur_sum > target:
                i += 1
            else:
                res.append(list(range(i, j + 1)))
                # 这里用j+=1,i+=1,i+=2都可以,因为是连续的正数序列,所以当sum==target
                时, i+1 开头的序列一定无解,左边界可以直接向右移动两位,即i+=2
                i += 2
        return res
    
    盛最多水的容器

    给你 n 个非负整数 a1,a2,…,an,每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。

    输入:[1, 8, 6, 2, 5, 4, 8, 3, 7]
    输出:49

    复杂度分析:
    时间复杂度 O(N): 双指针遍历一次底边宽度 N 。
    空间复杂度 O(1): 指针使用常数额外空间。
    
    def maxArea(height) -> int:
        res, i, j = 0, 0, len(height) - 1
        while i < j:
            if height[i] < height[j]:
                res = max(res, height[i] * (j - i))
                i += 1
            else:
                res = max(res, height[j] * (j - i))
                j -= 1
        return res
    

    二叉搜索树

    树的遍历方式总体分为两类:深度优先搜索(DFS)、广度优先搜索(BFS);
    常见的 DFS : 先序遍历、中序遍历、后序遍历;
    常见的 BFS : 层序遍历(按层遍历)。

    给定二叉树 [3,9,20,null,null,15,7],
    3
    / \
    9 20
    / \
    15 7
    返回它的最大深度 3 。

    class TreeNode:
        def __init__(self, x):
            self.val = x
            self.left = None
            self.right = None
    
    二叉树的深度

    输入一棵二叉树的根节点,求该树的深度。从根节点到叶节点依次经过的节点(含根、叶节点)形成树的一条路径,最长路径的长度为树的深度。

    方法一:后序遍历(DFS)
    时间复杂度 O(N) : N 为树的节点数量,计算树的深度需要遍历所有节点。
    空间复杂度 O(N): 最差情况下(当树退化为链表时),递归深度可达到 N 。
    class Solution:
        def maxDepth(self, root: TreeNode) -> int:
            if not root:
                return 0
            return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
            
    
    方法二:层序遍历(BFS)
    时间复杂度 O(N) : N 为树的节点数量,计算树的深度需要遍历所有节点。
    空间复杂度 O(N) : 最差情况下(当树平衡时),队列 queue 同时存储 N/2 个节点。
    class Solution:
        def maxDepth(self, root: TreeNode) -> int:
            if not root: 
                return 0
            queue, res = [root], 0
            while queue:
                tmp = []
                for node in queue:
                    if node.left: 
                        tmp.append(node.left)
                    if node.right: 
                        tmp.append(node.right)
                queue = tmp
                res += 1
            return res
    
    二叉树的深度

    从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。

    层序遍历(BFS)
    时间复杂度 O(N) : N 为二叉树的节点数量,即 BFS 需循环 N 次。
    空间复杂度 O(N) : 最差情况下,即当树为平衡二叉树时,最多有 N/2 个树节点同时在 queue 中,使用 O(N) 大小的额外空间。
    
    class Solution:
        def levelOrder(self, root: TreeNode):
            if not root: 
                return []
            res, queue = [], collections.deque()
            queue.append(root)
            while queue:
                node = queue.popleft()
                res.append(node.val)
                if node.left: 
                    queue.append(node.left)
                if node.right: 
                    queue.append(node.right)
            return res
    
    二维数组中的查找

    在一个 n * m 的二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
    现有矩阵 matrix 如下:
    [
    [1, 4, 7, 11, 15],
    [2, 5, 8, 12, 19],
    [3, 6, 9, 16, 22],
    [10, 13, 14, 17, 24],
    [18, 21, 23, 26, 30]
    ]
    给定 target = 5,返回 true。
    给定 target = 20,返回 false。

    复杂度分析:
    时间复杂度 O(M+N) :其中,N 和 M 分别为矩阵行数和列数,此算法最多循环 M+N 次。
    空间复杂度 O(1) : i, j 指针使用常数大小额外空间。
    def findNumberIn2DArray(matrix: list, target: int) -> bool:
            i, j = len(matrix) - 1, 0
            while i >= 0 and j < len(matrix[0]):
                if matrix[i][j] > target: 
                    i -= 1
                elif matrix[i][j] < target: 
                    j += 1
                else: 
                    return True
            return False
    

    链表

    # Definition for singly-linked list.
    class ListNode:
         def __init__(self, x):
             self.val = x
             self.next = None
    
    环形链表

    给定一个链表,判断链表中是否有环。

    class Solution:
        def hasCycle(self, head: ListNode) -> bool:
            slow = fast = head 
            while fast and fast.next:
                slow = slow.next
                fast = fast.next.next
                if slow == fast:
                    return True
            return False
    
    环形链表 II

    给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。

    class Solution(object):
        def detectCycle(self, head):
            fast, slow = head, head
            while True:
                if not (fast and fast.next): 
                    return
                fast, slow = fast.next.next, slow.next
                if fast == slow:
                    break
            fast = head
            while fast != slow:
                fast, slow = fast.next, slow.next
            return fast
    
    相交链表

    找到两个单链表相交的起始节点。

    class Solution:
        def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
            ha, hb = headA, headB
            while ha != hb:
                ha = ha.next if ha else headB
                hb = hb.next if hb else headA
            return ha
    
    删除链表的倒数第N个节点

    删除链表的倒数第 n 个节点,并且返回链表的头结点。

    class Solution:
        def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
            dummy = ListNode(0, head)
            first = head
            second = dummy
            for i in range(n):
                first = first.next
    
            while first:
                first = first.next
                second = second.next
            
            second.next = second.next.next
            return dummy.next
    
    反转链表
    双指针
    class Solution:
        def reverseList(self, head: ListNode) -> ListNode:
            if not head:
                return head
            pre=None
            cur=head
            while cur:
                # cur=cur.next
                # pre=cur
                # cur.next=pre
                cur.next, pre, cur = pre, cur, cur.next
            return pre
    
    递归
    class Solution:
        def reverseList(self, head: ListNode) -> ListNode:
            def helper(last,cur):
                if not cur: 
                	return last
                nex = cur.next
                cur.next = last           
                return helper(cur,nex)
            return helper(None,head)
    
    移除链表元素

    删除链表中等于给定值 val 的所有节点。

    class Solution:
        def removeElements(self, head: ListNode, val: int) -> ListNode:
            ans = ListNode(0)
            ans.next = head
            prev, curr = ans, head
            while curr:
                if curr.val == val:
                    prev.next = curr.next
                else:
                    prev = curr
                curr = curr.next
            return ans.next
    
    奇偶链表

    给定一个单链表,把所有的奇数节点和偶数节点分别排在一起。请注意,这里的奇数节点和偶数节点指的是节点编号的奇偶性,而不是节点的值的奇偶性。

    class Solution:
        def oddEvenList(self, head: ListNode) -> ListNode:
            if not head:
                return head
            odd = head
            even_head = even = head.next
            while odd.next and even.next:
                odd.next = odd.next.next
                even.next = even.next.next
                odd, even = odd.next, even.next
            odd.next = even_head
            return head
    
    
    回文链表

    请判断一个链表是否为回文链表。
    示例 1:
    输入: 1->2
    输出: false
    示例 2:
    输入: 1->2->2->1
    输出: true

    # 快节点每次走两步,走的同时,反转前半部分的链表。然后逐一比较后半部分和前半部分的值。
    class Solution:
        def isPalindrome(self, head: ListNode) -> bool:
            slow, fast, prev = head, head, None
            while fast and fast.next:
                fast = fast.next.next
                slow.next, slow, prev = prev, slow.next, slow
            if fast:
                slow = slow.next
            while prev and prev.val == slow.val:
                prev, slow = prev.next, slow.next
            return prev is None
    
    
    合并两个有序链表

    将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

    class Solution:
        def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
            cur = dum = ListNode(0)
            while l1 and l2:
                if l1.val < l2.val:
                    cur.next, l1 = l1, l1.next
                else:
                    cur.next, l2 = l2, l2.next
                cur = cur.next
            cur.next = l1 if l1 else l2
            return dum.next
    
    

    其他

    数组中重复的数字

    先问面试官要时间/空间需求!!!
    是否可以使用额外空间,是否可以修改原始数组
    只是时间优先就用set,
    还有空间要求O(1)原地hash
    空间要求O(1)并且不能修改原数组,使用二分法

    在一个长度为 n 的数组 nums 里的所有数字都在 0~n-1 的范围内。数组中某些数字是重复的,找出数组中重复的数字。
    输入:[2, 3, 1, 0, 2, 5, 3]
    输出:2 或 3

    # 哈希表 时间O(n),空间O(n)
    def findRepeatNumber(nums) :
        s = set()
        for num in nums:
            if num in s:
                return num 
            s.add(num)  
                
    # 原地hash,时间O(n),空间O(1)
    def findRepeatNumber(nums):
        for idx, val in enumerate(nums):
            if idx != val and nums[val] == val:
                return val
            nums[val], nums[idx] = nums[idx], nums[val]
    
    
    数组中出现次数超过一半的数字

    数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。
    输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
    输出: 2

    摩尔投票法:
    票数和: 由于众数出现的次数超过数组长度的一半,若记众数的票数为 +1,非众数的票数为 −1 ,
    则一定有所有数字的 票数和 > 0 。
    票数正负抵消: 设数组 nums 中的众数为 x ,数组长度为 n 。若 nums 的前 a 个数字的 
    票数和 =0 ,则数组后 (n−a) 个数字的票数和一定仍 >0 (即后 (n-a)个数字的 众数仍为 x )。
    
    复杂度分析:
    时间复杂度 O(N) : N 为数组 nums 长度。
    空间复杂度 O(1) : votes 变量使用常数大小的额外空间。
    
    def minArray(nums: [int]) -> int:
        votes, flag = 0, 0
        for v in nums:
            if votes == 0:
                flag = v
            if v == flag:
                votes += 1
            else:
                votes -= 1
        return flag if nums.count(flag) > len(nums) // 2 else None
        
    
    用两个栈实现队列

    用两个栈实现一个队列。队列的声明如下,请实现它的两个函数 appendTail 和 deleteHead ,分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素,deleteHead 操作返回 -1 )

    复杂度分析:
    由于问题特殊,以下分析仅满足栈初始和结束状态下都为空的情况。
    时间复杂度:对于插入和删除操作,时间复杂度均为 O(1)。插入不多说,对于删除操作,虽然看
    起来是 O(n) 的时间复杂度,但是仔细考虑下每个元素只会「至多被插入和弹出 stack2 一次」,
    因此均摊下来每个元素被删除的时间复杂度仍为 O(1)。
    空间复杂度:O(n),需要使用两个栈存储已有的元素。
    
    class CQueue:
        def __init__(self):
            self.A, self.B = [], []
    
        def appendTail(self, value: int):
            self.A.append(value)
    
        def deleteHead(self):
            if self.B: 
            	return self.B.pop()
            if not self.A: 
            	return -1
            while self.A:
                self.B.append(self.A.pop())
            return self.B.pop()
    
    
    滑动窗口的最大值

    给定一个数组 nums 和滑动窗口的大小 k,请找出所有滑动窗口里的最大值。
    输入: nums = [1, 3, -1, -3, 5, 3, 6, 7], k=3
    输出: [3, 3, 5, 5, 6, 7]

    单调队列
    复杂度分析:
    时间复杂度 O(n) : 其中 n 为数组 nums 长度;线性遍历 nums 占用 O(N) ;每个元素最多
    仅入队和出队一次,因此单调队列 deque 占用 O(2N) 。
    空间复杂度 O(k) :  deque中最多同时存储 k 个元素(即窗口大小)。
    
    def maxSlidingWindow(nums, k: int):
        res, deque = [], []
        for i, v in enumerate(nums):
            if i >= k and deque[0] <= i - k:
                deque.pop(0)
            # 只存有可能成为最大值的数字的index进deque
            while deque and nums[deque[-1]] <= v: 
                deque.pop()
            deque.append(i)
            if i >= k - 1:
                res.append(nums[deque[0]])
        return res
    
    
    第一个只出现一次的字符

    在字符串 s 中找出第一个只出现一次的字符。如果没有,返回一个单空格。
    s 只包含小写字母。
    输入: s = “abaccdeff”
    输出: 返回 “b”

    复杂度分析:
    时间复杂度 O(N) : N 为字符串 s 的长度;需遍历 s 两轮,使用 O(N) ;HashMap 查找的
    操作复杂度为 O(1) ;
    空间复杂度 O(N): HashMap 使用 O(N) 大小的额外空间。
    
    def firstUniqChar(s: str):
        dicts = {}
        for i in s:
            dicts[i] = dicts.get(i, 0) + 1
        for i in s:
            if dicts[i] == 1:
                return i
        return ' '
    
    def firstUniqChar(s: str):
        dic = {}
        for i in s:
            dic[i] = i not in dic
        for i in s:
            if dic[i]:
                return i
        return ""
    
    
    
    汉诺塔问题

    输入:A = [2, 1, 0], B = [], C = []
    输出:C = [2, 1, 0]

    输入:A = [1, 0], B = [], C = []
    输出:C = [1, 0]

    def hanota(A, B, C):
        def hanoi(n, x, y, z):
            if n == 1:
                z.append(x.pop())
                return
            else:
                hanoi(n - 1, x, z, y)
                hanoi(1, x, y, z)
                hanoi(n - 1, y, x, z)
    
        hanoi(len(A), A, B, C)
        return C
    
    括号

    给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。
    输入: “()[]{}”
    输出: true

    def isValid(s: str) -> bool:
        dic = {")": "(", "]": "[", "}": "{"}
        stack = []
        for i in s:
            if stack and i in dic:
                if stack[-1] == dic[i]:
                    stack.pop()
                else:
                    return False
            else:
                stack.append(i)
    
        return not stack
    
    
    扑克牌中的顺子

    从扑克牌中随机抽5张牌,判断是不是一个顺子,即这5张牌是不是连续的。2~10为数字本身,A为1,J为11,Q为12,K为13,而大、小王为 0 ,可以看成任意数字。A 不能视为 14。
    示例 :
    输入: [1, 2, 3, 4, 5] 输出: True
    输入:[0, 0, 1, 2, 5] 输出: True

    时间复杂度 O(N log N) = O(5 log 5) = O(1)
    空间复杂度 O(1)
    
    def isStraight(nums) -> bool:
        joker = 0
        nums.sort()
        for i in range(4):
            if nums[i] == 0:
                joker += 1
            elif nums[i] == nums[i + 1]:
                return False
        return nums[4] - nums[joker] < 5
    
    
    展开全文
  • 看了别人的博客半天大概知道是什么意思了,不过没有理解透彻,以后再说吧,反正核心代码也不长先背过再说。 推荐这篇博客我觉得树状数组讲的挺好的,http://blog.csdn.net/int64ago/article/details/7429868还有这...

    树状数组真的是巧妙,发明这个的人一定是个天才。看了别人的博客半天大概知道是什么意思了,不过没有理解透彻,以后再说吧,反正核心代码也不长先背过再说。
    推荐这篇博客我觉得树状数组讲的挺好的,http://blog.csdn.net/int64ago/article/details/7429868

    还有这道题要注意的,一个是数据量较大,最好不要用cin/cout,一个是输入输出时注意格式。

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    
    using namespace std;
    
    int tree[50005];
    
    void add(int k, int num,int n)   //维护数组的函数
    {
        while(k<=n)
        {
            tree[k]+=num;
            k+=k&-k;   //lowbit利用了编码的知识
        }
    }
    int read(int k)  //1~k的区间和
    {
        int sum =0;
        while(k)
        {
            sum+=tree[k];
            k-=k&-k;
        }
        return sum;
    }
    int main()
    {
        int t;
        scanf("%d",&t);
        for(int k=1; k<=t; k++)
        {
            memset(tree,0,sizeof(tree));
    
            int n,a,x,y;
            char in[6];
            scanf("%d",&n);
            for(int i=1; i<=n; i++)
            {
                scanf("%d",&a);
                add(i,a,n);
            }
            printf("Case %d:\n",k);
            while(scanf("%s",in) !=EOF)
            {
                if(in[0] =='E')
                    break;
                else if(in[0] =='Q')
                {
                    scanf("%d%d",&x,&y);
                    printf("%d\n",read(y) - read(x-1));
                }
                else if(in[0] =='A')
                {
                    scanf("%d%d",&x,&y);
                    add(x,y,n);
                }
                else if(in[0] =='S')
                {
                    scanf("%d%d",&x,&y);
                    add(x,-y,n);
                }
            }
        }
        return 0;
    }
    
    展开全文
  • HTML框架与内联框架

    千次阅读 2018-04-01 22:16:47
    在学习这一节之前经常听说这个框架这个词,只知道有这个东西,不知道是什么意思,今天就来分享一下关于HTML中的框架的理解,内容不一定多,等以后学到了更多的知识再来进行分享。 1.什么是HTML框架 这个地方要注意...

      在学习这一节之前经常听说这个框架这个词,只知道有这个东西,不知道是什么意思,今天就来分享一下关于HTML中的框架的理解,内容不一定多,等以后学到了更多的知识再来进行分享。

      1.什么是HTML框架

        这个地方要注意的是,我说的是HTML框架,而不是那些比较复杂的WEB框架,由于是新手入门,就从最简单的学起,我这里的框架指的是让同一个浏览器显示不止一个页面的工具或者说是模板。框架分为垂直框架,水平框架,混合框架,不能调宽度的框架(主要是通过noresize属性进行控制),通过框架,可以把一个页面分成多个不同的区域。

      2.什么是HTML内联框架

         HTML内联框架是为了实现在网页中显示网页,突出了内联二字,就是在一个网页中,我们能够控制在这个网页中用多大的框去显示另外一个网页,并且能通过CSS对其进行控制。

    3.HTML框架和HTML内联框架的区别及用法(简称HTML框架为框架,HTML内联框架为内联)

      区别:框架的标签是<frameset></frameset>,是一对标签,它和<body>标签是不能同时使用的,除非浏览器不支持框架时,要加<noframes>标签时,里面的要添加文本的话,就要在<body>标签里进行编写,如

    <noframes>
    <body>您的浏览器无法处理框架!</body>
    </noframes>

    这种只是处理意外情况,一般都支持框架;而内联框架则可以放在<body>里面,标签是<iframe></iframe>,如

    <body>
    
    <iframe src="/example/html/demo_iframe.html" width="200" height="200"></iframe>
    
    <p>某些老式的浏览器不支持内联框架。</p>
    <p>如果不支持,则 iframe 是不可见的。</p>
    
    </body>

    这个主要是用法上的区别,其实在了解了过后会发现其实差别很大,只是由于在学习的时候将两个知识点放在一起,可能会引起一种错觉,还有更多关于他们的知识,我就下次再补充了。

    展开全文
  • 关于爱读书的演讲稿范文三篇 关于爱读书的演讲稿范文篇一: 儿时的我,...爸爸严肃的对我说:“以后注意多读书,那才能积累知识呀!”于是,我便暗暗下决心,一定要多读书,懂得好多好多的知识。 从那以后,我真...
  • 读书演讲稿例文:我读书我快乐 儿时的我...爸爸严肃的对我说:“以后注意多读书,那才能积累知识呀!”于是,我便暗暗下决心,一定要多读书,懂得好多好多的知识。 从那以后,我真的喜欢上了读书,因为书给我带来...
  • 读书的演讲稿500字.doc

    2021-01-15 11:49:37
    读书的演讲稿500字 我读书 我快乐 儿时的我,在“锄禾...爸爸严肃的对我说:“以后注意多读书,那才能积累知识呀!”于是,我便暗暗下决心,一定要多读书,懂得好多好多的知识。 从那以后,我真的喜欢上了读书,...
  • 读书演讲稿:我读书我快乐 儿时的我...爸爸严肃的对我说:“以后注意多读书,那才能积累知识呀!”于是,我便暗暗下决心,一定要多读书,懂得好多好多的知识。 从那以后,我真的喜欢上了读书,因为书给我带来了无...
  • 读书演讲稿例文:我读书我快乐 儿时的我...爸爸严肃的对我说:“以后注意多读书,那才能积累知识呀!”于是,我便暗暗下决心,一定要多读书,懂得好多好多的知识。 从那以后,我真的喜欢上了读书,因为书给我带来...
  • 二叉树的遍历以DFS和BFS为基础的,无非在DFS和BFS上面的变形,熟练掌握了BFS和DFS以后,这种类型的题目也就没有什么太大的难度了 题目描述如下: 题目大致意思: 给出二叉树的后续遍历序列和中序遍历序列,重建...
  • 什么是解构赋值 ES6 允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)。所谓的解构就是解析解构的意思 数组的结构赋值 注意点: 赋值等号的左右侧的数组结构需要一直,这个...
  • 掌握这些以后,就可以决定采取什么方式来吸引听众,说服听众,取得好的效果。下面由PQ小编推荐的学习工匠精神演讲稿范文,欢迎大家阅读。 学习工匠精神演讲稿范文一 工匠精神与企业发展 很多人认为工匠精神意味...
  • 本书以问答的形式组织内容,讨论了学习或使用C语言的过程中经常遇到的一些问题。书中列出了C用户经常问的400多个经典问题,涵盖了初始化、数组、指针、字符串、内存... 5.18 运行时的整数值0转换为指针以后一定是空指针...
  • 5.18 运行时的整数值0转换为指针以后一定是空指针吗? 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零的空指针内部表示。  5.20运行时的“nullpointerassignment...
  •  5.18 运行时的整数值0转换为指针以后一定是空指针吗? 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零的空指针内部表示。 5.20运行时的...
  • 5.18 运行时的整数值0转换为指针以后一定是空指针吗? 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零的空指针内部表示。 5.20运行时的“nullpointerassignment”...
  • 5.18 运行时的整数值0转换为指针以后一定是空指针吗? 61 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零的空指针内部表示。 62  5.20 运行时的“null pointer...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    内容简介 《你必须知道的495个C语言问题》以问答的形式组织内容,讨论了学习或使用C语言的过程中经常遇到的一些问题。书中列出了C用户经常问的400多个...5.18 运行时的整数值0转换为指针以后一定是空指针吗? 61 5.19...
  • 发环境(并不一定是最友好的,但一定是最强大的),我建议你一定要好好的熟悉一下 Linux。 三.如何得到Linux? 据我所知,大多数的 Linux 发行版本(Linux distribution)和核心(Kernel)都可以 从网上下载...
  • 在学恢复数据前一定注意一个问题就是先用WINHEX备份要恢复的磁盘数据,然后你就可以大胆的修改啊恢复啊不用担心会弄错了。其次,还要对文件存放在硬盘,U盘的形式了解一下,我现在就讲一下删除剪切原理。想必大家...
  • 4.C#中的委托是什么?事件是不是一种委托? 答 : 委托可以把一个方法作为参数代入另一个方法。 委托可以理解为指向一个函数的引用。 是,是一种特殊的委托 5.override与重载的区别 答 : override 与重载的...
  • Phoenix-award workstation BIOS V6.00PC,An Energy star Ally copyright(c) 1984-2003,Phoenix Technologies,LTD 这句英语的意思是:Phoenix-award这两家COMS芯片开发公司合并后共同开发第6号BIOS版本,采用美国...
  • 那么启动 Traffic Shaping 以后的结果是什么? 很明显的发现,绿色的小方块(ACK 封包)可以「插队」在蓝色小方块(上传封包)之間。而且插队的位置,是在下一个要传送封包的预备位置。也就是说,封包之間產生了「...
  • 27、GC是什么? 为什么要有GC?  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象...
  • java 面试题 总结

    2009-09-16 08:45:34
    24、GC是什么? 为什么要有GC?  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象...
  • 疯狂的程序员

    热门讨论 2012-07-18 18:05:32
    程序员是什么?他不知道。他问:“程序员能找到教书的工作吗?” “当然,一点问题都没有。随便哪个学校都能教。想我那个年代,这城市有多少程序员,数都能数出来。我还报了高程,唉……差一点。” 能去教书当然好,...
  • php高级开发教程说明

    2008-11-27 11:39:22
    什么意思?)在此处讨论中并不重要。重要的:形式分析的结果越好,逻辑分析就越容易、 越快、越好。 逻辑分析能补偿形式分析中失去的信息,但仅仅在一个有限的程度上补偿。 你也许能读懂前面的这个句子,但要...
  • 汽车驾驶教程图解

    2012-05-26 08:56:12
    1)应该确认从驾驶座位看车前的宽度、长度是什么感觉。 2)确认汽车车身的大小和路面的视觉。 3)还要掌握汽车前方、后方位置的距离感觉。 正确地判断汽车的大小、记住视觉的死角都非常重要。 现代汽车由于空气...
  • Quartus_II使用教程

    热门讨论 2012-11-26 23:20:43
    波形仿真中有个需要注意,波形图的名称一定要与你所在的工程名相同。因为波形 仿真是和编译后的文件关联的。因此如果你在设计16位计数器的时候进行了波形仿真来测 试是否符合要求,如果想保留此波形图,请save ...

空空如也

空空如也

1 2 3 4
收藏数 64
精华内容 25
关键字:

以后一定注意是什么意思