剑指offer:25-28_字典

第25题：复杂链表的复制
题目说明：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
程序：
分三步：
第一步：复制结点；
第二步：复制随机指针；
第三步：分割链表。

# -*- coding:utf-8 -*-
# class RandomListNode:
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None
class Solution:
    # 返回 RandomListNode
    def Clone(self, pHead):
        # write code here
        if pHead == None:
            return None
        self.CopyNodes(pHead)
        self.CopyRandoms(pHead)
        copyHead = self.SplitList(pHead)
        return copyHead
    def CopyNodes(self, pHead):#第一步：复制结点
        p = pHead
        while p:
            p_next = p.next
            copyNode = RandomListNode(p.label)#创建新结点
            copyNode.next = p_next#插入复制结点
            p.next = copyNode
            p = p_next
    def CopyRandoms(self, pHead):#第二步：复制随机指针
        p = pHead
        while p:
            p_random = p.random
            copyNode = p.next
            if p_random:
                copyNode.random = p_random
            p = copyNode.next
    def SplitList(self, pHead):#第三步：分裂复制链表
        p = pHead
        copyHead = p.next
        while p:
            copyNode = p.next
            p_next = copyNode.next
            p.next = p_next
            if p_next:
                copyNode.next = p_next.next
            else:
                copyNode.next = None
            p = p_next
        return copyHead

第26题：二叉搜索树与双向链表
题目说明：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
程序：
使用中序遍历：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, pRootOfTree):
        # write code here
        if not pRootOfTree:
            return None
        l = []
        self.MidOrder(l, pRootOfTree)
        for i in range(len(l) - 1):
            l[i].right = l[i+1]
            l[i+1].left = l[i] 
        return l[0]
    def MidOrder(self, l, tree):
        if not tree:
            return
        self.MidOrder(l, tree.left)
        l.append(tree)
        self.MidOrder(l, tree.right)

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, pRootOfTree):
        # write code here
        if not pRootOfTree:
            return None
        self.l = []
        self.MidOrder(pRootOfTree)
        for i in range(len(self.l) - 1):
            self.l[i].right = self.l[i+1]
            self.l[i+1].left = self.l[i]
        return self.l[0]
    def MidOrder(self, tree):
        if not tree:
            return
        self.MidOrder(tree.left)
        self.l.append(tree)
        self.MidOrder(tree.right)

知识点：Python中self用法详解
第27题：字符串的排列
题目说明：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
程序：
首先依次取一个元素，然后和递归生成的所有子串依次结合，形成新的字符串：

# -*- coding:utf-8 -*-
class Solution:
	def Permutation(self, ss):
		# write code here
		if not ss:
			return []
		if len(ss) == 1:
			return ss
		ssList = list(ss)#将字符串转换成列表，以方便排序
		ssList.sort()
		result = []
		for i in range(len(ssList)):#依次取出一个字符，其余字符进行递归
			if i > 0 and ssList[i] == ssList[i-1]:#如果存在字符重复情况，跳过
				continue
			temp = self.Permutation(''.join(ssList[: i]) + ''.join(ssList[i+1: ]))	
			for j in temp:
				result.append(ssList[i] + temp)
		return result	

第28题：数组中出现次数超过一半的数字
题目说明：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
程序：
使用字典(键值对)：

# -*- coding:utf-8 -*-
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        if not numbers:
            return 0
        d = {}#使用字典
        for num in numbers:
            if d.get(num):
                d[num] += 1
            else:
                d[num] = 1
        for item in d.keys():
            if d[item] > (len(numbers) // 2):
                return item
        return 0

# -*- coding:utf-8 -*-
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        if not numbers:
            return 0
        d = {}
        for num in numbers:
            if d.get(num):
                d[num] += 1
            else:
                d[num] = 1
            if d[num] > (len(numbers) // 2):
                return num
        return 0

知识点：
字典常用方法总结：
字典用于存放具有映射关系的数据(键值对)，可以通过键(key)来访问值(value)，字典中的key不允许重复。
(1)字典的创建：
1)使用花括号创建字典时，key与value之间用英文冒号隔开，多个key-value之间用英文逗号隔开：

scores = {'语文': 89, '数学': 90, '英语': 95}
#使用元组作为dict的key
d = {(20, 30): 'good', 30: 'bad'}#{(20, 30): 'good', 30: 'bad'}

元组可以作为dict的key(元组是不可变类型)，但列表不能作为dic的key(列表是可变类型)。
2)使用dict()创建字典，可以传入多个列表或元组参数作为key-value对，每个列表或元组是一个key-value对：

vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]#元组
dict1 = dict(vegetables)
cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]#列表
dict2 = dict(cars)

(2)通过key访问value
用法：字典名[key]

scores = {'语文': 89, '数学': 90, '英语': 95}
print(scores['语文')

(3)通过key添加key-value对
用法：字典名[key] = value

scores['生物'] = 98

(4)通过 key 删除 key-value 对
用法：del 字典名[key]

del scores['生物']

(5)通过 key 修改 key-value 对
用法：字典名[key] = new value

scores['语文'] = 99

(6)使用in或not in，判断字典是否包含指定key

# 判断scores是否包含名为'语文'的key
print('语文' in scores)#True

(7)get()：根据key获取value
语法：字典名.get(key)

print(scores.get('语文'))#99

(8)items()、keys()、values()：分别用于获取字典中所有key-value对、所有key值以及所有value值，Python不希望用过直接操作这三个方法，通常使用list()转换成列表。

print(scores.keys())#dict_keys(['数学', '英语'])
print(list(scores.keys()))#['数学', '英语']

(9)pop()：用于获取指定key对应的value，并删除该key-value对

print(scores.pop('语文'))#99
print(scores)#{'数学': 90, '英语': 95}

参考链接：
Python中字典详解
剑指offer