经典逻辑编程题（本文用python实现）

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

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

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

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

k = [[1],
 	[1, 2],
 	[1, 2, 3],
 	[1, 2, 3, 4]]
e = []
for i in range(len(k[-1])):
    num = 0
    for 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 = 0
    end = len(A)-1
    while start <= end:
        mid = (start + end) // 2
        try: # 一直递增
            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 + 1
        else:
            end = mid

print(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,0
    slist=[]
    while L < len(a) and R < len(b):
        if a[L] > b[R]:
            slist.append(b[R])
            R +=1
        else:
            slist.append(a[L])
            L +=1
    slist+=a[L:]
    slist+=b[R:]
    return slist

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

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

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

class Node(object):
	def __init__(self,elem=-1, lchild=None, rchild=None):
		self.elem = elem
		self.lchild = lchild
		self.rchild = rchild
class Tree(object):
	def __init__(self,root=None):
		self.root = root
	def add(self,elem):
		node = Node(elem)
		if self.root == None
			self.root = node
		else:
			queue = []
			queue.append(self.root)# 往队列添加跟节点
			# 对已有的节点进行层次遍历
			while queue:
				cur = queue.pop(0)
				if cur.lchild == None:
					cur.lchild = node
					return
				elif cur.rchild == None: 
					cur.rchild = node
					return
				else:
					#如果左右子树都不为空，加入队列继续判断
					queue.append(cur.lchild)
					queue.append(cur.rchild)
	def q_order(self, root):
		'''先序遍历'''
		if root == None:
			return
		print(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:
            return
        queue = []
        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 = False
        for i, c in enumerate(contents):
            y_id = c.rstrip().split(',')[0]
            if id == int(y_id): # 发现第i行重复的id，那就更改这行的内容
                contents[i] = stu
                flag = True
        if 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 = x
		self.next = None
class LinkedList(object):
	'''实现链表类'''
	def __init__(self):
		self._head = None
	def is_empty(self):
		return self._head == None
	def append(self,x):
		node = LinkNode(x)
		if self.is_empty():
			self._head = node
		else:
			cur	 = self._head
			while cur.next != None: # 找出
				cur = cur.next
			cur.next = node
	def printl(self):
		'''遍历打链表'''
		cur = self._head
		while 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 = None

    def is_empty(self):
        """判断链表是否为空"""
        return self.__head == None

    def length(self):
        """链表长度"""
        # cur初始时指向头节点
        cur = self.__head
        count = 0
        # 尾节点指向None，当未到达尾部时
        while cur != None:
            count += 1
            # 将cur后移一个节点
            cur = cur.next
        return count

    def travel(self):
        """遍历链表"""
        cur = self.__head
        while cur != None:
            print cur.item,
            cur = cur.next
        print ""
    def add(self, item):
        """头部添加元素"""
        # 先创建一个保存item值的节点
        node = SingleNode(item)
        # 将新节点的链接域next指向头节点，即_head指向的位置
        node.next = self.__head
        # 将链表的头_head指向新节点
        self.__head = node
    def append(self, item):
        """尾部添加元素"""
        node = SingleNode(item)
        # 先判断链表是否为空，若是空链表，则将_head指向新节点
        if self.is_empty():
            self.__head = node
        # 若不为空，则找到尾部，将尾节点的next指向新节点
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
    def 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.__head
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 先将新节点node的next指向插入位置的节点
            node.next = pre.next
            # 将插入位置的前一个节点的next指向新节点
            pre.next = node
	def remove(self,item):
        """删除节点"""
        cur = self.__head
        pre = None
        while cur != None:
            # 找到了指定元素
            if cur.item == item:
                # 如果第一个就是删除的节点
                if not pre:
                    # 将头指针指向头节点的后一个节点
                    self.__head = cur.next
                else:
                    # 将删除位置前一个节点的next指向删除位置的后一个节点
                    pre.next = cur.next
                break
            else:
                # 继续按链表后移节点
                pre = cur
                cur = cur.next
	def search(self,item):
        """链表查找节点是否存在，并返回True或者False"""
        cur = self.__head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return 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 True
    return False

if __name__ == '__main__':
    l = LinkNode(1) # 头结点
    l1 = LinkNode(2)
    l2 = LinkNode(3)
    l3 = LinkNode(4)
    l4 = LinkNode(5)
	# 组成一条链
    l.next = l1
    l1.next = l2
    l2.next = l3
    l3.next = l4
    l4.next = l2 # l4结点指向l2结点，有环

    print(exist_h(l)) # 返回 True