第一题

　　题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

　　思路：先快速定位到该数在哪一行，然后再迅速定位具体位置。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     # array 二维列表
  4.     def Find(self, target, array):
  5.         # write code here
  6.         row = 0
  7.         col = len(array[0]) - 1
  8.         while col >= 0 and row < len(array):
  9.             if target == array[row][col]:
  10.                 return True
  11.             elif target > array[row][col]:
  12.                 row = row + 1
  13.             else:
  14.                 col = col - 1
  15.         return False

第一题

第二题

　　题目：请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

　　思路：使用字符串的replace方法即可。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     # s 源字符串
  4.     def replaceSpace(self, s):
  5.         # write code here
  6.         s = s.replace(' ','%20')
  7.         return s

第二题

第三题

　　题目：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

　　思路：先用append方法讲链表储存，然后使用reverse方法颠倒列表。

  1. # -*- coding:utf-8 -*-
  2. # class ListNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.next = None
  6.  
  7. class Solution:
  8.     # 返回从尾部到头部的列表值序列，例如[1,2,3]
  9.     def printListFromTailToHead(self, listNode):
  10.         # write code here
  11.         out = []
  12.         while listNode:
  13.             out.append(listNode.val)
  14.             listNode = listNode.next
  15.         out.reverse()
  16.         return out

第三题

第四题

　　题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

　　思路：前序遍历是由根开始，从左树到右数遍历。中序遍历是由左树开始，到根节点然后到右树。后序与中序相反。只考虑前序和中序，根节点在前序的首位，在中序的左树与右树的分割点。通过index方法，可以得出左树与右树的长度，然后通过递归重建二叉树。

  1. # -*- coding:utf-8 -*-
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7. class Solution:
  8.     # 返回构造的TreeNode根节点
  9.     def reConstructBinaryTree(self, pre, tin):
  10.         # write code here
  11.         if len(pre) == 0:
  12.             return None
  13.         elif len(pre) == 1:
  14.             return TreeNode(pre[0])
  15.         else:
  16.             tree = TreeNode(pre[0])
  17.             tree.left = self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
  18.             tree.right = self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
  19.         return tree

第四题

第五题 

　　题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

　　思路：一个栈来实现存储，一个栈来实现先入先出。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def __init__(self):
  4.         self.save = []
  5.     def push(self, node):
  6.         # write code here
  7.         self.save.append(node)
  8.     def pop(self):
  9.         # write code here
  10.         out = self.save[-1]
  11.         del self.save[-1]
  12.         return out

第五题

第六题

　　题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

　　思路：直接用min()方法好像也能通过，不然用循环也可完成目标。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def minNumberInRotateArray(self, rotateArray):
  4.         # write code here
  5.         if len(rotateArray) == 0:
  6.             return
  7.         else:
  8.             while len(rotateArray) > 1:
  9.                 if rotateArray[0] < rotateArray[-1]:
  10.                     return rotateArray[0]
  11.                 else:
  12.                     rotateArray[0] = rotateArray[-1]
  13.                     del rotateArray[-1]
  14.             else:
  15.                 return rotateArray[0]

第六题

第七题

　　题目：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

　　思路：斐波那契数列就是下一个数是前两个数之和，开头两个分别为1，1。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def Fibonacci(self, n):
  4.         # write code here
  5.         if n == 0:
  6.             return 0
  7.         elif n >0 and n<=2:
  8.             return 1
  9.         else:
  10.             n_1,n_2 = 1,1
  11.             for i in range(n-2):
  12.                 cun = n_2
  13.                 n_2 = n_1 + n_2
  14.                 n_1 = cun
  15.             return n_2

第七题

第八题

　　题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

　　思路：在大于2以后，可以考虑最后一步有两种可能，一种是跳一步，一种是跳两步，也就是说，跳n个台阶的方法与跳n-1与n-2个台阶的和的方法数相同。本题就与斐波那契数列相同。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def jumpFloor(self, number):
  4.         # write code here
  5.         n_0,n_1,n_2 = 0,1,0
  6.         for i in range(number):
  7.             n_2 = n_0 + n_1
  8.             n_0 = n_1
  9.             n_1 = n_2
  10.         return n_2

第八题

第九题

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

　　思路：条1~2级就是斐波那契数列，跳的越多，加入之前的项越多，跳n级即前n项之和，就有f(n)=f(n-1)+......+f(1)。f(n-1) = f(n-2)+......+f(1)。所以归纳出，f(n)=2^(n-1)。这里可以用**方法。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def jumpFloorII(self, number):
  4.         # write code here
  5.         out = 2**(number-1)
  6.         return out

第九题

第十题

　　题目：我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

　　思路：这个依然是斐波那契数列问题变种，2*4的矩形就是2*3的方法数加上一块2*2的方法数。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def rectCover(self, number):
  4.         # write code here
  5.         n_0,n_1,n_2 = 0,1,0
  6.         for i in range(number):
  7.             n_2 = n_0 + n_1
  8.             n_0 = n_1
  9.             n_1 = n_2
  10.         return n_2

第十题

第十一题 

　　题目：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

　　思路：想不到什么好办法，就准备直接将数转换为二进制的string型，这里负数-2147483648的补码是1000 0000 0000 0000 0000 0000 0000与其他负数不同。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def NumberOf1(self, n):
  4.         # write code here
  5.         if n >= 0:
  6.             flag = False
  7.         elif n == -2147483648:
  8.             return 1
  9.         else:
  10.             flag = True
  11.             n = 2**31 - 1 + n
  12.         num = ''
  13.         while n>0:
  14.             if n%2 == 1:
  15.                 num = '' + num
  16.             else:
  17.                 num = '' + num
  18.             n = int(n/2)
  19.         if flag:
  20.             num = num.zfill(31)
  21.             new = list(num)
  22.             for i in range(31):
  23.                 if new[30 - i] == '':
  24.                     new[30 - i] = ''
  25.                     break
  26.                 else:
  27.                     new[30 - i] = ''
  28.             num = ''.join(new)
  29.             num = '' + num
  30.         t = 0
  31.         for i in num:
  32.             if i == '':
  33.                 t = t + 1
  34.         return t

第十一题

第十二题

　　题目：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

　　思路：在Python中没有数字类型的严格定义，全都为C语言中double型编程而来，所以这里不需要特别注意，直接求解就可。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def Power(self, base, exponent):
  4.         # write code here
  5.         n = base**exponent
  6.         return n

第十二题

第十三题

　　题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

　　思路：直接可以循环整个数组，分别找出奇数和偶数列表后合并。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def reOrderArray(self, array):
  4.         # write code here
  5.         odd,even = [],[]
  6.         for i in array:
  7.             if i%2 == 0:
  8.                 even.append(i)
  9.             else:
  10.                 odd.append(i)
  11.         return odd + even

第十三题

第十四题

　　题目：输入一个链表，输出该链表中倒数第k个结点。

　　思路：这里输入的是一个链表，可以用next方法读出链表的内容。可以首先得到所有链表的长度，然后利用该长度计算需要next的次数，得到所需要的节点。

  1. # -*- coding:utf-8 -*-
  2. # class ListNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.next = None
  6.  
  7. class Solution:
  8.     def FindKthToTail(self, head, k):
  9.         # write code here
  10.         out = head
  11.         num = 0
  12.         while head:
  13.             num += 1
  14.             head = head.next
  15.         if k > num:
  16.             return None
  17.         else:
  18.             for i in range(num-k):
  19.                 out = out.next
  20.             return out

第十四题

第十五题

　　题目：输入一个链表，反转链表后，输出新链表的表头。

　　思路：这里是要反转链表，可以首先得到将旧链表所有的值，然后依次赋给新链表的next来完成。

  1. # -*- coding:utf-8 -*-
  2. # class ListNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.next = None
  6. class Solution:
  7.     # 返回ListNode
  8.     def ReverseList(self, pHead):
  9.         # write code here
  10.         nHead = None
  11.         plist = []
  12.         while pHead:
  13.             plist.append(pHead)
  14.             pHead = pHead.next
  15.         for i in plist:
  16.             mHead = i
  17.             oHead = nHead
  18.             nHead = mHead
  19.             nHead.next = oHead
  20.         return nHead

第十五题

第十六题

　　题目：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

　　思路：可以参考上一题，将两个链表中所有值取出后，依次赋给新的链表。

  1. # -*- coding:utf-8 -*-
  2. # class ListNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.next = None
  6. class Solution:
  7.     # 返回合并后列表
  8.     def Merge(self, pHead1, pHead2):
  9.         # write code here
  10.         nHead = None
  11.         plist = []
  12.         while pHead1 or pHead2:
  13.             if pHead1 != None and pHead2 != None:
  14.                 plist.append(pHead1)
  15.                 plist.append(pHead2)
  16.                 pHead1 = pHead1.next
  17.                 pHead2 = pHead2.next
  18.             elif pHead1 != None and pHead2 == None:
  19.                 plist.append(pHead1)
  20.                 pHead1 = pHead1.next
  21.             elif pHead1 == None and pHead2 != None:
  22.                 plist.append(pHead2)
  23.                 pHead2 = pHead2.next
  24.         plist.reverse()
  25.         for i in plist:
  26.             mHead = i
  27.             oHead = nHead
  28.             nHead = mHead
  29.             nHead.next = oHead
  30.         return nHead

第十六题

第十七题

　　题目：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

　　思路：首先找出与B树根节点相同的，然后分别判断下一层是否相同。分别判断根节点，左大树，右大树。这道题有点懵。

  1. # -*- coding:utf-8 -*-
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7. class Solution:
  8.     def HasSubtree(self, pRoot1, pRoot2):
  9.         # write code here
  10.         flag = False
  11.         if pRoot1 == None or pRoot2 == None:
  12.             return False
  13.         if pRoot1.val == pRoot2.val:
  14.             #判断是否在树根
  15.             flag = Solution.judge(self, pRoot1, pRoot2)
  16.         if not flag:
  17.             #判断是否在左树
  18.             flag = Solution.HasSubtree(self, pRoot1.left, pRoot2)
  19.         if not flag:
  20.             #判断是否在右树
  21.             flag = Solution.HasSubtree(self, pRoot1.right, pRoot2)
  22.         return flag
  23.  
  24.     def judge(self, pRoot1, pRoot2):
  25.         if pRoot2 == None:
  26.             return True
  27.         elif pRoot1 == None:
  28.             return False
  29.         elif pRoot1.val != pRoot2.val:
  30.             return False
  31.         else:
  32.             #递归判断
  33.             right_flag = Solution.judge(self, pRoot1.right, pRoot2.right)
  34.             left_flag = Solution.judge(self, pRoot1.left, pRoot2.left)
  35.             return right_flag and left_flag

第十七题

第十八题

　　题目：操作给定的二叉树，将其变换为源二叉树的镜像。

　　思路：不断循环调用，左树赋值给右树，右树赋值给左树

  1. # -*- coding:utf-8 -*-
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7. class Solution:
  8.     # 返回镜像树的根节点
  9.     def Mirror(self, root):
  10.         # write code here
  11.         if root == None:
  12.             return None
  13.         root.left,root.right = root.right,root.left
  14.         if root.left:
  15.             self.Mirror(root.left)
  16.         if root.right:
  17.             self.Mirror(root.right)
  18.         return root

第十八题

第十九题

　　题目：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

　　思路：每个周期会进行四步，顶行打印，右列打印，底行打印，左列打印。循环即可。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     # matrix类型为二维列表，需要返回列表
  4.     def printMatrix(self, matrix):
  5.         # write code here
  6.         row = len(matrix)
  7.         col = len(matrix[0])
  8.         left,right = 0,col
  9.         high,down = 0,row
  10.         res = []
  11.         while left<right and high<down:
  12.             # h_line
  13.             for i in range(left,right):
  14.                 res.append(matrix[high][i])
  15.             high = high + 1
  16.             if high == down:
  17.                 break
  18.             # r_line
  19.             for i in range(high,down):
  20.                 res.append(matrix[i][right-1])
  21.             right = right - 1
  22.             if right == left:
  23.                 break
  24.             for i in range(right-1,left-1,-1):
  25.                 res.append(matrix[down-1][i])
  26.             down = down - 1
  27.             if high == down:
  28.                 break
  29.             for i in range(down-1,high-1,-1):
  30.                 res.append(matrix[i][left])
  31.             left = left + 1
  32.             if right == left:
  33.                 break
  34.         return res

第十九题

第二十题

　　题目：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

　　思路：在第五题基础上增加min操作。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def __init__(self):
  4.         self.save = []
  5.     def push(self, node):
  6.         # write code here
  7.         self.save.append(node)
  8.     def pop(self):
  9.         # write code here
  10.         out = self.save[-1]
  11.         del self.save[-1]
  12.         return out
  13.     def top(self):
  14.         # write code here
  15.         out = self.save[0]
  16.         return out
  17.     def min(self):
  18.         # write code here
  19.         return min(self.save)

第二十题

第二十一题

　　题目：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

　　思路：逐个将压入顺序的序列压入到列表中，分别与弹出第一位比较，相同则分别弹出后继续比较，直至压完所有的压入栈，最后看列表是否完全弹空。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def IsPopOrder(self, pushV, popV):
  4.         # write code here
  5.         if len(pushV) != len(popV):
  6.             return False
  7.         else:
  8.             pushN = []
  9.             for i in pushV:
  10.                 pushN.append(i)
  11.                 while pushN and pushN[-1] == popV[0]:
  12.                     pushN.pop()
  13.                     del popV[0]
  14.             return len(pushN) == 0

第二十一题

第二十二题

　　题目：从上往下打印出二叉树的每个节点，同层节点从左至右打印。

　　思路：建立一个容器，依次将树的节点从左至右排队插入，依次存入要打印的列表中。

  1. # -*- coding:utf-8 -*-
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7. class Solution:
  8.     # 返回从上到下每个节点值列表，例：[1,2,3]
  9.     def PrintFromTopToBottom(self, root):
  10.         # write code here
  11.         tree = []
  12.         if root:
  13.             temp = [root]
  14.             while len(temp):
  15.                 x = temp.pop(0)
  16.                 tree.append(x.val)
  17.                 if x.left:
  18.                     temp.append(x.left)
  19.                 if x.right:
  20.                     temp.append(x.right)
  21.         return tree

第二十二题

第二十三题

　　题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

　　思路：后序遍历二叉树，根节点在最后一位，比它小的一齐在最前面是左树，比它大的一齐在后面是右树。

  1. # -*- coding:utf-8 -*-
  2. class Solution:
  3.     def VerifySquenceOfBST(self, sequence):
  4.         # write code here
  5.         size = len(sequence)
  6.         if size == 1:
  7.             return True
  8.         elif size == 0:
  9.             return False
  10.         left,right = [],[]
  11.         flag_l,flag_r = True,True
  12.         i = 0
  13.         while sequence[i]<sequence[-1] and i <size-1:
  14.             left.append(sequence[i])
  15.             i += 1
  16.         right = sequence[i:size-1]
  17.         if right:
  18.             for j in right:
  19.                 if j <= sequence[-1]:
  20.                     return False
  21.             else:
  22.                 flag_r = Solution.VerifySquenceOfBST(self, right)
  23.         if left:
  24.             flag_l = Solution.VerifySquenceOfBST(self, left)
  25.         return flag_l and flag_r

第二十三题

第二十四题

　　题目：输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

　　思路：前序遍历，找到同时满足左右子树为空，根节点与值相同的情况。

  1. # -*- coding:utf-8 -*-
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7. class Solution:
  8.     # 返回二维列表，内部每个列表表示找到的路径
  9.     def FindPath(self, root, expectNumber):
  10.         # write code here
  11.         if not root:
  12.             return []
  13.         if not root.left and not root.right and expectNumber == root.val:
  14.             return [[root.val]]
  15.         res = []
  16.         left = self.FindPath(root.left,expectNumber-root.val)
  17.         right = self.FindPath(root.right,expectNumber-root.val)
  18.         for i in left+right:
  19.             res.append([root.val]+i)
  20.         return res

第二十四题

[持久更新] 剑指offer题目Python做题记录的更多相关文章

  1. 代码题 — 剑指offer题目、总结

    剑指offer题目总结:  https://www.cnblogs.com/dingxiaoqiang/category/1117681.html 版权归作者所有,任何形式转载请联系作者.作者:马孔多 ...

  2. 剑指offer题目系列三（链表相关题目）

    本篇延续上一篇剑指offer题目系列二,介绍<剑指offer>第二版中的四个题目:O(1)时间内删除链表结点.链表中倒数第k个结点.反转链表.合并两个排序的链表.同样,这些题目并非严格按照 ...

  3. 再来五道剑指offer题目

    再来五道剑指offer题目 6.旋转数组的最小数字 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转. 输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素. 例如数组{3,4, ...

  4. 剑指offer题目java实现

    Problem2:实现Singleton模式 题目描述:设计一个类,我们只能生成该类的一个实例 package Problem2; public class SingletonClass { /* * ...

  5. 剑指 Offer 题目汇总索引

    剑指 Offer 总目录:(共50道大题) 1. 赋值运算符函数(或应说复制拷贝函数问题) 2. 实现 Singleton 模式 (C#) 3.二维数组中的查找 4.替换空格              ...

  6. 【剑指Offer】剑指offer题目汇总

      本文为<剑指Offer>刷题笔记的总结篇,花了两个多月的时间,将牛客网上<剑指Offer>的66道题刷了一遍,以博客的形式整理了一遍,这66道题属于相对基础的算法题目,对于 ...

  7. 牛客网上的剑指offer题目

    题目:在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数. 题目:请实现一个函数,将一 ...

  8. 剑指offer题目系列二

    本篇延续上一篇,介绍<剑指offer>第二版中的四个题目:从尾到头打印链表.用两个栈实现队列.旋转数组的最小数字.二进制中1的个数. 5.从尾到头打印链表 题目:输入一个链表的头结点,从尾 ...

  9. 剑指offer题目系列一

    本篇介绍<剑指offer>第二版中的四个题目:找出数组中重复的数字.二维数组中的查找.替换字符串中的空格.计算斐波那契数列第n项. 这些题目并非严格按照书中的顺序展示的,而是按自己学习的顺 ...

随机推荐

  1. python 二维数组键盘输入

    m = int(input()) grid = [[] for i in range(m)] for i in range(m): line = input().split(' ') for j in ...

  2. virtualbox+vagrant学习-2(command cli)-7-vagrant login命令

    Login ⚠️该命令已经弃用了,别名为vagrant cloud auth login.看本博客的 格式: vagrant cloud auth login [options] 登录命令用于使用Ha ...

  3. ethers.js-4-Contracts

    Contracts A Contract is an abstraction of an executable program on the Ethereum Blockchain. A Contra ...

  4. [转]DirectX and .NET[英]

    With the DirectX SDK (June 2010) release and the addition of support for Visual Studio 2010, I’ve be ...

  5. JDK（八）JDK1.7&1.8源码对比分析【集合】HashMap

    前言 在JDK1.8源码分析[集合]HashMap文章中,我们分析了HashMap在JDK1.8中新增的特性(引进了红黑树数据结构),但是为什么要进行这个优化呢?这篇文章我们通过对比JDK1.7和1. ...

  6. PAT乙级1022

    1022 D进制的A+B (20 分)   输入两个非负 10 进制整数 A 和 B (≤2​30​​−1),输出 A+B 的 D (1<D≤10)进制数. 输入格式: 输入在一行中依次给出 3 ...

  7. 使用jquery获取url上的参数（笔记）

    使用jquery获取url上的参数(笔记) 一.做作业时经常要获取url上的参数 1.当url上有多个参数时 从互联网找到了一个方法 (function ($) { $.getUrlParam = f ...

  8. Ceph学习之路（三）Ceph luminous版本部署

    1.配置ceph.repo并安装批量管理工具ceph-deploy [root@ceph-node1 ~]# vim /etc/yum.repos.d/ceph.repo [ceph] name=Ce ...

  9. iOS开发者证书-详解

    iOS开发者证书-详解/生成/使用 本文假设你已经有一些基本的Xcode开发经验, 并注册了iOS开发者账号. 相关基础 加密算法 现代密码学中, 主要有两种加密算法: 对称密钥加密 和 公开密钥加密 ...

  10. 【POJ2832 】【Tyvj1460】【 7.22Test 】询问

    几种版本的题面 Description You are given an undirected graph G with N vertices and M edges. Each edge has a ...