shiquxinkong的专栏

#@ root: the root of searched tree#@ nodeToFind: the tree-node to be found#@ path: the path from root to node#@@#@@ search tree referenced by root, and return the path #@@ from root to node, if n

分析：假如给定的数组中的元素是1-9之间的数，我们怎么来处理呢？比如[ 1,4,7,9,3,8]，很简单，排个序，就是134789。这里不同的一点就是，给定的数稍微复杂一点，不再单纯的是1位的数，[3,32,321] 这种情况也会出现。我们还想用排序，那么就需要自己制定下排序规则，也就是比较的标准。str1和str2 长度相同的比较就不说了，在长度不同的时候，我们将长度短的用最后一位进

def FindKthToTail(head, k): if head == None: return None front = head; back = head steps = 0 # get | front - head | = k while front and steps < k: front = front.next steps += 1 # less than

class BTNode: def __init__(self, val): self.left = None self.right = None self.val = val'''@ construct tree by inorder & preorder'''def constructByInPre(inorder, instart, inend, preorde

def MirroRecursively(root): # root is None or just one node, return root if None == root or None == root.left and None == root.right: return root root.left, root.right = root.right, root.left Mi

def Fibonacci(n): if n <= 0: return 0 if n <= 1: return n f0 = 0; f1 = 1 for i in range(2, n + 1): fn = f0 + f1 f0 = f1 f1 = fn return fn

class StackWithMin: def __init__(self): self.data = [] self.min_data = [] self.size = 0 def push(self, val): self.data.append(val) if len(self.min_data) == 0 or \ self.min_data[-1] >

“如果你愿意一层一层一层的剥开。。。”，这里就是按层剥开。def PrintMatrixClockWisely(matrix): rows = len(matrix) if rows == 0: return cols = len( matrix[0] ) cells = (min(rows, cols) + 1) >> 1 for cell in range(cells):

def Merge(head1, head2): if head1 == None: return head2 if head2 == None: return head1 psuhead = ListNode(-1) tail = psuhead while head1 and head2: if head1.val < head2.val: cur = head1

可以练习下链表的逆置。def PrintListReversingly(head): if head == None: return if head: PrintListReversingly(head.next) print head.valdef reverse(head): if head == None or head.next == None: return

def isOdd(n): return n & 1def Reorder(data, cf = isOdd): odd = 0 even = len( data ) - 1 while True: while not isOdd( data[ even ]) : even -= 1 while isOdd( data[ odd ]) : odd += 1 if odd

pow(base, exponent)考虑一下几种情况：base = 0， 那么直接返回0base = 1， 那么直接返回1exponent = 0， 那么直接返回1， 注意base= 0exponent = 1， 那么直接返回 baseexponent  为正为负 的情况主要考察的点是将问题缩减，用折半的思想。这个题细节还是很多的，为了便于验证，leetcode上恰好

题目总结：1.若没有进行旋转，或者说旋转后的效果跟没有旋转是一样的，那么index1指示的值小于index2指示的值，返回index1的值。2.若是一般性的旋转，那么最小的值旋转后肯定在中间，那么我们就可以从两边向中间夹逼。3.夹逼的过程中，若 [ index1, middle ] 是有序的，说明这部分子区间没被破坏，旋转所移动的元素都在middle 的后面，那么最小值可定也在后面的部

def reverse(head): if head == None or head.next == None: return head psuhead = ListNode(-1) while head: nexthead = head.next head.next = psuhead.next psuhead.next = head head = nexthead

上一篇 说了些堆的建立及其相关操作，这里看下用堆来解决数据量较大的时候，查找最小的k个数的情况。这里会用到上一篇中的函数。我们先生存1千万个随机数，写到文件中：import randomdef randData(): with open('randint.txt', 'w') as fd: for i in range(1, 10000000): fd.write('%

这里记录下堆的相关操作。op 1：''' @ data: the heap array @ p : index of parent item @ n : number of data @@ Swap p and it's son items, make p the largest of them'''def swapForMaxHeap(data, n, p): l

第一种思路是，每个骰子的点数从最小到最大，假设为1-6，那么所有的骰子从最小1开始，我们假设一种从左向右的排列，右边的最低，索引从最低开始，判断和的情况。def setTo1(dices, start, end): for i in range(start, end): dices[i] = 1def probability(n, s, dmax = 6, dmin = 1): i

def Permutation(data, i): if len( data ) == 0: return # i stand for the start of first part for i in range(i, len( data ) - 1): # j stand for the start of second part for j in range(i + 1, le

def TreeDepth1(root): if None == root: return 0 if None == root.left and None == root.right: return 1 leftDepth = 0; rightDepth = 0 if root.left: leftDepth = TreeDepth(root.left) if root.ri

def FirstNotRepeatingChar(string): hashStr = [0] * 256 for c in string: hashStr[ord(c)] += 1 for c in string: if hashStr[ord(c)] == 1: return c这里说下ord， 可以作为atoi来用，功能是若给定的参数是一个长度为1的字符串，那么若

# @left part: [start, mid]# @right part: (mid, end]def merge(data, start, mid, end): if mid < start or end < mid: return 0 reverse = 0 ''' @ for start, it play as the start index of left par

这里尽可能的不去用语言本身提供的函数。将string逆置def reverse(string): #return string[::-1] reversedStr = '' for i in xrange(len(string) - 1, -1, -1): reversedStr += string[i] return reversedStr单词的翻转def reverse

test1 的判定函数：''' @ sum(1,2,3,4) = sum(5,6,7,8) and @ sum(1,2,5,6) = sum(3,4,7,8) and @ sum(1,3,5,7) = sum(2,4,6,8) @ used for test 1'''def sumEqual(data): eq1 = sum(data[0:4]) == sum(data[4:8

#@ util function, get the number of nodes in list referenced by headdef getLenOfList(head): nodeNum = 0 while head: nodeNum += 1 head = head.next return nodeNum# find the first common node o

import randomdef partition(data, start, end): if end <= start: return start index = random.randint(start, end) guard = data[index] while True: while data[start] < guard: start += 1 w

类似于字符串的匹配，我们总是找到第一个匹配的字符，在继续比较以后的字符是否全部相同，如果匹配串的第一个字符与模式串的第一个不相同，我们就去查看匹配串的下一个字符是否与模式串的第一个相同，对应到这里，就是我们要遍历root1，找到与root2相同的第一个结点，若root1的根不相同，那么我们查找其左子树是否有第一个相同的，相同的操作再去看右子树是否有相同的第一个，若找到了第一个相同的，与字符串匹配思

通常我们所说的删除链表的某个结点，是彻底删除该结点的空间，而要这么做就必须知道其前驱结点。这里的想法是，链表中存储的val是同类型的，只要将该结点的val内容删除就可以了。那么就可以用该结点的后继结点的值覆盖当前结点，然后删除其后继结点，而对于其后继结点而言，该结点就是前驱。这里只需要考虑当前删除的结点是否为last node 就可以了，至于是否是头结点，这种情况是可以归为同一种情况的，只是参

分析：还是二叉树遍历模板的改造问题，对于二叉搜索树，中序遍历的结果是有顺序的。题目的要求无非是将中序遍历的结点访问结果链接起来，至于双向链表，通过复用树结点的left 和 right 指针就可以完成。最直接的就是我们可以把中序遍历中访问到的每个结点都放入到个队列里，然后将队列的元素链接起来，但是题目不允许用额外的空间。想想中心遍历，遍历顺序是 左 --根---右，那么中序遍历的第一个访问结

这个题前，我们回想下经常遇到的另一个问题，给定一个整数，判断该整数是否是2的幂次。而所谓一个整数是2的幂次，就是说这个整数的2进制写法中，只有1个 。比如 1，是2 的0次幂，2 (10)是2的1次幂，等等。至于如何判断一个整数是否是2的幂次，我们先放一边，先来看看二进制中减 1的问题，对于一个整数，我们对其减去1，在二进制表示下，0肯定不够减1，所以就会向其左侧的高位寻求借位，然而高位的0肯

从大学的数据结构ka

/*参数说明：Original：给定的原字符串，存在多余的空间，真实使用的大小由下一参数给定。usedLength：实际的长度。strReplace: 由该参数指定的字符串替换原串Original的空格。返回值：进行替换后，新的字串的大小。*/int RepalceBlank(string &Original, int usedLength, const string &strRe

题目：在一个二维数组中，每一行从左到右递增，每一列从上到下递增，在这个二维数组中，查找给定的数是否存在。分析：遍历来查找的事这里就不说了，像星爷说的：“像我这么理智的人，怎么会相信这么无稽的事情。”这本书里提倡，遇到问题画画图，写写小例子。我们把已知条件都在例子中一一标出来。行递增，列递增，同一颜色按箭头方向，即顺时针方向递增有序，对于圈出的副对角线元素，对于所在行，是该行最大

题目：为给定的类添加yuns

将两个栈封装成为一个队列，使其具有队列的性质，可以进行相应的操作。分析：栈的后进先出特性执行两次，就成了先进先出，这就满足了队列的性质。实现：我们用一个栈stack_push来实现队列的push操作，用栈stack_pop来实现队列的pop操作。在push时，我们只管向stack_push中插入，因为这里没涉及到出，所以没有什么顺序可言。在pop时，

不像俩个栈实现队列，两次先进后出之后就是先进先出，队列几次先进先出仍然是先进先出，那么我们看看实际情况，将队列里除最后一个以外，全都拿走，剩下的这最后一个就是想要的结果，那么先前拿走的那些放哪里呢？给了两个队列，那就放在另外一个队列里。若是在出的话，就对另一个队列进行相同的操作。templateclass MyStack{public: MyStack() { push_queu

Q：输入一颗二叉搜索树，将该二叉搜索树转换为一个排序的双向链表。要求不能创建任何新的结点。分析：二叉搜索树的中序遍历就是一个有序的序列，而树的左孩子指针和有孩子指针当然就充当了前驱和后继指针，所以这种转换是自然的。我们定义结构体如下：struct TreeNode{ int val; TreeNode *left; TreeNode *right; TreeNode(int v

Q：输入一颗二叉树和一个整数，打印出二叉树中结点和为输入整数的所有路径。从树的根结点开始到叶子节点所经过的结点形成一条路径。结点定义如下：struct BinaryTreeNode{ int m_nValue; BinaryTreeNode *m_pLeft; BinaryTreeNode *m_pRight;}这个问题直白点就是二叉树的遍历，在遍历的

Q：输入整数数组，判断该数组是否为某二叉搜索树的后序遍历结果。题目里有几个字眼要求我们熟知，第一就是二叉搜索树，第二个就是后序遍历，第三就是它是树。1）二叉搜索树：左孩子的值 2）后序遍历：左->右->根3）树：若一棵树是满足某一性质X的X树，则其子树若存在，则也定为满足X性质的X树。好了，回到这个问题，通过2），我们可以从给定的数组中找到这个树的根，也就是数组的最后一

Q：从上往下打印出二叉树的每个节点，同层按从左到右的顺序打印。这里其实就是我们经常见的树的层次遍历。所以我们不禁想到要借助队列了。具体的过程如下：1）将树的根结点入队2）若队列不空，则取出队列的队首元素pfront(出队)，打印其内容3）若pfront的左孩子不为空，则其左孩子入队，若其右孩子不空，则其右孩子入队(注意这两个判断是并列关系，不是if ，else关系)4）返回2）

def copyRandomList(self, head): if None == head: return None phead = head while phead: pnext = phead.next phead.next = RandomListNode(phead.label)