Python 编程

1、二维数组中，每行从左到右递增，每列从上到下递增，给出一个数，判断它是否在数组中

'''
这个东西没啥写的哈
'''
def getNum(arr, num):
	if arr == None or num == None:
		return False

	line = len(arr)
	cloumn = len(arr[0])

	for i in range(line):
		if arr[i][-1] < num:
			continue
		else:
			for j in range(cloumn-1,-1,-1):
				if arr[i][j] == num:
					return [i, j]
				elif arr[i][j] < num:
					return False
	return False

arr = [[1,2,3],[4,5,6],[7,8,9]]

print(getNum(arr, 55))

2、把字符串中的空格替换成'20%'

def strReplace(str1):
	if not str1:
		return False
	return str1.replace(' ', '20%')

print(strReplace('hello word! good  luck!'))

3、从尾到头打印单链表

#链表节点
class node():
	"""docstring for node"""
	def __init__(self, data=None):
		self.data = data
		self.next = None
	def getNext():
		return self.next
	def setNext(next_node):
		if isinstance(node, next_node):
			self.next =  next_node
			return True
		else:
			return False

#创建链表
def structLinkList(arrList):
	if not arrList:
		return False
	pHead = node(arrList[0])
	tmp = pHead
	for i in range(1,len(arrList)):
		tmp.next = node(arrList[i])
		tmp = tmp.next
	return pHead

link = structLinkList([1,2,3,4,5,6,7])
#用 list 存储链表节点
tmpList = []
while link:
	tmpList.append(link)
	link = link.next
#利用 list pop 出栈实现倒序
while tmpList:
	print(tmpList.pop().data)

4、用前序和中序遍历结果构建二叉树，遍历结果中不包含重复值，例如给出了一个前序（1,2,3,4,5,6,7）和一个中序（3,2,4,1,6,5,7），需要我们给出二叉树结构。

class treeNode():
	"""docstring for treeNode"""
	def __init__(self, data=None):
		self.data = data
		self.left = None
		self.right = None

	def getRightNode():
		return self.right

	def getLeft():
		return self.left

'''
例如给出了一个前序（1,2,3,4,5,6,7）和一个中序（3,2,4,1,6,5,7）,用递归进行重建
'''		
def constructTree(preOrder, inOrder):
	if not preOrder:
		return None
	root = treeNode(preOrder[0])
	point = inOrder.index(preOrder[0])
	#构建左子树
	root.left = constructTree(preOrder[1:point+1], inOrder[:point])
	#构建右子树
	root.right = constructTree(preOrder[point+1:], inOrder[point+1:])
	return root

def drawTree(graphIn, tree):
	if tree and tree.left:
		graphIn.add_edge(tree.data, tree.left.data)
		drawTree(graphIn, tree.left)
	if tree and tree.right:
		graphIn.add_edge(tree.data, tree.right.data)
		drawTree(graphIn, tree.right)
	return graphIn


tree = constructTree([1,2,3,4,5,6,7], [3,2,4,1,6,5,7])

import pygraphviz as pgv
A = pgv.AGraph(directed=True, strict=True)
A = drawTree(A, tree)
A.graph_attr['epsilon'] = '0.01'
A.write('fooOld.dot')
A.layout('dot')
A.draw('tree.png')

5、用两个栈实现队列，分别实现入队和出队操作

class queue():
	def __init__(self):
		self.inQ = []
		self.outQ = []

	def inQueue(self, num):
		self.inQ.append(num)

	def outQueue(self):
		if self.outQ:
			return self.outQ.pop()
		else:
			while self.inQ:
				self.outQ.append(self.inQ.pop())
			return self.outQ.pop()

6、把递增数组的前面部分数字移到队尾，求数组中的最小值，例如[3,4,5,6,1,2]

def rotateArrByBinarySearch(arr):
	#print(arr)
	if not arr:
		return 0
	arrlen = len(arr)
	if arrlen == 1:
		return arr[0]
	elif arrlen == 2:
		if arr[0] > arr[1]:
			return arr[1]
		else:
			return arr[0]
	else:
		if arr[arrlen//2] >= arr[arrlen//2 - 1] and arr[arrlen//2] >= arr[0]:
			return rotateArrByBinarySearch(arr[arrlen//2:])
		elif arr[arrlen//2] >= arr[arrlen//2 - 1] and arr[arrlen//2] <= arr[0]:
			return rotateArrByBinarySearch(arr[:arrlen//2 + 1])
		else:
			return arr[arrlen//2]

7、大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

def Fibonacci(n):
        # write code here
        if n == 0 or n == 1:
            return n
        x0 = 0
        x1 = 1
        i, result = 1,0
        while i < n:
            result = x0 + x1
            x0 = x1
            x1 = result
            i += 1
        return result

def jumpFloor(self, number):
    # write code her
    if number == 1 or number == 2:
        return number
    x1, x2 = 1, 2
    result = 0
    for i in range(number-2):
        x1, x2 = x2, x1 + x2
    return x2

 

8、一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

def jumpFloor(self, number):
    # write code here
    if number == 1 or number == 2:
        return number
    x1, x2 = 1, 2
    result = 0
    for i in range(number-2):
        x1, x2 = x2, x1 + x2
    return x2

9、我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

原本自己觉得用递归就可以是吧，应该没问题吧，很简单很自然，但是在牛客网上提交怎么都不过?，好吧，非递归哈

def rectCover(self, number):
    # write code here
    if number == 0 or number == 1 or number == 2:
        return number
    x1, x2 = 1, 2
    for i in range(number-2):
        x1, x2 = x2, x1+x2
    return x2

10、输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

def NumberOf1(self, n):
    
    num, index = 0, 1
    i = 0
    while i < 32:
        if n & index:
            num += 1
        index = index << 1
        i += 1
    return num

11、给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。讲真，没看出来这个是考察啥的。尼玛

 def Power(base, exponent):
    # write code here
    if exponent == 0:
        return 1
    res = base
    for i in range(abs(exponent)-1):
        res = res * base
    if exponent < 0:
        res = 1/res
    return res

12、输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

def reOrderArray(array):
    # write code here
    odd, even = [],[]
    for i in array:
        if i%2 == 0:
            even.append(i)
        else:
            odd.append(i)
    return odd + even

13、输入一个链表，输出该链表中倒数第k个结点。

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

def FindKthToTail(self, head, k):
    # write code here
    if k == 0:
        return None
    temp = []
    while head:
        temp.append(head.val)
        head = head.next
    k_val = 0
    while(k>0 and len(temp)>0):
        k_val = temp.pop()
        k = k - 1
    if k == 0:
        return k_val
    elif k > 0 and len(temp) == 0:
        return None

14、输入一个链表，反转链表后，输出新链表的表头。

def ReverseList(pHead):
    # write code here
    temp, head = [], pHead
    while pHead:
        temp.append(pHead.val)
        pHead = pHead.next
    pHead = head
    while pHead:
        pHead.val = temp.pop()
        pHead = pHead.next
     return head

15、输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

 

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        if pHead1 == None:
            return pHead2
        if pHead2 == None:
            return pHead1
        newHead, temp = '', ''
        if pHead1.val > pHead2.val:
            temp = pHead2
            newHead = temp
            pHead2 = pHead2.next
        else:
            temp = pHead1
            newHead = temp
            pHead1 = pHead1.next
        while pHead1 and pHead2:
            if pHead1.val > pHead2.val:
                temp.next = pHead2
                pHead2 = pHead2.next
            else:
                temp.next = pHead1
                pHead1 = pHead1.next
            temp = temp.next
        if pHead1 == None:
            temp.next = pHead2
        else:
            temp.next = pHead1
        return newHead
         

16、操作给定的二叉树，将其变换为源二叉树的镜像。

二叉树的镜像定义：源二叉树 
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

def Mirror(root):
    # write code here
    if root == None:
        return None
    temp = root.left
    root.left = Mirror(root.right)
    root.right = Mirror(temp)
    return root

17、输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

'''好吧，居然没测试通过，没看出有什么问题呀，除非矩阵不是 n*n ，而是 m*n 的'''
def printMatrix(self, matrix):
    # write code here
    temp = []
    lenth = len(matrix)
    for i in range(lenth//2):
        for j in range(i,lenth-i):
            temp.append(matrix[i][j])
        for j in range(i+1, lenth-i):
            temp.append(matrix[j][lenth-i-1])
        for j in range(lenth-i-2,i,-1):
            temp.append(matrix[lenth-i-1][j])
        for j in range(lenth-1-i,i,-1):
            temp.append(matrix[j][i])
    if lenth%2 != 0:
        temp.append(matrix[lenth//2][lenth//2])
    return temp

18、定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

class Solution:
    def __init__(self):
        self.ab = []
        self.cd = []
    def push(self, node):
        # write code here
        if len(self.cd)==0:
            self.cd.append(node)
        elif node > self.cd[-1]:
            self.cd.append(self.cd[-1])
        else:
            self.cd.append(node)
        self.ab.append(node)
    def pop(self):
        # write code here
        if len(self.ab) != 0:
            self.cd.pop()
            return self.ab.pop()
        else:
            return False
    def top(self):
        # write code here
        if len(self.ab) != 0:
            return self.ab[-1]
        else:
            return False
    def min(self):
        # write code here
        return self.cd[-1]

19、输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

'''
这段代码在牛客网上测试，case 通过率一直是87.5%，找了半天原因，后来恍然大悟，估计是当 sequence 是空的时候，牛客网认为是 False，好吧，不管它了，就这么写，只能说它的测试用例不好哈
'''
def VerifySquenceOfBST(sequence):
    # write code here
    if len(sequence) == 1 or len(sequence) == 0:
        return True
    root = sequence[-1]
    i = 0
    while root > sequence[i]:
        i = i + 1
    j = i
    while sequence[i] > root:
        i = i + 1
    if i != len(sequence) - 1:
        return False
    return VerifySquenceOfBST(sequence[:j]) and VerifySquenceOfBST(sequence[j:-1])

20、输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

#自己写的有点问题，提交测试失败
 def Clone(self, pHead):
        # write code here
        if not pHead:
            return None
        # 复制一遍原节点
        p1 = pHead
        while p1:
            p = RandomListNode(p1.label)
            p.next = p1.next
            p1.next = p
            p1 = p.next
        # 增加随机指针
        p1 = pHead
        while p1:
            p1.next.random = p1.random.next
            p1 = p1.next.next
        # 拆分链表
        p1 = pHead
        p2 =  p1.next
        pHead2 = p2
        while p1:
            p1.next = p1.next.next
            p1 = p1.next
            p2.next = p2.next.next
            p2 = p2.next
        return pHead2

#这个是提交可以成功的，不知道为什么?
def Clone(self, pHead):
        # write code here
        pNode=pHead
        while pNode!=None:
            pClone=RandomListNode(pNode.label)
            pClone.next=pNode.next
            pNode.next=pClone
            pNode=pClone.next
        self.ConnectSiblingNodes(pHead)
        return self.ReconnectNodes(pHead)       
    def ConnectSiblingNodes(self,pHead):
        pNode=pHead
        while pNode!=None:
            pClone=pNode.next
            if pNode.random!=None:
                pClone.random=pNode.random.next
            pNode=pClone.next
    def ReconnectNodes(self,pHead):
        pNode=pHead
        pCloneHead=None
        pCloneNode=None
        if pNode!=None:
            pCloneHead=pCloneNode=pNode.next
            pNode.next=pCloneNode.next
            pNode=pNode.next
        while pNode!=None:
            pCloneNode.next=pNode.next
            pCloneNode=pCloneNode.next
            pNode.next=pCloneNode.next
            pNode=pNode.next
        return pCloneHead

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

#搞了半天才搞定，现在都开始怀疑自己的编程能力了?
def Permutation(self, ss):
    def helper(sk):
        if len(sk) == 1:
            return [list(sk)]
        s1 = list(set(sk))
        s1.sort()
        s2 = list(sk)
        nl = []
        for i in range(len(s1)):
            temp = list(s2)
            temp.remove(s1[i])
            t = helper(''.join(temp))
            for j in range(len(t)):
                nl.append([s1[i]] + t[j])
        return nl
    ha = helper(ss)
    res = []
    for i in ha:
        res.append(''.join(i))
    return res

22、数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        temp = list(numbers)
        temp.sort()
        lenth = len(temp)

        nu = temp[lenth//2]
        index = 0
        for i in temp:
            if i == nu:
                index += 1
        if index * 2 > lenth:
            return nu
        else:
            return 0

23、输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        # write code here
        lenth = len(tinput)
        if k > lenth:
            return []
        tinput.sort()
        return tinput[:k]

24、输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

#好尼玛伤心，别人两行代码搞定了，我写了这么多?
'''
class Solution:
    def PrintMinNumber(self, numbers):
        # write code here
        if not numbers:
            return ""
        num=map(str,numbers)
        num.sort(lambda x,y:cmp(x+y,y+x))
        return ''.join(num)
'''
class Solution:
    def PrintMinNumber(self, numbers):
        # write code here
        def compare(a, b):
            if str(a) + str(b) > str(b) + str(a):
                return True
            else:
                return False

        def quickSort(num, beg, end):
            if beg >= end:
                return
            v = num[beg]
            b, e = beg, end
            #pdb.set_trace()
            while b < e:
                while b < e and compare(num[e], v) is True:
                    e -= 1
                num[b] = num[e]
                while b < e and compare(num[b], v) is False:
                    b += 1
                num[e] = num[b]
            num[b] = v
            quickSort(num, beg, b - 1)
            quickSort(num, b + 1, end)

        quickSort(numbers, 0, len(numbers)-1)
        small = ''
        for i in range(len(numbers)):
            small += str(numbers[i])
        return small

25、基数排序，假设排序最高为3位，从个位开始排序，稳定排序

from random import randint

'''little 2 big'''
def radix_sort(list, d=3):
    for i in range(d):
        temp = [[] for ii in range(10)]
        for j in list:
            aa = (j//(10**i)) % 10
            temp[aa].append(j)
        list = [tx for t in temp for tx in t]
        #print(list)
    return list


a = [randint(1, 999) for i in range(10)]
print(a)
a = radix_sort(a, 3)
print(a)

26、堆排序

from random import randint
def sift_down(lst, start, end):
    left = 2 * start + 1
    right = left + 1
    bigger = start
    if left < end and lst[left] > lst[bigger]:
        bigger = left
    if right < end and lst[right] > lst[bigger]:
        bigger = right
    if bigger != start:
        lst[start], lst[bigger] = lst[bigger], lst[start]
        sift_down(lst, bigger, end)


'''堆排序，大顶堆'''
def Heap_sort(lst):
    lenth = len(lst)
    for i in range((len(lst) - 2) // 2, -1, -1):
        sift_down(lst, i, lenth - 1)

    for end in range(len(lst) - 1, 0, -1):
        lst[0], lst[end] = lst[end], lst[0]
        sift_down(lst, 0, end - 1)
    return lst


a = [randint(1, 999) for i in range(10)]
print(a)
a = Heap_sort(a)
print(a)