剑指offer的Python实现（六）

26.二叉搜索树与双向链表

题目描述

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向

 

# -*- coding:utf-8 -*-

# class TreeNode:

#     def __init__(self, x):

#         self.val = x

#         self.left = None

#         self.right = None

class Solution:

    def Convert(self, root):

        # write code here

        if not root:

            return

        self.arr = []

        self.midTraversal(root)

        for i, v in enumerate(self.arr[:-1]):

            v.right = self.arr[i+1]

            self.arr[i+1].left = v

        return self.arr[0]

    def midTraversal(self,root):

        if not root:

            return

        self.midTraversal(root.left)

        self.arr.append(root)

        self.midTraversal(root.right)

先中序遍历，将所有的节点保存到一个列表中。对这个list[:-1]进行遍历，每个节点的right设为下一个节点，下一个节点的left设为上一个节点。

enumerate 函数用于遍历序列中的元素以及它们的下标：

>>> for i,j in enumerate(('a','b','c')):
 print i,j

 
0 a
1 b
2 c

27.字符串的排列

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
来源：牛客网

思路：递归法，问题转换为先固定第一个字符，求剩余字符的排列；求剩余字符排列时跟原问题一样。

(1) 遍历出所有可能出现在第一个位置的字符（即：依次将第一个字符同后面所有字符交换）；

(2) 固定第一个字符，求后面字符的排列（即：在第1步的遍历过程中，插入递归进行实现）。

需要注意的几点：

(1) 先确定递归结束的条件，例如本题中可设begin == str.size() - 1; 

(2) 形如 aba 或 aa 等特殊测试用例的情况，vector在进行push_back时是不考虑重复情况的，需要自行控制；

(3) 输出的排列可能不是按字典顺序排列的，可能导致无法完全通过测试用例，考虑输出前排序，或者递归之后取消复位操作。

（1）

# -*- coding:utf-8 -*-

class Solution:

    def Permutation(self, ss):

        # write code here

        res = []

        if len(ss) < 2:

            return ss.split()

        for i in range(len(ss)):

            for n in map(lambda x: x+ ss[i], self.Permutation(ss[:i]+ss[i+1:])):

                if n not in res:

                    res.append(n)

        return sorted(res)

（2）

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
来源：牛客网

# -*- coding:utf-8 -*-

import itertools

class Solution:

    def Permutation(self, ss):

        # write code here

        result=[]

        if not ss:

            return []

        else:

            res=itertools.permutations(ss)

            for i in res:

                if "".join(i) not in result:

                    result.append("".join(i))

        return result

 

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
来源：牛客网

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
来源：牛客网

class Solution:
    def Permutation(self, ss):
        if len(ss)==0:
            return []
        if len(ss)==1:
            return [ss]
        res=set()
        for i in range(len(ss)):
            for j in self.Permutation(ss[:i]+ss[i+1:]):
                res.add(ss[i]+j)

        return sorted(list(res))

 

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
来源：牛客网

分为两步：

1. 求所有可能在第一个位置的字符，即把第一个字符和后面的依次交换
2. 固定第一个字符，求后面所有字符的排列。后面所有的字符又可看成第一个字符跟后面所有的字符的排列。典型的递归思路
3. 链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
   来源：牛客网
4. # -*- coding:utf-8 -*-
5. class Solution:
6.     def Permutation(self, ss):
7.         if not ss:
8.             return []
9.          
10.         def Permutation(startIdx):
11.             if startIdx >= len(arrSs):
12.                 clone = ''.join(arrSs)
13.                 res.append(clone)
14.             else:
15.                 changeIdx = startIdx
16.                 while changeIdx < len(arrSs):
17.                     arrSs[changeIdx], arrSs[startIdx] = arrSs[startIdx], arrSs[changeIdx]
18.                     Permutation(startIdx + 1)
19.                     arrSs[changeIdx], arrSs[startIdx] = arrSs[startIdx], arrSs[changeIdx]
20.                     changeIdx += 1
21.          
22.         res = []
23.         arrSs = list(ss)
24.         Permutation(0)
25.         res = list(set(res))
26.         return sorted(res)

 

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7
来源：牛客网

# -*- coding:utf-8 -*-

class Solution:

    def Permutation(self, ss):

        # write code here

        if(len(ss) ==0):

            return []

        if(len(ss) == 1):

            return list(ss)

        result = []

        tmp = list(ss)

        keep = list(ss)

        for i in set(keep):

            tmp = list(ss)

            tmp.pop(tmp.index(i))

            ans = self.Permutation(tmp)

            ans = [i+j for j in ans]

            result.extend(ans)

        return sorted(result)