LeetCode-DataStructure
来源：互联网 发布：手游抢激活码软件 编辑：程序博客网 时间：2024/06/05 07:42
链表
class ListNode(object): def __init__(self, x): self.val = x self.next = None21.Merge Two Sorted Lists
创建一个新链表dummy。依次将l1与l2中较小的一个结点插入到dummy后面。
class Solution(object): def mergeTwoLists(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ dummy = ListNode(0) cur = dummy 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 dummy.next83. Remove Duplicates from Sorted List
去除有序链表中多余的元素
class Solution(object): def deleteDuplicates(self, head): """ :type head: ListNode :rtype: ListNode """ p = head while p: if p.next and p.next.val == p.val: p.next = p.next.next else: p = p.next return head206.ReverseLinkedList
反转链表
class Solution(object): def reverseList(self, head): """ :type head: ListNode :rtype: ListNode """ if head ==None: return None if head.next ==None: return head pre =head p = head.next pre.next = None while p!=None: nxt = p.next p.next = pre pre =p p=nxt return pre237.DeleteNodeinaLinkedList
删除结点
class Solution(object): def deleteNode(self, node): """ :type node: ListNode :rtype: void Do not return anything, modify node in-place instead. """ node.val = node.next.val node.next = node.next.nextclass Solution(object): def deleteNode(self, node): """ :type node: ListNode :rtype: void Do not return anything, modify node in-place instead. """ if (node == None): return; if (node.next != None): node.val = node.next.val; node.next = node.next.next; return; else: del node; return;树
class TreeNode(object): def __init__(self, x): self.val = x self.left = None self.right = None100.SameTree
判断两棵树是否相同
class Solution(object): def isSameTree(self, p, q): """ :type p: TreeNode :type q: TreeNode :rtype: bool """ if p==None and q==None: return True elif p==None and q!=None: return False elif p!=None and q==None: return False elif p!=None and q!=None and p.val!=q.val: return False else: return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)107.Binary Tree Level Order Traversal II
逆序层次遍历二叉树，
class Solution(object): def levelOrderBottom(self, root): """ :type root: TreeNode :rtype: List[List[int]] """ if not root: return [] level = [] cur = [root] while (len(cur) > 0): next_level = [] level_val = [] for node in cur: level_val.append(node.val) if node.left: next_level.append(node.left) if node.right: next_level.append(node.right) cur = next_level level.append(level_val) return level[::-1]104.MaximumDepthOfBinaryTree
求二叉树的深度
class Solution(object): def maxDepth(self, root): """ :type root: TreeNode :rtype: int """ if not root: return 0 return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1108.Convert Sorted Array to Binary Search Tree
Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
因为是平衡查找树以最中间的结点为根构建二叉树即可
class Solution(object): def sortedArrayToBST(self, num): """ :type nums: List[int] :rtype: TreeNode """ length = len(num) if length == 0: return None if length == 1: return TreeNode(num[0]) root = TreeNode(num[length / 2]) root.left = self.sortedArrayToBST(num[:length / 2]) root.right = self.sortedArrayToBST(num[length / 2 + 1:]) return rootclass Solution(object): def sortedArrayToBST(self, nums): """ :type nums: List[int] :rtype: TreeNode """ if nums: mid = len(nums) / 2 root = TreeNode(nums[mid]) root.left = self.sortedArrayToBST(nums[:mid]) root.right = self.sortedArrayToBST(nums[mid + 1:]) return root return None110. Balanced Binary Tree
判断一棵树是否为平衡二叉树
解题思路：在这道题里，平衡二叉树的定义是二叉树的任意节点的两颗子树之间的高度差小于等于1。这实际上是AVL树的定义。首先要写一个计算二叉树高度的函数，二叉树的高度定义为：树为空时，高度为0。然后递归求解：树的高度 = max(左子树高度，右子树高度)+1(根节点要算上)。高度计算函数实现后，递归求解每个节点的左右子树的高度差，如果有大于1的，则return False。如果高度差小于等于1，则继续递归求解。
class Solution(object): def Height(self, root): if root == None: return 0 return max(self.Height(root.left), self.Height(root.right)) + 1 def isBalanced(self, root): """ :type root: TreeNode :rtype: bool """ if root==None: return True if abs(self.Height(root.left)-self.Height(root.right))<=1: return self.isBalanced( root.left ) and self.isBalanced( root.right ) else: return False226.InvertBinaryTree
反转二叉树
class Solution(object): def invertTree(self, root): """ :type root: TreeNode :rtype: TreeNode """ if root is None: return root root.left, root.right = root.right, root.left self.invertTree(root.left) self.invertTree(root.right) return root235.Lowest Common Ancestor of a Binary Search Tree
找出两个结点的最小父结点，基本思想是，如果结点值大于这两个p，q的结点值，则p，q再当前结点的左子树上，还不是最小父结点，反之，则在右子树上。若等于其中一个结点的值，则此结点就是最小父结点
迭代法：
class Solution(object): def lowestCommonAncestor(self, root, p, q): while root: if p.val < root.val > q.val: root = root.left elif p.val > root.val < q.val: root = root.right else: return root递归法：
class Solution: def lowestCommonAncestor(self, root, p, q): if (p.val - root.val) * (q.val - root.val) <= 0: return root elif p.val < root.val: return self.lowestCommonAncestor(root.left, p, q) else: return self.lowestCommonAncestor(root.right, p, q)257. Binary Tree Paths
输出一颗二叉树的所有路径，使用深度优先遍历，遍历到一个结点没有孩子结点时，说明已经得到一条路径，将此路径加入paths
参考代码
class Solution(object): def binaryTreePaths(self, root): """ :type root: TreeNode :rtype: List[str] """ if not root: return [] path, paths = "", [] self.dfs(root, path, paths) return paths def dfs(self, node, path, paths): if not path: path += str(node.val) else: path += "->" + str(node.val) if not node.left and not node.right: paths.append(path) else: if node.left: self.dfs(node.left, path, paths) if node.right: self.dfs(node.right, path, paths)404.SumofLeftLeaves
计算叶子结点值得和
class Solution(object): def sumOfLeftLeaves(self, root): """ :type root: TreeNode :rtype: int """ if root==None: return 0 if root.left!=None and root.left.left==None and root.left.right==None: return root.left.val+self.sumOfLeftLeaves(root.right) return self.sumOfLeftLeaves(root.left)+self.sumOfLeftLeaves(root.right)437. Path Sum III
给出一个数，找出路径上值的和等于这个数的路径个数
class Solution(object): res =0 def pathSum(self, root, sum): """ :type root: TreeNode :type sum: int :rtype: int """ if root==None : return 0 self.pathSum(root.left,sum) self.pathSum(root.right,sum) self.helper(root,sum) return self.res def helper(self,root,sum): if root==None : return if sum-root.val==0 : self.res+=1 self.helper(root.left,sum-root.val) self.helper(root.right, sum - root.val)502.Find Mode in Binary Search Tree
找出二叉搜索树中的众数
class Solution(object): def findMode(self, root): """ :type root: TreeNode :rtype: List[int] """ res = [] if not root: return res occur = {} level = [root] while level: next_level = [] for node in level: if node.val in occur: occur[node.val] += 1 else: occur[node.val] = 1 if node.left: next_level.append(node.left) if node.right: next_level.append(node.right) level = next_level max_val = max(occur.values()) for k, v in occur.iteritems(): if v == max_val: res.append(k) return res530.MinimumAbsoluteDifferenceinBST
求二叉查找树两个结点相差最小的值。由于是二叉查找树，所以中序遍历即可获得一个有序序列。由于是递增或者递减的，只需求其中两两之间最小的即可
class Solution(object): def getMinimumDifference(self, root): #由于是二叉查找树，中序遍历，取两两间最小值即可 """ :type root: TreeNode :rtype: int """ def inorder(root, l=[]): if root.left: inorder(root.left, l) l.append(root.val) if root.right: inorder(root.right, l) return l l = inorder(root, []) return min([l[i + 1] - l[i] for i in range(len(l) - 1)])538.ConvertBSTtoGreaterTree
对于每个结点，加上所以比它大的值
利用二分查找树的特性，我们可以很容易得出从大到小的数组序列，即中序遍历（右子树-根节点-左子树）
class Solution(object): sum = 0 def convert(self,root): if root==None: return self.convert(root.right) self.sum += root.val root.val=self.sum self.convert(root.left) def convertBST(self, root): """ :type root: TreeNode :rtype: TreeNode """ self.convert(root,self.sum) return root563.BinaryTreeTilt
求左右子树相差的绝对值0
class Solution(object): sum = 0 def helper(self,root): if root==None: return 0 left = self.helper(root.left) right = self.helper(root.right) self.sum +=abs(left-right) return root.val+left+right def findTilt(self, root): """ :type root: TreeNode :rtype: int """ self.helper(root) return self.sum572.SubtreeofAnotherTreepython
判断一棵树是不是另一棵树的子树
class Solution(object):def isSubtree(self, s, t): """ :type s: TreeNode :type t: TreeNode :rtype: bool """ if s==None : return False if self.isSame(s,t) : return True return self.isSubtree(s.left,t) or self.isSubtree(s.right,t)def isSame(self,s,t): if s==None and t==None: return True if s==None or t==None: return False if s.val!=t.val : return False return self.isSame(s.left,t.left) and self.isSame(s.right,t.right)class Solution(object): def isSubtree(self, s, t): """ :type s: TreeNode :type t: TreeNode :rtype: bool """ def preorder(node): if node is None: return "%" return "*" + str(node.val) + "#" + preorder(node.left) + preorder(node.right) return preorder(t) in preorder(s)class Solution(object): def isSubtree(self, s, t, sub=False): """ :type s: TreeNode :type t: TreeNode :rtype: bool """ if s is None and t is not None: return False elif s is not None and t is None and sub: return False elif t is None: return True if s.val == t.val: return (self.isSubtree(s.right, t.right, True) and self.isSubtree(s.left, t.left, True)) or self.isSubtree( s.right, t) or self.isSubtree(s.left, t) else: if sub: return False else: return self.isSubtree(s.right, t) or self.isSubtree(s.left, t)606.ConstructStringfromBinaryTree
用带括号的字符串表示二叉树
class Solution(object): def tree2str(self, t): """ :type t: TreeNode :rtype: str """ if t: s =str(t.val) print(s+'('+self.tree2str(t.left)+')'+'('+self.tree2str(t.right)+')') else: return return617.MergeTwoBinaryTree
融合两颗二叉树
class Solution(object): def mergeTrees(self, t1, t2): if t1 and t2: root = TreeNode(t1.val + t2.val) root.left = self.mergeTrees(t1.left, t2.left) root.right = self.mergeTrees(t1.right, t2.right) return root else: return t1 or t2637.AverageofLevelsinBinaryTree
计算每一层的结点值的平均数，使用队列进行层次遍历
import queueclass Solution(object): def averageOfLevels(self, root): """ :type root: TreeNode :rtype: List[float] """ result = [] q = queue.Queue() q.put(root) while(q.empty()==False): n = q.qsize() mysum = 0 for i in range(0,n): x= q.get() mysum +=x.val if x.left!=None: q.put(x.left) if x.right!=None: q.put(x.right) result.append(mysum/n) return result543.DiameterofBinaryTree
计算树中的最长路径，二叉树的直径
这道题目给了我们一个二叉树，让我们找到二叉树的直径 - 最远的距离存在于两个点之间。 我们另外需要一个function - getDepth。 这个function利用post order，从最左边下面开始返回每一个点的depth， 如果这个点是null，那么返回0，依次像上一个level，每次加1。
在知道了每一个点的depth之后，我们可以来找到树的最大直径。我们来分析一下，怎么找到最大直径，取题目中给的例子，我们只看2 4 5 这基本结构， 2 4 5 这个子树的最大直径是2，这个直径等于 2的left 4的depth（1） 和 2的right 5的depth（1），两边的depth之和就等于最大直径 。 我们再回到原来的树立，1，2，3，4，5这个原题中的例子，我们从下往上看， 4的depth = 1， 5的depth = 1， 对于每一个parent node 取两个children的depth之和，和之前的diameter比较，大的就取代。 所以2的diameter = 2； 接着看2的depth = 2， 3的depth = 1， 那么1的diameter = 2 + 1 = 3, 比之前的diameter大，所以最大直径等于3。
对于每一个点，left 和 right depth 之和，就等于这个点的最大直径。换一句话说，就是这个点，左边能延伸出去最大值 + 右边能延伸出去的最大值，加一起，就等于这个点的左边最远的点到右边最远的点的距离。 就是最大直径。
class Solution(object): count = 0 def diameterOfBinaryTree(self, root): """ :type root: TreeNode :rtype: int """ self.getDepth(root) return self.count def getDepth(self,root): if root == None: return -1 left = self.getDepth(root.left) right = self.getDepth(root.right) temp = left + right +2 if temp>self.count: self.count = temp return max(left,right)+1class Solution(object): def diameterOfBinaryTree(self, root): self.s = 0 self.dfs(root) return self.s def dfs(self, root): if not root: return 0 l = self.dfs(root.left) r = self.dfs(root.right) self.s = max(self.s, l + r) return max(l, r) + 1101. Symmetric Tree
判断二叉树是不是镜像对称的
递归的方法：
class Solution(object): # @param root, a tree node # @return a boolean def sym(self, left, right): if left == None and right == None: return True if left and right and left.val == right.val: return self.sym(left.left, right.right) and self.sym(left.right, right.left) else: return False def isSymmetric(self, root): if root == None: return True return self.sym(root.left, root.right)迭代的方法：
from collections import dequeclass Solution(object): def isSymmetric(self, root): """ :type root: TreeNode :rtype: bool """ if not root: return True lefts = deque([root.left]) rights = deque([root.right]) while lefts and rights: left = lefts.popleft() right = rights.popleft() if not left and not right: continue if not left or not right or left.val != right.val: return False lefts.extend([left.left, left.right]) rights.extend([right.right, right.left]) return True阅读全文
0 0
- LeetCode-DataStructure
- useful datastructure:
- All DataStructure
- Game - datastructure
- 【datastructure】栈。
- Python4：DataStructure
- Datastructure c++ note 1
- Datastructure c++ note 2
- 【DataStructure&AlgorithmInJava】Ch02-HighArrayDemo
- 【DataStructure&AlgorithmInJava】Ch02-BinarySearchDemo
- 【DataStructure&AlgorithmInJava】Ch02-PersonArrayDemo
- 【DataStructure&AlgorithmInJava】Ch05-LinkedListDemo1
- 【DataStructure】Linked Data Structures
- Object V.S datastructure
- DataStructure-插入排序
- network datastructure --- skb
- DataStructure-8-查找技术
- DataStructure-1-基础
- java nio
- 【hdu5512 规律】Pagodas icpc2015·沈阳
- nodejs的express自动生成项目框架-2016
- 使用Servlet来进行数据类型的转化操作
- 求数字在非降序数组中出现的次数
- LeetCode-DataStructure
- Android中点击编辑框以外的地方关闭输入法
- CVPR 2017最佳论文
- hadoop YARN配置参数剖析—MapReduce相关参数
- Java Web中界面之间传值的实现方法
- leetcode-other
- LeetCode-String
- 流
- Unity试题收集
