先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注Python）
正文
2 3
/ \ /
4 5 _6 7
/ / / \
8 10 12 13 15
空结点一般用null描述，如：{1,2,3,4,5,6,7,8,null,10,11,null,13,null,15}。
为了不改变数组的描述，用最小负整数来定义null： #define null INT_MIN
代码：
增加对空节点的判断 if(i < nums.size() && nums[i] != null)
#include
#include
#include
#define null INT_MIN
using namespace std;
struct TreeNode
{
int val;
TreeNode *left, *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}
void levelOrder(TreeNode* root)
{
if(!root) return;
queue<TreeNode*> q;
q.push(root);
while(!q.empty())
{
int size = q.size();
for(int i = 0; i < size; i++)
{
TreeNode *cur = q.front();
q.pop();
cout << cur->val << " ";
if(cur->left)
q.push(cur->left);
if(cur->right)
q.push(cur->right);
}
cout << endl;
}
}
int main()
{
vector nums = {1,2,3,4,5,6,7,8,null,10,11,null,13,null,15};
TreeNode *root = buildTree(nums);
levelOrder(root);
return 0;
}
输出：
1
2 3
4 5 6 7
8 10 11 13 15
以上代码，直接用队列 queue来存放二叉树各节点的指针，queue有队列操作的专用内置方法pop和push，所以要比在前一例中用vector模拟的队列操作要稍微方便一点。
注：二叉树的遍历，如
用队列操作的一般是广度优先遍历 （BFS，Breath First Search）
而用栈操作的一般是深度优先遍历 （DFS，Depth First Search）
二叉树的遍历
指如何按某种搜索路径巡防树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次。
常见的遍历方法有：层序遍历，先序遍历，中序遍历，后序遍历。
层序遍历
若二叉树为空，为空操作；否则从上到下、从左到右按层次进行访问。
遍历结果： 1 [2 3] [4 5 6 7] [8 9 10 11 12 13 14 15]
层序遍历的BFS代码在上面的打印二叉树章节已放出，这里放上我见过的一种用递归法写的二叉树层序遍历：
#include
#include
#include
#define null INT_MIN
using namespace std;
struct TreeNode
{
int val;
TreeNode *left, *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}
int countNodesAtLevel(TreeNode* root, int level)
{
if(root == nullptr) return 0;
if(level == 0) return 1;
return countNodesAtLevel(root->left, level - 1) + countNodesAtLevel(root->right, level - 1);
}
TreeNode* getNodeAtLevel(TreeNode* root, int level, int index)
{
if(root == nullptr) return nullptr;
if(level == 0)
{
if(index == 0) return root;
else return nullptr;
}
TreeNode *left = getNodeAtLevel(root->left, level - 1, index);
if(left != nullptr) return left;
return getNodeAtLevel(root->right, level - 1, index - countNodesAtLevel(root->left, level - 1));
}
void levelOrder(TreeNode* root)
{
int level = 0;
while(true)
{
int cnt = countNodesAtLevel(root, level);
if(cnt == 0) break;
for(int i = 0; i < cnt; i++)
{
TreeNode *node = getNodeAtLevel(root, level, i);
cout << node->val << " ";
}
cout << endl;
level++;
}
}
int main()
{
vector nums = {1,2,3,4,5,6,7,8,null,10,11,null,13,null,15};
TreeNode *root = buildTree(nums);
levelOrder(root);
return 0;
}
先序遍历
若二叉树为空，为空操作；
否则（1）访问根节点；（2）先序遍历左子树；（3）先序遍历右子树。
遍历结果： 1 [2 [4 8 9] [5 10 11]] [3 [6 12 13] [7 14 15] “根左右”
中序遍历
若二叉树为空，为空操作；
否则（1）中序遍历左子树；（2）访问根结点；（3）中序遍历右子树。
遍历结果： [[8 4 9] 2 [10 5 11]] 1 [[12 6 13] 3 [14 7 15]] “左根右”
后序遍历
若二叉树为空，为空操作；
否则（1）后序遍历左子树；（2）后序遍历右子树；（3）访问根结点。
遍历结果： [[8 9 4] [10 11 5] 2] [[12 13 6] [14 15 7] 3] 1 “左右根”
递归法
#include
#include
#include
#define null INT_MIN
using namespace std;
struct TreeNode
{
int val;
TreeNode *left, *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}
void preOrderTraversal(TreeNode* root) {
if (root == nullptr) {
return;
}
cout << root->val << " ";
preOrderTraversal(root->left);
preOrderTraversal(root->right);
}
void inOrderTraversal(TreeNode* root) {
if (root == nullptr) {
return;
}
inOrderTraversal(root->left);
cout << root->val << " ";
inOrderTraversal(root->right);
}
void postOrderTraversal(TreeNode* root) {
if (root == nullptr) {
return;
}
postOrderTraversal(root->left);
postOrderTraversal(root->right);
cout << root->val << " ";
}
int main()
{
vector nums;
for (int i = 0; i < 15; i++)
nums.push_back(i+1);
TreeNode *root = buildTree(nums);
preOrderTraversal(root);
cout << endl;
inOrderTraversal(root);
cout << endl;
postOrderTraversal(root);
cout << endl;
return 0;
}
输出：
1 2 4 8 9 5 10 11 3 6 12 13 7 14 15
8 4 9 2 10 5 11 1 12 6 13 3 14 7 15
8 9 4 10 11 5 2 12 13 6 14 15 7 3 1
前中后序对比
遍历时核心代码的顺序是关键，就是上面讲过的用“根左右”“左根右”“左右根”记忆，看根节点的左右子树节点的位置比较：
根左右——前序
cout << root->val << " ";
preOrderTraversal(root->left);
preOrderTraversal(root->right);左根右——中序
inOrderTraversal(root->left);
cout << root->val << " ";
inOrderTraversal(root->right);左右根——后序
postOrderTraversal(root->left);
postOrderTraversal(root->right);
cout << root->val << " ";
遍历除了直接打印节点外，还可以把各节点值域存入数组，以中序为例：
vector inorderTraversal(TreeNode* root) {
vector res;
inorderTraversal(root, res);
return res;
}
void inorderTraversal(TreeNode* root, vector& res) {
if (root == nullptr) {
return;
}
inorderTraversal(root->left, res);
res.push_back(root->val);
inorderTraversal(root->right, res);
}
DFS遍历
DFS会用到，直接打印版：
#include
#include
#include
#include
#define null INT_MIN
using namespace std;
struct TreeNode
{
int val;
TreeNode *left, *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}
void preOrderTraversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* node = root;
while (node != nullptr || !st.empty()) {
while (node != nullptr) {
cout << node->val << " ";
st.push(node);
node = node->left;
}
node = st.top();
st.pop();
node = node->right;
}
}
void inOrderTraversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* node = root;
while (node != nullptr || !st.empty()) {
while (node != nullptr) {
st.push(node);
node = node->left;
}
node = st.top();
st.pop();
cout << node->val << " ";
node = node->right;
}
}
void postOrderTraversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* node = root;
TreeNode* last = nullptr; // 上一次访问的节点
while (node != nullptr || !st.empty()) {
while (node != nullptr) {
st.push(node);
node = node->left;
}
node = st.top();
if (node->right == nullptr || node->right == last) {
// 右子树为空或已经访问过
cout << node->val << " ";
st.pop();
last = node; // 更新上一次访问的节点
node = nullptr; // 继续弹出栈顶元素
} else { // 右子树还未访问
node = node->right;
}
}
}
int main()
{
vector nums;
for (int i = 0; i < 15; i++)
nums.push_back(i+1);
TreeNode *root = buildTree(nums);
preOrderTraversal(root);
cout << endl;
inOrderTraversal(root);
cout << endl;
postOrderTraversal(root);
cout << endl;
return 0;
}
二叉树转数组，分别用DFS,BFS实现：
vector DFSinorderTraversal(TreeNode* root) {
vector res;
stack<TreeNode*> st;
while (root != nullptr || !st.empty()) {
while (root != nullptr) {
st.push(root);
root = root->left;
}
root = st.top();
st.pop();
res.push_back(root->val);
root = root->right;
}
return res;
}
vector BFSinorderTraversal(TreeNode* root) {
vector res;
queue<TreeNode*> q;
if (root != nullptr) {
q.push(root);
}
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
if (node->left != nullptr) {
q.push(node->left);
}
res.push_back(node->val);
if (node->right != nullptr) {
q.push(node->right);
}
}
return res;
}
树的相关术语
节点：包含一个数据元素及若干指向其子树的分支，又的译成“结点”（Node）
根：树和子树的“顶点”（Root）
度：节点拥有的子树数量称为节点的度（Degree）；树的度是指树内个结点的度的最大值
分支节点：度不为0的节点
叶子：没有子树的节点，即它的度为0 （Leaf）
子节点：结点的子树的根称为该节点的孩子（Child）
父节点：对应子节点上一层(level)节点称为该节点的双亲（Parent）
兄弟结点：同一父节点的子节点，互称兄弟（Sibling）
节点的祖先：是从根到该结点所经分支上的所有节点
节点的子孙：以某结点为根的子树中的所有节点
层：从根开始，根为第一层，根的孩子为第二层…（Level）
深度：树中结点的最大层次数，称为树的深度或高度 （Depth or Height）
森林：是很多互不相交的树的集合（Forest）
无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树
有序树：树中任意节点的子节点之间有顺序关系，这种树称为有序树
最大树（最小树）：每个结点的值都大于（小于）或等于其子结点（如果有的话）值的树
特殊二叉树
满二叉树
所有层的节点都达到最大数量，叶子除外的所有节点都有两个子节点，所有叶子都在最底一层(k)且数目为2^(k - 1)。即深度k且有2^k - 1个节点(叶子“长”满最后一层)，或称完美二叉树 （Perfect Binary Tree）
12_
/
3 5
/ \ /
_7 6 _9 11
/ \ / \ / \ /
13 8 1 4 10 2 0 14
完全二叉树
如果删除最底一层的所有叶子它就是满二叉树，即除了最后一层，每层节点都达到最大数量 ，即有深度k的个节点数在左闭右开【2(k-1)+1,2k-1】区间内。（Complete Binary Tree）
__3
/
11 4
/ \ /
14 7 9 13
/ \ / \ /
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
5
/ \ /
_7 6 _9 11
/ \ / \ / \ /
13 8 1 4 10 2 0 14
完全二叉树
如果删除最底一层的所有叶子它就是满二叉树，即除了最后一层，每层节点都达到最大数量 ，即有深度k的个节点数在左闭右开【2(k-1)+1,2k-1】区间内。（Complete Binary Tree）
__3
/
11 4
/ \ /
14 7 9 13
/ \ / \ /
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
[外链图片转存中…(img-xjdVq1UR-1713652333710)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
1564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
