数据结构习题

编程：
1、 判断两棵树是否相等：node1, node2

2、 判断node1这棵树是否完全包含node2这棵树

3、 扫地机器人，上下左右四个方向，已经走过的地方不会再去，走n
步一共有多少种可能路径

4、二分查找，时间复杂度是多少

5、两个数组如何判断元素完全相等

6、最长不重复子串（取尺or直接暴力）

7、模拟一个栈

8、判断一棵树是否是完全二叉树（bfs）

'''完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。（除了最后一层之外的其他每一层都被完全填充，并且所有结点都保持向左对齐。）'''

 1 # 判断一棵树是否为完全二叉树
 2 # 左无、右有 ==> 返回 False
 3 # 左无、右无 ==> 激活判断：之后所有节点都是叶节点
 4 # 左有、右无 ==> 激活判断：之后所有节点都是叶节点        ==》      只要右无之后都必须是叶节点
 5 # 左有、右有 ==> 不用处理
 6 import queue
 7 def isCBTree(head):
 8     if not head:
 9         return False
10     que = queue.Queue()
11     que.put(head)
12     flag = False                                # 是否激活判断过程
13     while not que.empty():
14         head = que.get()
15         if head.left:
16             que.put(head.left)
17         if head.right:
18             que.put(head.right)
19 
20         if (not head.left) and head.right:      #左空、又不空必不为CBT
21             return False
22 
23         if flag:                                # 若过程激活则判断节点是否为叶节点
24             if head.left or head.right:
25                 return False
26 
27         if not (head.left and head.right):      # 左不空、右空 | 左空、右空
28             flag = True                         # 激活判断在此之后的节点必须为叶节点
29 return True

9、有序数组查找某个树是否出现（二分）

字节算法题

10、反转链表

#反转链表
def reverse(self, head):
    if not head or not head.next:
        return head
    else:
        newhead = self.reverse(head.next) # 新的节点递归head的下一个节点
        head.next.next = head # 当前head节点的下一个节点的下一个节点绕回head
        head.next = None # 反转当前节点后，首节点的下一个节点为空
        return newhead

11、python统计出现单词的个数

# 借助collections模块
import re # re模块提供各种正则表达式的匹配
from collections import Counter

with open("this.txt", 'r', encoing = 'utf-8') as fd:
    texts = fd.read() # 文件的内容读取成一个字符串
    count = Counter(re.split(r"\W+", texts))  # 以单词为分割
    #\W	匹配任意非数字和字母:[^a-zA-Z0-9]
    # re.split() 作用：按照能够匹配的 子串(字符或字符串) 将 字符串 分割后返回 列表 。
result = count.most_common(10) # 统计最长使用的前十个
# most_common()函数用来实现Top n 功能
print(result)

12、三数之和为0

# 三数之和为0，找出所有满足条件的三元组，排序+双指针
def three(nums):
    n = len(nums)
    res = []
    if not nums or n < 3:
        return []
    nums.sort() # 先进行排序
    res = []
    for i in range(n):
        if nums[i] > 0:
            return res # 最小的数都大于0，直接为空
        if (i > 0 and nums[i] == nums[i - 1]):
            continue
        l = i + 1
        r = n - 1
        while l < r:
            if (nums[i] + nums[l] + nums[r]) == 0: # 选定i+ 左+ 右 = 0 ，加入数组
                res.append(nums[i], nums[l], nums[r])
                while (l < r and nums[l] == nums[l + 1]): # 左边连着相等 or 右边连着相等
                    l += 1
                while (l < r and nums[r] == nums[r - 1]):
                    r -= 1
                l += 1
                r -= 1
            elif (nums[i] + nums[l] + nums[r] > 0): # 三数大于0，左移 三数小于0，右移
                r -= 1
            else:
                l += 1
        return res

13、使用正则表达式匹配ip4

#!/usr/bin/python2.7
# -*- coding:utf-8 -*-
import re
 
 
def ipv4_addr_check(ipAddr):
    p = re.compile('^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$')
    if p.match(ipAddr):
        return True
    else:
        return False
 
 
print ipv4_addr_check("120.112.112.110")  # 输出结果为True
 
print ipv4_addr_check("172.31.137.256")  # 输出结果为False

14、中文亿级数转化为int
按照亿万分割成三个部分

数据结构：
堆和栈的区别–java

内存泄漏和内存溢出

1、内存泄漏memory leak :
是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄漏似乎不会有大的影响，但内存泄漏堆积后的后果就是内存溢出。

2、内存溢出 out of memory :
指程序申请内存时，没有足够的内存供申请者使用，或者说，给了你一块存储int类型数据的存储空间，但是你却存储long类型的数据，那么结果就是内存不够用，此时就会报错OOM,即所谓的内存溢出。

3、二者的关系
内存泄漏的堆积最终会导致内存溢出
内存溢出就是你要的内存空间超过了系统实际分配给你的空间，此时系统相当于没法满足你的需求，就会报内存溢出的错误。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。就相当于你租了个带钥匙的柜子，你存完东西之后把柜子锁上之后，把钥匙丢了或者没有将钥匙还回去，那么结果就是这个柜子将无法供给任何人使用，也无法被垃圾回收器回收，因为找不到他的任何信息。
内存溢出：一个盘子用尽各种方法只能装4个果子，你装了5个，结果掉倒地上不能吃了。这就是溢出。比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出。说白了就是我承受不了那么多，那我就报错，
内存泄漏和溢出

数组和链表的区别：
不同：
链表是链式的存储结构；数组是顺序的存储结构。
链表通过指针来连接元素与元素，数组则是把所有元素按次序依次存储。
链表的插入删除元素相对数组较为简单，不需要移动元素，且较为容易实现长度扩充，但是寻找某个元素较为困难；
数组寻找某个元素较为简单，但插入与删除比较复杂，由于最大长度需要再编程一开始时指定，故当达到最大长度时，扩充长度不如链表方便。
相同：
两种结构均可实现数据的顺序存储，构造出来的模型呈线性结构。

平衡二叉树：

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        if not root:
            return True
        return abs(self.depth(root.left) - self.depth(root.right)) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)


    def depth(self, root):
        if not root:
            return 0
        return max(self.depth(root.left), self.depth(root.right)) + 1

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        return self.recur(root) != -1

    def recur(self, root):
        if not root:
            return 0
        left = self.recur(root.left) # 先递归判断左子树是不是平衡二叉树
        if left == -1: # 如果不是，直接返回
            return -1
        right = self.recur(root.right)
        if right == -1:
            return -1
        if abs(left - right) <= 1: # 再判断左右子树的高度差
            return max(left, right) + 1  
        else:
            return -1 # 如果比1大，就返回-1