算法竞赛备赛之经典数据结构训练提升，暑期集训营培训

**算法竞赛备赛之经典数据结构训练提升**

作为一名算法竞赛爱好者，你一定知道，数据结构是算法竞赛中的基础知识之一。掌握了各种数据结构的基本操作和应用技巧，可以帮助你更快地解决问题，提高算法设计能力。

在这篇文章中，我们将介绍一些经典的数据结构训练题目，包括链表、栈、队列、树、图等。这些题目不仅可以帮助你巩固基础知识，还可以让你掌握一些高级技巧和思维模式。

**一、链表**

链表是一种线性数据结构，每个元素称为结点，结点之间通过指针连接。链表的基本操作包括插入、删除、查找等。

###1.1 链表的基本操作

class Node:
 def __init__(self, data=None):
 self.data = data self.next = Noneclass LinkedList:
 def __init__(self):
 self.head = None def append(self, data):
 if not self.head:
 self.head = Node(data)
 else:
 current = self.head while current.next:
 current = current.next current.next = Node(data)

 def print_list(self):
 elements = []
 current_node = self.head while current_node:
 elements.append(current_node.data)
 current_node = current_node.next return elements# 创建一个链表并添加元素linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)

# 打印链表中的元素print(linked_list.print_list()) # [1,2,3]

def has_cycle(head):
 slow = head fast = head while fast and fast.next:
 slow = slow.next fast = fast.next.next if slow == fast:
 return True return False# 创建一个带环链表ring_list = LinkedList()
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)

node1.next = node2node2.next = node3node3.next = node1 # 创建环print(has_cycle(ring_list.head)) # True

class Stack:
 def __init__(self):
 self.items = []

 def push(self, item):
 self.items.append(item)

 def pop(self):
 return self.items.pop()

 def peek(self):
 return self.items[-1]

# 创建一个栈并添加元素stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

# 弹出栈顶元素print(stack.pop()) #3

def is_valid_expression(expression):
 stack = []
 for char in expression:
 if char == '(' or char == '{' or char == '[':
 stack.append(char)
 elif char == ')' or char == '}' or char == ']':
 if not stack:
 return False top_char = stack.pop()
 if (char == ')' and top_char != '(') or 
 (char == '}' and top_char != '{') or 
 (char == ']' and top_char != '['):
 return False return not stack# 测试栈的应用print(is_valid_expression("((()))")) # Trueprint(is_valid_expression("(()")) # False

class Queue:
 def __init__(self):
 self.items = []

 def enqueue(self, item):
 self.items.append(item)

 def dequeue(self):
 return self.items.pop(0)

# 创建一个队列并添加元素queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)

# 弹出队首元素print(queue.dequeue()) #1

def is_valid_queue(expression):
 stack = []
 for char in expression:
 if char == '(' or char == '{' or char == '[':
 stack.append(char)
 elif char == ')' or char == '}' or char == ']':
 if not stack:
 return False top_char = stack.pop()
 if (char == ')' and top_char != '(') or 
 (char == '}' and top_char != '{') or 
 (char == ']' and top_char != '['):
 return False return not stack# 测试队列的应用print(is_valid_queue("((()))")) # Trueprint(is_valid_queue("(()")) # False

class Node:
 def __init__(self, data=None):
 self.data = data self.children = []

class Tree:
 def __init__(self):
 self.root = None def add(self, parent_data, child_data):
 if not self.root:
 self.root = Node(parent_data)
 else:
 current_node = self.root while current_node:
 if current_node.data == parent_data:
 current_node.children.append(Node(child_data))
 break elif current_node.children and any(node.data == parent_data for node in current_node.children):
 current_node = current_node.children[0]
 while current_node:
 if current_node.data == parent_data:
 current_node.children.append(Node(child_data))
 break elif current_node.children and any(node.data == parent_data for node in current_node.children):
 current_node = current_node.children[0]
 else:
 current_node = None# 创建一个树并添加元素tree = Tree()
tree.add("A", "B")
tree.add("A", "C")
tree.add("B", "D")

# 打印树中的元素def print_tree(node, level=0):
 if node:
 print(' ' * level + str(node.data))
 for child in node.children:
 print_tree(child, level +1)

print_tree(tree.root)

def is_valid_expression(expression):
 stack = []
 for char in expression:
 if char == '(' or char == '{' or char == '[':
 stack.append(char)
 elif char == ')' or char == '}' or char == ']':
 if not stack:
 return False top_char = stack.pop()
 if (char == ')' and top_char != '(') or 
 (char == '}' and top_char != '{') or 
 (char == ']' and top_char != '['):
 return False return not stack# 测试树的应用print(is_valid_expression("((()))")) # Trueprint(is_valid_expression("(()")) # False

class Node:
 def __init__(self, data=None):
 self.data = data self.edges = []

class Graph:
 def __init__(self):
 self.nodes = {}

 def add_node(self, node_data):
 if not node_data in self.nodes:
 self.nodes[node_data] = Node(node_data)

 def add_edge(self, from_node, to_node):
 if from_node in self.nodes and to_node in self.nodes:
 self.nodes[from_node].edges.append(to_node)
 self.nodes[to_node].edges.append(from_node)

# 创建一个图并添加元素graph = Graph()
graph.add_node("A")
graph.add_node("B")
graph.add_node("C")

graph.add_edge("A", "B")
graph.add_edge("B", "C")
graph.add_edge("C", "A")

# 打印图中的元素def print_graph(graph):
 for node in graph.nodes.values():
 print(node.data, end=" ")
 for edge in node.edges:
 print(edge, end=" ")
 print()

print_graph(graph)

def is_valid_expression(expression):
 stack = []
 for char in expression:
 if char == '(' or char == '{' or char == '[':
 stack.append(char)
 elif char == ')' or char == '}' or char == ']':
 if not stack:
 return False top_char = stack.pop()
 if (char == ')' and top_char != '(') or 
 (char == '}' and top_char != '{') or 
 (char == ']' and top_char != '['):
 return False return not stack# 测试图的应用print(is_valid_expression("((()))"))