在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

思路：从左下角元素往上查找，右边元素是比这个元素大，上边是的元素比这个元素小。于是，target比这个元素小就往上找，比这个元素大就往右找。如果出了边界，则说明二维数组中不存在target元素。

array= [[1,2,3],[2,3,4],[3,4,5]]
def find_item(item,array):cols = len(array[0]) - 1rows = len(array) - 1i = rows j = 0while j <= cols and i >= 0 :if item > array[i][j]:j += 1elif item <  array[i][j]:i -= 1else:return Truereturn False

二维列表第一个数字相加生成一个新列表e

k = [[1],[1, 2],[1, 2, 3],[1, 2, 3, 4]]
e = []
for i in range(len(k[-1])):num = 0for L in k :if len(L) > i:num +=L[i]e.append(num)
print(e)

二维列表旋转90度

a = [[1,2,3],[3,4,5],[2,3,5]]
b = []
for i in range(len(a)):c = []for L in a:c.insert(0, L[i]) # 插入到c的第一个元素之前b.append(c)
print(b)
b=[[2, 3, 1], [3, 4, 2], [5, 5, 3]]

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

思路：转成列表，循环遍历下标替换即可，还可以直接用a = replace(' ', '%20')

   def replaceSpace(self, s):a = list(s)for i in range(len(a)):if a[i] == ' ':a[i] = '%20'  return ''.join(a)

在一个先增长后减小的数组中找到最大值

思路：二分法算法的应用，先找到中间值，如果前一个和一个都比这个值小，则这个值就是最大值

A = [1,2,3,4,5]
B = [9,4,3,2,1]
C = [1,2,3,4,3,2,1]
def peek_point(A):start = 0end = len(A)-1while start <= end:mid = (start + end) // 2try: # 一直递增a=A[mid+1]except:return A[-1]try: # 一直递减b=[mid-1]except:return A[0]if A[mid-1] < A[mid] > A[mid+1]: # 先递增后递减return A[mid]elif A[mid] >= A[mid-1]:start = mid + 1else:end = midprint(peek_point(A))
print(peek_point(B))
print(peek_point(C))

一个有正有负的数组中，求出一个连续子数组和是最大的值（注意：任意元素个数组成的连续的子数组）

思路：求出所有子序列，开始下标可以是0~len(arr)-1,结束下标可以是1~len(arr)（此代码可优化，各位大佬可以帮想一下）

def find_big(arr):zlist=[]for i in range(0, len(arr)):for j in range(i,len(arr)):num = zlist.append(sum(arr[i:j+1]))return max(zlist)
print(find_big([1,-2,-3,4,3,-1,2])) # --》8

对字符串a=‘abc’进行随意组合成不同顺序的字符串，例如acb,bac…6种组合方式

a='abc'
[(i+j+m) for i in a for j in a for m in a if i != j and j !=m and i!=m]

对字典列表按年龄进行倒序排序d_list = [{'name':'a','age':18},....]

d_list.sort(key=lambda x:x['age'],reverse = True)

如何将一个可迭代对象的每个元素变成一个字典的所有键？

{}.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路：斐波那契数列

fib = lambda n: n if n <=2 else fib(n-1) + fib(n-2)

一只青蛙一次可以跳上1级台阶，也可跳2级。还可跳n级台阶，求该青蛙跳上一个n级的台阶总共有多少种跳法。

fib = lambda n:n if n < 2 else fib(n-1)*2

实现删除一个 L1=[1,2,3,3,2]里面的重复元素，保证原序

L2 = list(set(L1))
L2.sort(key = L1.index)
# 使用列表生成时 append
L2 = []
[L2.append(i) for i in L1 if i not in L2]

合并两个有序列表

def loop_merge_sort(l1, l2):tmp = []while len(l1) > 0 and len(l2) > 0:if l1[0] > l2[0]:tmp.append(l2[0])del l2[0] # 列表删除时间复杂度大else:tmp.append(l1[0])del l1[0]tmp.extend(l1)tmp.extend(l2)return tmp

# 不删除元素，采用归并a = [1,2,3,4] 、 b = [5,6,7]
def merge(a,b):L,R=0,0slist=[]while L < len(a) and R < len(b):if a[L] > b[R]:slist.append(b[R])R +=1else:slist.append(a[L])L +=1slist+=a[L:]slist+=b[R:]return slist

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution:# 返回从尾部到头部的列表值序列，例如[1,2,3]def printListFromTailToHead(self, listNode):l = []head = listNodewhile head:l.insert(0, head.val)head = head.nextreturn l

实现一个二叉树，有add添加节点方法，前中后序遍历，层次遍历

class Node(object):def __init__(self,elem=-1, lchild=None, rchild=None):self.elem = elemself.lchild = lchildself.rchild = rchild
class Tree(object):def __init__(self,root=None):self.root = rootdef add(self,elem):node = Node(elem)if self.root == Noneself.root = nodeelse:queue = []queue.append(self.root)# 往队列添加跟节点# 对已有的节点进行层次遍历while queue:cur = queue.pop(0)if cur.lchild == None:cur.lchild = nodereturnelif cur.rchild == None: cur.rchild = nodereturnelse:#如果左右子树都不为空，加入队列继续判断queue.append(cur.lchild)queue.append(cur.rchild)def q_order(self, root):'''先序遍历'''if root == None:returnprint(root.elem)self.q_order(root.lchild)self.q_order(root.rchild)def z_order(self,root):'''中序遍历print语句放在中间'''def h_order(self,root):'''后续遍历同理放在后面'''def breadth_travel(self):"""利用队列实现树的层次遍历"""if root == None:returnqueue = []queue.append(root)while queue:node = queue.pop(0)print(node.elem) # 先打印跟节点if node.lchild != None:queue.append(node.lchild)if node.rchild != None:queue.append(node.rchild)

文件操作

def ws(id,name):stu = str(id) + ','+name+'\n'with open('d.txt','a+',encoding='utf8') as f:f.seek(0) # 移动坐标到文件开头contents = f.readlines()flag = Falsefor i, c in enumerate(contents):y_id = c.rstrip().split(',')[0]if id == int(y_id): # 发现第i行重复的id，那就更改这行的内容contents[i] = stuflag = Trueif not flag: # 如果没找到重复的id，直接追加到文件尾部f.write(stu)if flag: # 如果读到的内容被更改了，覆盖源文件，写入新数据with open('d.txt','w',encoding='utf8') as f2:f2.write(''.join(contents))

实现一个链表的append和printl方法

class LinkNode(object):'''实现一个节点类'''def __init__(self, x):self.val = xself.next = None
class LinkedList(object):'''实现链表类'''def __init__(self):self._head = Nonedef is_empty(self):return self._head == Nonedef append(self,x):node = LinkNode(x)if self.is_empty():self._head = nodeelse:cur	 = self._headwhile cur.next != None: # 找出cur = cur.nextcur.next = nodedef printl(self):'''遍历打链表'''cur = self._headwhile cur != None:print(cur.val,end='')cur = cur.next
l = LinkedList()
l.append('abc')
l.append('xyz')
l.printl()

# 常用的链表方法
class SingleLinkList(object):"""单链表"""def __init__(self):self.__head = Nonedef is_empty(self):"""判断链表是否为空"""return self.__head == Nonedef length(self):"""链表长度"""# cur初始时指向头节点cur = self.__headcount = 0# 尾节点指向None，当未到达尾部时while cur != None:count += 1# 将cur后移一个节点cur = cur.nextreturn countdef travel(self):"""遍历链表"""cur = self.__headwhile cur != None:print cur.item,cur = cur.nextprint ""def add(self, item):"""头部添加元素"""# 先创建一个保存item值的节点node = SingleNode(item)# 将新节点的链接域next指向头节点，即_head指向的位置node.next = self.__head# 将链表的头_head指向新节点self.__head = nodedef append(self, item):"""尾部添加元素"""node = SingleNode(item)# 先判断链表是否为空，若是空链表，则将_head指向新节点if self.is_empty():self.__head = node# 若不为空，则找到尾部，将尾节点的next指向新节点else:cur = self.__headwhile cur.next != None:cur = cur.nextcur.next = nodedef insert(self, pos, item):"""指定位置添加元素"""# 若指定位置pos为第一个元素之前，则执行头部插入if pos <= 0:self.add(item)# 若指定位置超过链表尾部，则执行尾部插入elif pos > (self.length()-1):self.append(item)# 找到指定位置else:node = SingleNode(item)count = 0# pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置pre = self.__headwhile count < (pos-1):count += 1pre = pre.next# 先将新节点node的next指向插入位置的节点node.next = pre.next# 将插入位置的前一个节点的next指向新节点pre.next = nodedef remove(self,item):"""删除节点"""cur = self.__headpre = Nonewhile cur != None:# 找到了指定元素if cur.item == item:# 如果第一个就是删除的节点if not pre:# 将头指针指向头节点的后一个节点self.__head = cur.nextelse:# 将删除位置前一个节点的next指向删除位置的后一个节点pre.next = cur.nextbreakelse:# 继续按链表后移节点pre = curcur = cur.nextdef search(self,item):"""链表查找节点是否存在，并返回True或者False"""cur = self.__headwhile cur != None:if cur.item == item:return Truecur = cur.nextreturn False

判断一个单链表是否有环

思路：快慢两个游标都从head开始，快游标依次移动2步，慢移动1步，如果有环，总会相遇

def exist_h(linkList):p1 = p2 = linkList  # 指针指向头结点while p2 and p2.next:  # 当链表为空，或者没有下一个节点时，表示没有环p1 = p1.next  # 一次移动一步p2 = p2.next.next  # 一次移动两步if p1 == p2:  # 如果两个游标相交，那么说明有环return Truereturn Falseif __name__ == '__main__':l = LinkNode(1) # 头结点l1 = LinkNode(2)l2 = LinkNode(3)l3 = LinkNode(4)l4 = LinkNode(5)# 组成一条链l.next = l1l1.next = l2l2.next = l3l3.next = l4l4.next = l2 # l4结点指向l2结点，有环print(exist_h(l)) # 返回 True