数据结构的基本操作
数据结构的基本操作
数据结构的基本操作
对于任何数据结构，其基本操作⽆⾮遍历 + 访问，再具体⼀点就是：增删查改。
数据结构种类很多，但它们存在的⽬的都是在不同的应⽤场景，尽可能⾼效地增删查改。话说这不就是数据结构的使命么？
如何遍历 + 访问？我们仍然从最⾼层来看，各种数据结构的遍历 + 访问⽆⾮两种形式：线性的和⾮线性的。
线性就是 for/while 迭代为代表，⾮线性就是递归为代表。再具体⼀步，⽆⾮以下⼏种框架：
数组遍历框架，典型的线性迭代结构：
void traverse(int[] arr) {
for (int i = 0; i < arr.length; i++) {
// 迭代访问 arr[i]大学生党员转正申请书范文
}
}
链表遍历框架，兼具迭代和递归结构：
/* 基本的单链表节点 */
class ListNode {
教师节作文500字int val;
ListNode next;
}
void traverse(ListNode head) {
for (ListNode p = head; p != null; p = p.next) {
// 迭代访问 p.val
}
}
void traverse(ListNode head) {
// 递归访问 head.val
);
}
⼆叉树遍历框架，典型的⾮线性递归遍历结构：
/* 基本的⼆叉树节点 */
class TreeNode {
int val;
TreeNode left, right;
}
void traverse(TreeNode root) {
traverse(root.left);
traverse(root.right);
}
你看⼆叉树的递归遍历⽅式和链表的递归遍历⽅式，相似不？再看看⼆叉树结构和单链表结构，相似不？如果再多⼏条叉，N 叉树你会不会遍历？
⼆叉树框架可以扩展为 N 叉树的遍历框架：
/* 基本的 N 叉树节点 */
class TreeNode {
int val;
TreeNode[] children;
}
void traverse(TreeNode root) {
for (TreeNode child : root.children)
traverse(child);
}
N 叉树的遍历⼜可以扩展为图的遍历，因为图就是好⼏ N 叉棵树的结合体。你说图是可能出现环的？这个很好办，⽤个布尔数组 visited 做标记就⾏了，这⾥就不写代码了。
所谓框架，就是套路。不管增删查改，这些代码都是永远⽆法脱离的结构，你可以把这个结构作为⼤纲，根据具体问题在框架上添加代码就⾏了。
例题
LeetCode 124 题，难度 Hard，让你求⼆叉树中最⼤路径和，主要代码如下：
int ans = INT_MIN;
撤回
int oneSideMax(TreeNode* root) {天下有情人 原唱
if (root == nullptr) return 0;
int left = max(0, oneSideMax(root->left));
int right = max(0, oneSideMax(root->right));
ans = max(ans, left + right + root->val);
return max(left, right) + root->val;
}
这就是个后序遍历
LeetCode 105 题，难度 Medium，让你根据前序遍历和中序遍历的结果还原⼀棵⼆叉树，很经典的问题吧，主要代码如下：
TreeNode buildTree(int[] preorder, int preStart, int preEnd,
int[] inorder, int inStart, int inEnd, Map<Integer, Integer> inMap) {
if(preStart > preEnd || inStart > inEnd) return null;
TreeNode root = new TreeNode(preorder[preStart]);
int inRoot = (root.val);
int numsLeft = inRoot - inStart;
root.left = buildTree(preorder, preStart + 1, preStart + numsLeft,
inorder, inStart, inRoot - 1, inMap);
root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd,
inorder, inRoot + 1, inEnd, inMap);
return root;
}
不要看这个函数的参数很多，只是为了控制数组索引⽽已，本质上该算法也就是⼀个前序遍历
笔记本 投影仪
LeetCode 99 题，难度 Hard，恢复⼀棵 BST，主要代码如下：
void traverse(TreeNode* node) {
if (!node) return;
traverse(node->left);
if (node->val < prev->val) {
s = (s == NULL) ? prev : s;
t = node;
flash动画制作}
prev = node;
traverse(node->right);
}
这就是个中序遍历。
对于⼀个理解⼆叉树的⼈来说，刷⼀道⼆叉树的题⽬花不了多长时间。那么如果你对刷题⽆从下⼿或者有畏惧⼼理，不妨从⼆叉树下⼿，前10 道也许有点难受；结合框架再做 20 道，也许你就有点⾃⼰的理解了；刷完整个专题，再去做什么回溯动规分治专题，你就会发现只要涉及递归的问题，都是树的问题。
动态规划凑零钱问题，暴⼒解法就是遍历⼀棵 N 叉树：
def coinChange(coins: List[int], amount: int):
def dp(n):
if n == 0: return 0
if n < 0: return -1
res = float('INF')
for coin in coins:
subproblem = dp(n - coin)
# ⼦问题⽆解，跳过
if subproblem == -1: continue
res = min(res, 1 + subproblem)
return res if res != float('INF') else -1
return dp(amount)
这么多代码看不懂咋办？直接提取出框架，就能看出核⼼思路了：
# 不过是⼀个 N 叉树的遍历问题⽽已
def dp(n):
for coin in coins:
dp(n - coin)
其实很多动态规划问题就是在遍历⼀棵树，你如果对树的遍历操作烂熟于⼼，起码知道怎么把思路转化成代码，也知道如何提取别⼈解法的核⼼思路。
回溯算法就是个 N 叉树的前后序遍历问题，没有例外。
⽐如 N 皇后问题吧，主要代码如下：
void backtrack(int[] nums, LinkedList<Integer> track) {
if (track.size() == nums.length) {
res.add(new LinkedList(track));
return;
}
for (int i = 0; i < nums.length; i++) {
if (ains(nums[i]))
continue;
track.add(nums[i]);
// 进⼊下⼀层决策树
backtrack(nums, track);
}
/* 提取出 N 叉树遍历框架 */
void backtrack(int[] nums, LinkedList<Integer> track) {
for (int i = 0; i < nums.length; i++) {
backtrack(nums, track);
}
N 叉树的遍历框架，出来了。
数据结构的基本存储⽅式就是链式和顺序两种，基本操作就是增删查改，遍历⽅式⽆⾮迭代和递归。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。