数据结构可视化

复制from collections import deque

# 二叉树层序遍历（BFS）
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def level_order(root):
    if not root:
        return []
    result = []
    q = deque([root])
    while q:
        level = []
        for _ in range(len(q)):
            node = q.popleft()
            level.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        result.append(level)
    return result

# 构建示例树:       1
#                  / \
#                 2   3
#                / \
#               4   5
root = TreeNode(1)
root.left = TreeNode(2, TreeNode(4), TreeNode(5))
root.right = TreeNode(3)

print(level_order(root))  # [[1], [2, 3], [4, 5]]

复制package main

import "fmt"

// 链表反转
func main() {
	type ListNode struct {
		Val  int
		Next *ListNode
	}

	// 构建链表: 1 -> 2 -> 3 -> 4 -> 5
	head := &ListNode{1, &ListNode{2, &ListNode{3, &ListNode{4, &ListNode{5, nil}}}}}

	// 反转
	var prev *ListNode
	curr := head
	for curr != nil {
		next := curr.Next
		curr.Next = prev
		prev = curr
		curr = next
	}

	// 打印结果: 5 -> 4 -> 3 -> 2 -> 1
	for p := prev; p != nil; p = p.Next {
		fmt.Print(p.Val)
		if p.Next != nil {
			fmt.Print(" -> ")
		}
	}
	fmt.Println()
}

复制// 图：邻接表 + DFS 遍历
const graph = {
  'A': ['B', 'C'],
  'B': ['A', 'D', 'E'],
  'C': ['A', 'F'],
  'D': ['B'],
  'E': ['B', 'F'],
  'F': ['C', 'E']
};

function dfs(start, visited = new Set()) {
  visited.add(start);
  console.log(start);  // 访问节点
  for (const neighbor of graph[start]) {
    if (!visited.has(neighbor)) {
      dfs(neighbor, visited);
    }
  }
}

dfs('A');  // 输出: A B D E F C