刷题小日记

软件python3

二维数组中的查找

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

1. 思路 ：数组从左到右递增，从上到下递增，所以遍历数组，首先定义i，j，i 为数组行数，j为0，那么此时指针在array[rows,0]，即左下角位置，如果target大于该值，那么指针应该向比当前值大的方向移动，即向右移动，j+=1，如果target小于该值，那么应该向更小的方向移动，即往上移动，i-=1，else：target=该值；
2. 相关知识点 ：
   数组行列的取法：
   rows = len(array) - 1
   cols= len(array[0]) - 1
   while循环：while j<=cols and i>=0:
   if:
   elif:
   else:
   return True；
   3.代码：

class Solution():
	def Find(self,target,array):
		rows = len(array) -1
		columns  = len(array[0]) - 1
		i = rows
		j = 0
		while j<=columns and i>=0:
			if target<array[i][j]:
				i-=1
			elif target>array[i][j]:
				j+=1
			else:
				return True
		return False

替换空格

题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
1.思路：先将s变为一个列表,方便对其进行遍历，然后s[i]替换
2.知识点：
将字符串变为列表只需list（s）即可
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
3.代码

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

从尾到头打印链表

题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
1.思路：先建立一个空列表，然后将值append进去，然后列表反向[::-1],输入值是ListNode.val 然后迭代，将listnode.next赋给listnode
3.代码：

class Solution:
	def printreverselistnode(self,listnode):
		arraylist = []
		while listnode:
			arraylist.append(listnode.val)
			listnode = listnode.next
		return arraylist[::-1]

2.知识点：链表与数组的区别
数组是将元素在内存中连续存放，可以通过下标迅速访问数组中任何元素array[i]。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中；如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。
需要快速访问数据，很少或不插入和删除元素，选择数组。
链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起。比如：上一个元素有个指针指到下一个元素,(curNode.next())以此类推，直到最后一个元素。如果要访问链表中一个元素，需要从第一个元素开始(head)，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了(a.next()=a.next.next())。
需要经常插入和删除元素需要用链表了。

优缺	数组	链表
优点	随机访问性强；查找速度快	插入删除速度快；内存利用率高，不会浪费内存；大小没有固定，拓展很灵活。
缺点	插入和删除效率低；可能浪费内存；内存空间要求高，必须有足够的连续内存空间。数组大小固定，不能动态拓展	不能随机查找，必须从第一个开始遍历，查找效率低
读取	o(1)	o(n)
插入	o(n)	o(1）
删除	o(n)	o(1）

链表中每一个元素都是一个对象，每个对象称为一个节点，包含有数据域key和指向下一个节点的指针next。通过各个节点之间的相互连接，最终串联成一个链表。

定义节点和构造链表

class Node:
	def __init__(self,val,next):
		self.val = val 
		self.next = None
#链表的构造包括赋值和链接进链表
#实例化节点 Node括号里是val 赋值
a = Node(1)
b = Node(2)
c = Node(3)
#构造链表 链接
t.next = f
b.next = t
#取节点c的值 取值.val
b.next.val
#节点的插入
p=Node(5)
p.next = curNode.next
curNode.next = p
#节点的删除
p = curNode.next
curNode.next = curNode.next.next
del p
#节点的遍历
def traversal(head):
	curNode = head
	while curNode is not None:
		print(curNode)
		curNode = curNode.next
#头插法，每一个新节点都插入到头节点后面#head指向头节点
def create_head(listnode):
	head = Node(None)
	for num in listnode:
		s = Node(num)
		s.next  = head.next
		head.next = s
	return head
#尾插法每一个新节点都插入到最后一个节点后面# tail指向尾节点
def create_tail(listnode):
	head = Node(None)
	tail = head
	for num in listnode:
		s = Node(num)
		tail.next = s.next
		tail = s
	return head

重建二叉树

题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
1.思路：按照知识点中思路及先从前序找到跟节点pre[0]，然后再在中序中找到该元素的位置，左边是左子树，右边是右子树的中序，该元素位置为pos=tin.index(pre[0]),然后左面递归调用函数，（pre[1:1+pos],tin[:pos])；右子树递归调用（pre[pos+1:],tin[pos+1:]).要考虑到pre里面没有元素的情况返回none

2.知识点：二叉树：前序根左右中序左根右后序左右根
已知一棵二叉树的前序和中根序，构造该二叉树的过程如下：

1. 根据前序序列的第一个元素建立根结点；1
2. 在中序序列中找到该元素，确定根结点的左右子树的中序序列；4，7，2 ；5，3，8，6
3. 在前序序列中确定左右子树的前序序列；2，4，7；3，5，6，8
4. 由左子树的前序和中序建立左子树；
5. 由右子树的前根序序列和中根序序列建立右子树。

已知一棵二叉树的后序和中序，构造该二叉树的过程如下：

1. 根据后根序列的最后一个元素建立根结点；
2. 在中序序列中找到该元素，确定根结点的左右子树的中序序列；
3. 在后序序列中确定左右子树的后序；
4. 由左子树的后序序列和中序序列建立左子树；
5. 由右子树的后序序列和中序序列建立右子树。
   3.代码：

class solution:
	def reConstructBinaryTree(self, pre, tin):
		if len(pre) == 0:
			return None
		root = TreeNode(pre[0])
		pos = tin.index(pre[0])
		root.left = self.reConstructBinaryTree(pre[1:pos+1],tin[:pos])
		root.right = self.reConstructBinaryTree(pre[pos+1:],tin[pos+1:])
		return root

TreeNode(
self.reConstructBinaryTree(

用两个栈实现一个队列

题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
1.思路：栈先进后出，队列的push和pop操作 先推进去先出来 表尾插入表头出，两个栈实现一个队列就是两个栈的栈顶分别作为队列的表头和表尾，用于push和pop，先进栈的后出到第二个栈里面转换顺序形成队列。
2.知识点：栈的插入和删除操作只允许在表的尾端进行（在栈中成为“栈顶”），满足“FILO：First In Last Out”；队列只允许在表尾插入数据元素，在表头删除数据元素,满足“First In First Out”。
3.代码：

class Solution:
    def push(self, node):
        
        
    def pop(self):