136. 只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
思路：这里使用字典会超时，O(n*k)时间复杂度是行不通的，只能将时间复杂度控制在线性O(n)，这里就需要使用位运算，对于数组中的任一一个数与除它本身以外的数做异或运算都是它本身，与它本身做异或则得到0，程序最终输出那个唯一一个没有变成0的数，就是只重复一次的数。
# -*- coding:utf-8 -*-
"""
对于一个数A，A^A = 0;
对于一个数B，B^0=B。
"""
class Solution(object):
def singleNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
ans = 0
for i in nums:
ans ^= i
return ans206. 反转链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
思路：迭代，设置反转链表的头节点（newHead), 使用临时指针保存头节点的下一个节点，然后将头节点的next域指向newHead，接着将头节点传给newHead，最后将头节点指向下一个节点（temp指针）,重复这个过程，直到链表结束。
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def reverseList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head or not head.next:
return None
newHead = None
while head:
temp = head.next
head.next = newHead
newHead = head
head = temp
return newHead169. 求众数
给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在众数。
示例 1:
输入: [3,2,3] 输出: 3
示例 2:
输入: [2,2,1,1,1,2,2] 输出: 2
思路：使用字典保存每个数出现的次数，数值为键，value为次数，遍历字典找到那个出现次数大于长度一般的那个key。
class Solution(object):
def majorityElement(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
aDict = {}
half = len(nums) / 2
for i in nums:
if i in aDict.keys():
aDict[i] += 1
else:
aDict[i] = 1
for j in aDict.keys():
if aDict[j] > half:
return j9. 回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121 输出: true
示例 2:
输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:
你能不将整数转为字符串来解决这个问题吗？
class Solution(object):
def isPalindrome(self, x):
"""
:type x: int
:rtype: bool
"""
string = ''
x = str(x)
for i in range(len(x)):
string += x[i]
if string == x[::-1]:
return True
return False235. 二叉搜索树的最近公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
_______6______
/ \
___2__ ___8__
/ \ / \
0 _4 7 9
/ \
3 5
示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 输出: 6 解释: 节点2和节点8的最近公共祖先是6。示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 输出: 2 解释: 节点2和节点4的最近公共祖先是2, 因为根据定义最近公共祖先节点可以为节点本身。
说明:
- 所有节点的值都是唯一的。
- p、q 为不同节点且均存在于给定的二叉搜索树中。
思路：以上面这颗树为例，二叉搜索树是一颗左子树都小于根节点，右子树都大于根节点的树，若p,q都大于根节点，则在右子树中找，若p，q都小于根节点则在左子树中找，若p > root and q < root 或者 p < root and q > root则找到公共祖先root。
# -*- coding:utf-8 -*-
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
"""
二叉搜索树的左子树比根节点都要小，右子树比根节点都要大
这是一个非常经典的问题，我们通过递归可以非常快的解决这个问题，我们只要理清楚这样的几种情况：
root.val > p.val and root.val > q.val，那我们在root.left继续搜索
root.val < p.val and root.val < q.val，那我们在root.right继续搜索
其他的情况，返回root
"""
class Solution(object):
def lowestCommonAncestor(self, root, p, q):
"""
:type root: TreeNode
:type p: TreeNode
:type q: TreeNode
:rtype: TreeNode
"""
if root.val > p.val and root.val > q.val:
return self.lowestCommonAncestor(root.left, p, q)
if root.val < p.val and root.val < q.val:
return self.lowestCommonAncestor(root.right, p, q)
return root