Day02_1单链表代码

01_sigleLinkList.py

"""单链表节点对象 --> 类域       --> 类属性
"""class Node:"""节点类"""def __init__(self, value):self.value = valueself.next = Noneclass SingleLinkList:"""单链表"""def __init__(self, node=None):"""list01 = list() --> list(xx)s = SingleLinkList() 表示空链表s = SingleLinkList(Node(100)) 表示有一个节点的链表"""self.head = nodedef is_empty(self):"""判断链表是否为空"""return self.head == Nonedef add(self, item):"""在链表头部添加节点"""node = Node(item)node.next = self.headself.head = nodedef travel(self):"""遍历整个链表 ---> 创建游标  移动游标"""# 创建游标cur = self.headwhile cur:print(cur.value)cur = cur.nextdef append(self, item):"""在链表尾部增加元素注意：考虑空链表情况"""node = Node(item)if self.is_empty():  # 空链表情况self.head = nodereturnelse:  # 非空链表情况cur = self.headwhile cur.next:cur = cur.nextcur.next = nodeif __name__ == '__main__':s = SingleLinkList()# 打印1：Trueprint(s.is_empty())# 头部添加节点对象s.add(300)s.add(200)s.add(100)s.add(50)# 打印2：Falseprint(s.is_empty())# 遍历链表 --> 头到尾s.travel()# 在链表尾部添加节点s.append(400)s.travel()

Day02_1单链表视图

Day02_1回顾

Python 开发：
公司：新创型公司 京东外包

面试题：
你是怎么理解闭包？
你如何理解装饰器？装饰器的应用
迭代器是什么？
生成器是什么？

进程、线程、协程的区别？
GIL是什么?为什么要有GIL？【GIL锁、线程锁】
为什么我们有了GIL,但是在多线程的时候还需要加锁？MySQL的主键索引和唯一索引有什么区别？【索引、引擎、事务、优化、锁】
【索引的优点：为了加快数据检索的速度，缺点：索引需要动态维护消耗资源，索引需要占用物理存储空间】
MySQL的引擎都有什么?【InnDB：支持外键、支持事务、支持行级锁、适用用于写操作多的表，MyISAM：支持表级锁，适用于读操作多的表，MEMORY：表记录储存在内存中，适用于临时表】
数据库如何优化？如何优化查询？【分组、聚合、排序、筛选、连接查询】
如何开启慢查询？
B树和B+树的优点和使用场景？
【事务：原子性：一致性：隔离性：持久性】
【优化】DJANGO 的请求流程？
高并发的处理
如何进行会话状态的保持
如何解决跨域问题?
CSRF跨站攻击如何防范?
如何加速数据的查询？如何防范SQL注入？
celery的核心组件有哪些？【消息中间件broker【Redis】、Worker、Backend】【prefork、 -P 】各种排序算法？针对于项目，你遇到了那些问题？如何解决？
其他：编码规范

---

数据结构和算法：
程序 = 数据结构 + 算法

时间复杂度：大O表示法，最坏情况下面执行的次数数据结构：线性结构：顺序表：单链表：栈：队列：非线性结构：

---

Day02_2单链表代码

01_sigleLinkList.py

"""单链表节点对象 --> 类域       --> 类属性
"""class Node:"""节点类"""def __init__(self, value):self.value = valueself.next = Noneclass SingleLinkList:"""单链表"""def __init__(self, node=None):"""list01 = list() --> list(xx)s = SingleLinkList() 表示空链表s = SingleLinkList(Node(100)) 表示有一个节点的链表"""self.head = nodedef is_empty(self):"""判断链表是否为空"""return self.head == Nonedef add(self, item):"""在链表头部添加节点"""node = Node(item)node.next = self.headself.head = nodedef travel(self):"""遍历整个链表 ---> 创建游标  移动游标"""# 创建游标cur = self.headwhile cur:print(cur.value)cur = cur.nextdef append(self, item):"""在链表尾部增加元素注意：考虑空链表情况"""node = Node(item)if self.is_empty():  # 空链表情况self.head = nodereturnelse:  # 非空链表情况cur = self.headwhile cur.next:cur = cur.nextcur.next = nodedef insert(self, pos, item):"""在指定位置插入节点"""node = Node(item)# 空链表if not self.head:self.append(item)return# 非空链表elif pos > self.length() - 1:self.append(item)else:cur = self.headmiddle = 0while middle < (pos - 1):cur = cur.nextmiddle += 1node.next = cur.nextcur.next = nodedef length(self):"""获取链表长度"""if not self.head:return 0cur = self.headcount = 1while cur.next:cur = cur.nextcount += 1return countdef remove(self, item):"""删除一个节点"""pre = None  # 游标前的一个节点cur = self.head# 1. 删除头节点的情况if self.head.value == item:self.head = self.head.nextreturn# 2. 删除非头结点的情况while True:if cur.value == item:pre.next = cur.nextreturnpre = curcur = cur.nextif __name__ == '__main__':s = SingleLinkList()# 打印1：Trueprint(s.is_empty())# 头部添加节点对象s.add(300)s.add(200)s.add(100)s.add(50)# 打印2：Falseprint(s.is_empty())# 遍历链表 --> 头到尾s.travel()# 在链表尾部添加节点s.append(400)s.travel()# 在指定位置插入节点s.insert(2, 250)print('---------')s.travel()# 删除节点s.remove(50)print('---------')s.travel()

Day02_2单链表视图

---

Day02_3栈代码

02_listStack.py

"""栈：只允许在一端[栈顶]操作数据特点：Last In First Out  后进先出栈是顺序存储：1. 顺序存储实现栈模型 --> list栈顶：列表的尾部作为栈顶，负责 入栈[append()] 和 出栈[pop()] 操作栈底：列表的头部作为栈底，不负责任何操作2. 链表  ---> SingleLinkList
"""class ListStack:def __init__(self):# 初始化一个空栈self.elems = []def is_empty(self):"""判断栈是否为空【判断列表是否为空】，为空则返回True，非空返回False"""return self.elems == []def push(self, item):"""入栈操作：栈顶操作数据 ---> 列表的尾部增加数据"""self.elems.append(item)def destack(self):"""出栈操作：栈顶操作数据 ---> 列表的尾部弹出数据"""if self.is_empty():raise Exception('destack from an empty stack')return self.elems.pop()def peek(self):"""查看栈顶元素：相当于查看列表最后元素"""if self.is_empty():raise Exception('destack from an empty stack')return self.elems[-1]def size(self):"""栈大小：相当于查看列表中元素的个数"""return len(self.elems)if __name__ == '__main__':s = ListStack()# 判断栈是否为空print(s.is_empty())# 入栈操作：300 200 100s.push(300)s.push(200)s.push(100)print(s.is_empty())# 出栈操作：100print(s.destack())# 查看栈顶元素 200print(s.peek())# 查看栈中元素数量 2print(s.size())

03_singleLinkListStack.py

"""栈：只允许在一端[栈顶]操作数据特点：Last In First Out  后进先出栈是顺序存储：1. 顺序存储实现栈模型 --> list栈顶：列表的尾部作为栈顶，负责 入栈[append()] 和 出栈[pop()] 操作栈底：列表的头部作为栈底，不负责任何操作2. 链表  ---> SingleLinkList栈顶：链表的头部作为栈顶, 进行 入栈[相当于在链表的头部添加节点] 和 出栈[删除链表的头节点] 操作栈底：链表的尾部作为栈底，不进行任何操作
"""class Node:def __init__(self, value):self.value = valueself.next = Noneclass SingleLinkListStack:def __init__(self):self.head = Nonedef is_empty(self):"""判断栈是否为空：相当于判断链表是否为空"""return self.head == Nonedef push(self, item):"""入栈：相当于在链表的头部添加一个节点"""node = Node(item)node.next = self.headself.head = nodedef pop(self):"""出栈：相当于删除链表的头节点"""if self.is_empty():raise Exception('pop from an empty stack')item = self.head.valueself.head = self.head.nextreturn itemdef peek(self):"""查看栈顶元素：相当于查看头节点元素"""if self.is_empty():raise Exception('from an empty stack')return self.head.valuedef size(self):"""栈大小:相当于查看链表的元素数量"""count = 0cur = self.headwhile cur:count += 1cur = cur.nextreturn countif __name__ == '__main__':s = SingleLinkListStack()# 入栈： 300 200 100s.push(300)s.push(200)s.push(100)# 判断是否为空print(s.is_empty())print(s.pop())  # 100print(s.peek())  # 200print(s.size())  # 2

Day02_3图解

Day03

01_ListQueue.py

"""队列：允许在两端进行插入操作和删除操作特点：先进先出 First In First Out队尾：入队队头：出队实现：1、使用 顺序存储方式实现 队列列表：队头： 列表头部作为对头，出队操作 (pop(0))队尾： 列表尾部作为队尾，入队操作 (append())2、使用 链式存储方式实现 队列单链表：队头：链表的头部作为队头，相当于在链表的头部删除一个节点队尾：链表的尾部作为队尾，相当于在链表尾部添加一个节点
"""class ListQueue:def __init__(self):"""初始化一个空队列"""self.elems = []def is_empty(self):"""判断队列是否为空：判断列表是否为空"""return self.elems == []def enqueue(self, item):"""入队：相当于在列表的尾部添加一个节点"""self.elems.append(item)def dequeue(self):"""出队：相当于在列表的头部删除一个节点"""if self.is_empty():return "删除失败"return self.elems.pop(0)def size(self):"""返回队列大小：相当于获取列表的长度"""return len(self.elems)if __name__ == '__main__':q = ListQueue()# 入队操作：100 200 300q.enqueue(100)q.enqueue(200)q.enqueue(300)# 终端一： Falseprint(q.is_empty())# 出队操作 100print(q.dequeue())# 队列大小 2print(q.size())

02_LinkListQueue.py

"""链式存储实现 队列
"""class Node:def __init__(self, value):self.value = valueself.next = Noneclass LinkListQueue:def __init__(self):"""初始化一个空队列"""self.head = Nonedef is_empty(self):"""判断是否为空"""return self.head == Nonedef enqueue(self, item):"""入队：相当于在链表的尾部添加一个节点"""node = Node(item)if self.is_empty():self.head = nodereturncur = self.headwhile cur.next:cur = cur.nextcur.next = nodedef dequeue(self):"""出队：相当于删除链表头节点"""if self.is_empty():return "为空"item = self.head.valueself.head = self.head.nextreturn itemdef size(self):"""队列大小"""count = 0cur = self.headwhile cur:count += 1cur = cur.nextreturn countif __name__ == '__main__':s = LinkListQueue()# 入队 100 200 300s.enqueue(100)s.enqueue(200)s.enqueue(300)print(s.is_empty())print(s.dequeue())print(s.size())

---

Day04

01_recure.py

"""递归：1. 递归算法必须要有基本结束条件；2. 递归算法必须改变自己的状态并向基本结束条件演进3. 递归算法必须递归的调用自身
"""def f(n):if n == 0:return print(n)f(n-1)f(3) # 输出结果： 3   2   1def f(n):if n == 0:return f(n-1)print(n)f(3) # 输出结果： 1   2   3 # 当我们在调用递归的时候， 一定是先从外到里的递推；然后再从里到外的回归
# 三大定律：
# 结论：
#   1. 调用递归之前的语句，从外到里执行(递推过程中执行)
#   2. 调用递归之后的语句，从内到外执行(回归过程中执行)# 练习：使用递归 计算出 1 + 2 + 3 + ... + n 的和
def sumn(n):if n == 1:return 1return n + sumn(n-1)print(sumn(4))

归并排序图解

归并排序代码

02_mergesort.py

"""Python 实现 归并排序：思想：分而治之思路：1. 先分：2. 再和：
"""
def merge_sort(li):# 1. 分if len(li) == 1:print(li)return li mid = len(li) // 2left = li[:mid]right = li[mid:]left_li = merge_sort(left)right_li = merge_sort(right)# 2. 合return merge(left_li, right_li)def merge(left_li, right_li):"""合并"""result = [] # 存储有序元素while len(left_li) > 0 and len(right_li) > 0:if left_li[0] >= right_li[0]:# left_li = [6]   right_li = [5]result.append(right_li.pop(0))else:# left_li = [3]  right_li = [8]result.append(left_li.pop(0))if left_li: # 说明 左侧列表中 存在元素 应该追加到另一个容器末尾result.extend(left_li)if right_li:result.extend(right_li)return resultli = [6,5,3,8,0, -2]
print(merge_sort(li))

快速排序代码

03_quickSort.py

"""快速排序思路：1. 找到基准值 一般情况为第一个元素2. 左游标右移，遇到比基准值大的停！3. 右游标左移，遇到比基准值小的停！情况1：左游标<右游标：左右游标交换位置情况2：左游标>右游标：右游标和基准值交换位置
"""
from typing_extensions import Literaldef qucik_sort(li, first, last):"""快速排序"""if first > last:return split_pos = part(li, first, last)qucik_sort(li, first, split_pos-1)qucik_sort(li, split_pos+1, last)def part(li, first, last):"""给一个基准值找到正确位置"""mid = li[first] # first = 0  基准值left_cursor = first + 1 # 0 + 1  左游标right_cursor = last  # 右游标sign = True while sign:# 移动游标# 左游标右移，遇到比基准值大的停！while left_cursor <= right_cursor and li[left_cursor] <= mid:left_cursor += 1# 右游标左移，遇到比基准值小的停！while left_cursor <= right_cursor and li[right_cursor] >= mid:right_cursor -= 1# 两个游标停止了# 情况1：左游标<右游标：左右游标交换位置if left_cursor < right_cursor:li[left_cursor], li[right_cursor] = li[right_cursor], li[left_cursor]# 情况2：左游标>右游标：右游标和基准值交换位置else:li[first], li[right_cursor] = li[right_cursor], li[first]# 基准值找到了合适的位置sign = Falsereturn right_cursor # 返回右游标li = [6,5,999,888,7,2,1,4]
qucik_sort(li, 0, len(li)-1)
print(li)

---

Day05 树

01_twoTree.py

"""Python 实现二叉树经过分析：二叉树中每一个节点为一个节点对象，每个节点对象应该有三个属性：分别为：数据区左孩子（左子树）右孩子 （右子树）
"""
class Node:"""二叉树的节点类"""def __init__(self, value):self.value = value self.left = None  # 左孩子self.right = None  # 右孩子class BinaryTree:def __init__(self):"""初始化一颗空树（树根为None的树为空树）"""self.root = None def add(self, item):"""在二叉树添加一个节点"""node = Node(item) # 情况1： 空树if not self.root:self.root = node return # 情况2：非空树# 队列思想：从树根开始判断node_list = [self.root]while True:cur = node_list.pop(0)# 判断左孩子是否存在if cur.left:node_list.append(cur.left)else:cur.left = node return # 判断右孩子是否存在if cur.right:node_list.append(cur.right)else:cur.right = nodereturn def breadth_travel(self):"""二叉树广度遍历：从上到下，从左到右"""# 树根开始node_list = [self.root]while node_list:cur = node_list.pop(0)print(cur.value, end=" ")if cur.left:node_list.append(cur.left)if cur.right:node_list.append(cur.right)print()def pre_travel(self, root):"""前序遍历：根左右"""if not root:return print(root.value, end=" ")self.pre_travel(root.left)self.pre_travel(root.right)def mid_travel(self, root):"""中序遍历：左根右"""if not root:returnself.mid_travel(root.left)print(root.value, end=" ")self.mid_travel(root.right)def rear_travel(self, root):"""后序遍历：左右根"""if not root:return self.rear_travel(root.left)self.rear_travel(root.right)print(root.value, end=" ")if __name__ == "__main__":bt = BinaryTree()bt.add(1)bt.add(2)bt.add(3)bt.add(4)bt.add(5)bt.add(6)bt.add(7)bt.add(8)bt.add(9)bt.add(10)# 广度遍历bt.breadth_travel()# 前序bt.pre_travel(bt.root)print()# 中序bt.mid_travel(bt.root)print()# 后序bt.rear_travel(bt.root)

02_getKNode.py

"""给定一棵二叉搜索树，请找出其中的第 K 小的结点例如：5,3,7,2,4,6,8 中,按结点数值大小顺序第三小结点的值是4思路：1. 先对于二叉搜索树进行中序遍历，得到是一个递增的序列2. 利用列表的索引值取出对应的值
"""
class Node:def __init__(self, value):self.value = value self.left = None self.right = None class Solution:def __init__(self):self.result = []def get_k_node(self, root, k):"""root: 二叉树的根节点; k：第K小的节点"""li = self.mid_travel(root)# 索引if k < 0 or k >len(li):raise Exception("Index out of range")return li[k-1]def mid_travel(self, root):"""中序遍历-->序列"""if not root:return self.mid_travel(root.left)self.result.append(root.value)self.mid_travel(root.right)return self.resultif __name__ == "__main__":s = Solution()n12 = Node(12)n5 = Node(5)n2 = Node(2)n9 = Node(9)n18 = Node(18)n15 = Node(15)n17 = Node(17)n16 = Node(16)n19 = Node(19)# 创建二叉树n12.left = n5 n12.right = n18 n5.left = n2 n5.right = n9 n18.left = n15 n18.right = n19 n15.right = n17 n17.left = n16# 查找print(s.get_k_node(n12,100))

03_treeToLinList.py

"""输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中节点指针的指向思路：1. 中序遍历 得到序列2. 调整节点的left和right的属性值情况1：头节点的left ---> None 情况2：中间节点操作情况3：尾节点的right ---> None
"""
class Node:def __init__(self, value):self.value = value self.left = None self.right = None class Solution:def __init__(self):self.result = []def tree_to_link_list(self, root):li = self.mid_travel(root)if len(li) == 0:return None if len(li) == 1:return root# 处理头尾节点li[0].left = None li[0].right = li[1]li[-1].left = li[-2]li[-1].right = None # 中间节点for i  in range(1, len(li)-1):li[i].left = li[i-1]1li[i].right = li[i+1]return li[0]def mid_travel(self, root):"""中序遍历"""if not root:return self.mid_travel(root.left)self.result.append(root)self.mid_travel(root.right)return self.result if __name__ == "__main__":s = Solution()n12 = Node(12)n5 = Node(5)n2 = Node(2)n9 = Node(9)n18 = Node(18)n15 = Node(15)n17 = Node(17)n16 = Node(16)n19 = Node(19)# 创建二叉树n12.left = n5 n12.right = n18 n5.left = n2 n5.right = n9 n18.left = n15 n18.right = n19 n15.right = n17 n17.left = n16head = s.tree_to_link_list(n12)# 遍历双向链表cur = head while cur:print(cur.value, end=" ")cur = cur.right

04_printtree.py

"""从上到下按层打印二叉树，同一层结点从左至右输出，每一层输出一行。cur_queue = []next_queue = []思想：1. 队列思想 先进先出2. 两个对应用来操作当前层数据 和 下一层数据3. 当前层数据操作完成后，和下一层变量交换
"""
"""输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中节点指针的指向思路：1. 中序遍历 得到序列2. 调整节点的left和right的属性值情况1：头节点的left ---> None 情况2：中间节点操作情况3：尾节点的right ---> None
"""
class Node:def __init__(self, value):self.value = value self.left = None self.right = None class Solution:def print_tree(self, root):if not root:return # 非空cur_queue = [root]next_queue = []while cur_queue:cur = cur_queue.pop(0)print(cur.value, end=" ")if cur.left:next_queue.append(cur.left)if cur.right:next_queue.append(cur.right)# 交换变量（交换当前层 和 下一层的变量）if not cur_queue:cur_queue, next_queue = next_queue, cur_queueprint()if __name__ == "__main__":s = Solution()n12 = Node(12)n5 = Node(5)n2 = Node(2)n9 = Node(9)n18 = Node(18)n15 = Node(15)n17 = Node(17)n16 = Node(16)n19 = Node(19)# 创建二叉树n12.left = n5 n12.right = n18 n5.left = n2 n5.right = n9 n18.left = n15 n18.right = n19 n15.right = n17 n17.left = n16# 打印s.print_tree(n12)

05_printTree2.py

"""请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印， 第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推思想：1. 栈思想：LIFO append()  +   pop()2. 奇数层：先添加 right 再添加left3. 偶数层：先添加left  再添加right
"""class Node:def __init__(self, value):self.value = value self.left = None self.right = None class Solution:def print_tree(self, root):if not root:return # 非空cur_stack= [root]next_stack = []level = 1while cur_stack:cur = cur_stack.pop()print(cur.value, end=" ")# 区分奇数层 还是偶数层if level % 2 == 0: # 偶数层if cur.left:next_stack.append(cur.left)if cur.right:next_stack.append(cur.right)else:if cur.right:next_stack.append(cur.right)if cur.left:next_stack.append(cur.left)if not cur_stack:cur_stack, next_stack = next_stack, cur_stackprint()level += 1if __name__ == "__main__":s = Solution()n12 = Node(12)n5 = Node(5)n2 = Node(2)n9 = Node(9)n18 = Node(18)n15 = Node(15)n17 = Node(17)n16 = Node(16)n19 = Node(19)# 创建二叉树n12.left = n5 n12.right = n18 n5.left = n2 n5.right = n9 n18.left = n15 n18.right = n19 n15.right = n17 n17.left = n16# 打印s.print_tree(n12)

06_二叉树图解

数据结构与算法之python相关推荐

1. python中栈的描述是_数据结构与算法：Python语言描述 栈和队列.ppt

   数据结构与算法:Python语言描述 栈和队列 迷宫问题 迷宫问题的特点: 存在一集可能位置,一些位置相互连通,一步可达 一个位置可能连通若干位置,出现向前探查的多种可能(有分支) 目标是找到一条路径 ...

2. 数据结构与算法（Python）– 回溯法（Backtracking algorithm）

   数据结构与算法(Python)– 回溯法(Backtracking algorithm) 1.回溯法 回溯算法实际上一个类似枚举的搜索尝试过程,主要是在搜索尝试过程中寻找问题的解,当发现已不满足求解条 ...

3. 数据结构与算法（Python）第四天

   数据结构与算法(Python)第四天 链表 双向链表 操作 实现 单向循环链表 操作 实现 栈 栈结构实现 操作 实现 队列 队列的实现 操作 实现 双端队列 操作 实现 链表 双向链表 一种更复杂的 ...

4. 数据结构与算法（Python）第三天

   数据结构与算法(Python)第三天 3:链表 为什么需要链表 链表的定义 3.1 单向链表 Python 中赋值的实际意义: 节点实现 单链表的操作 单链表的实现 测试 链表与顺序表的对比 3:链表 ...

5. 数据结构与算法（Python）第二天

   提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 数据结构与算法(Python)第二天 顺序表 顺序表的基本形式 顺序表的结构与实现 顺序表的结构 顺序表的两种基本实现方式 元素存储区 ...

6. 数据结构与算法（Python）第一天

   数据结构与算法(Python)第一天 数据结构与算法(Python)第一天 算法引入 第一次尝试 算法的提出 算法的概念 算法的五大特性 第二次尝试 算法效率衡量 执行时间反应算法效率 单靠时间值绝对 ...

7. 资料分享：送你一本《数据结构与算法：Python语言描述》电子书！

   下图为 TIOBE 3月编程语言排行榜. 从榜单来看,曾经铁打的 Java.C.C++ 局势,早已在数月前被 Python 的闯入而打破.究其根由,并非是 C++ 的应用领域正在逐渐缩减,而是随着人工 ...

8. 《数据结构与算法：Python语言描述》一1.3算法和算法分析

   本节书摘来自华章出版社<数据结构与算法:Python语言描述>一书中的第1章,第1.3节,作者 裘宗燕,更多章节内容可以访问云栖社区"华章计算机"公众号查看 1.3算法 ...

9. 数据结构与算法（Python）【PKU MOOC】

   数据结构与算法(Python) 一. Python数据类型的性能 1.list 列表 列表list所包含的方法 #1 添加: list.append(a_new_element) #在列表末尾添加新的 ...

10. python数据结构算法_数据结构与算法（Python）

    数据结构与算法(Python) Why? 我们举一个可能不太恰当的例子: 如果将最终写好运行的程序比作战场,我们码农便是指挥作战的将军,而我们所写的代码便是士兵和武器. 那么数据结构和算法是什么?答曰 ...

最新文章

1. ceph-osd无法获取osd map导致osd down掉的解决办法
2. ASCII，Unicode和UTF-8终于找到一个能完全搞清楚的文章了
3. 用GAN还原语义标注图！还能手动改细节（附论文、代码）
4. 最全pandas函数用法速查手册（高清版）
5. java文本输入输出小结
6. 各种ARM仿真器接口图
7. 【AT2434】JOI 公園 (JOI Park) 最短路+贪心
8. 线程间通信的三种方法 (转)
9. MFC 直线 虚线 折线 圆 椭圆 矩形 弧形
10. java将json转为hashmap_java – 将JSON字符串转换为HashMap
11. go按行读取数据的坑
12. 杜比专为旧版本Android,杜比音效app(dolby audio) v2.1.0 安卓版
13. 经典贪吃蛇大战逆向_游戏内购
14. android内存dump分析,闭眼能敲，Android内存分析command
15. 【python多版本共存】
16. git index.lock
17. [结构光三维重建] 2、基于结构光的三维重建系统工作原理总结
18. 唱歌如何更好听？ KTV调音师帮你忙
19. Qt基于QGraphicsView 实现四个教具之一直尺(一)
20. 3.4.10nbsp;孙正义

热门文章

1. c51为啥要宏定义时钟_C51 程序中 #define 宏定义语句末尾一定要使用分号才能正确编译通过。_学小易找答案...
2. layui图标显示不正常,显示成方块
3. 就业、养老、住房、出行等领域稳步前行 这一年，民生改善实实在在
4. 如何让app不走系统代理？
5. 【博客目录】成为一个优秀的数据工程师
6. ghost u盘 linux,用U盘启动G4L备份还原linux系统用Ghost备份Windows操作系统
7. SDUT 3337 计算长方体、四棱锥的表面积和体积
8. python单因素方差分析_Python数据科学：方差分析
9. Navicat Premium 历史版本地址
10. python绘制柱状图和折线图_python绘制散点图，柱状图和折线图