在编程的世界里，集合框架是处理数据的基础工具之一。它提供了丰富的数据结构和算法，使得我们能够高效地管理数据。本文将带您走进集合框架的奥秘，通过50个实用代码实例，让您轻松掌握集合的使用方法。
实例1：数组与列表的区别
# 数组
array = [1, 2, 3, 4, 5]
print("数组索引:", array[0])
# 列表
list = [1, 2, 3, 4, 5]
print("列表索引:", list[0])
在这个例子中，我们展示了数组和列表的基本用法。数组是一种固定长度的数据结构，而列表则是一种动态长度的数据结构。
实例2：集合的创建与操作
# 创建集合
set = {1, 2, 3, 4, 5}
# 添加元素
set.add(6)
print("添加元素后:", set)
# 删除元素
set.remove(3)
print("删除元素后:", set)
# 检查元素是否存在
if 2 in set:
print("元素2存在")
在这个例子中，我们展示了如何创建集合、添加元素、删除元素以及检查元素是否存在。
实例3：字典的创建与操作
# 创建字典
dict = {"name": "张三", "age": 25}
# 获取字典中的值
print("姓名:", dict["name"])
# 添加键值对
dict["city"] = "北京"
print("添加键值对后:", dict)
# 删除键值对
del dict["age"]
print("删除键值对后:", dict)
在这个例子中，我们展示了如何创建字典、获取值、添加键值对以及删除键值对。
实例4：元组的创建与操作
# 创建元组
tuple = (1, 2, 3, 4, 5)
# 访问元组中的元素
print("元组索引:", tuple[0])
# 修改元组（元组是不可变的）
# tuple[0] = 10 # 这行代码会引发错误
在这个例子中，我们展示了如何创建元组、访问元素以及修改元组。
实例5：集合的交集、并集与差集
# 创建集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 交集
print("交集:", set1 & set2)
# 并集
print("并集:", set1 | set2)
# 差集
print("差集:", set1 - set2)
在这个例子中，我们展示了如何计算集合的交集、并集以及差集。
实例6：排序与逆序
# 创建列表
list = [5, 2, 9, 1, 5, 6]
# 排序
list.sort()
print("排序后:", list)
# 逆序
list.reverse()
print("逆序后:", list)
在这个例子中，我们展示了如何对列表进行排序和逆序。
实例7：链表的创建与操作
# 创建链表
class Node:
def __init__(self, data):
self.data = data
self.next = None
head = Node(1)
node2 = Node(2)
node3 = Node(3)
head.next = node2
node2.next = node3
# 遍历链表
current = head
while current:
print("链表元素:", current.data)
current = current.next
在这个例子中，我们展示了如何创建链表以及遍历链表。
实例8：栈的实现
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]
def is_empty(self):
return len(self.items) == 0
# 使用栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print("栈顶元素:", stack.peek())
print("栈元素:", stack.items)
在这个例子中，我们展示了如何实现栈的数据结构。
实例9：队列的实现
class Queue:
def __init__(self):
self.items = []
def enqueue(self, item):
self.items.append(item)
def dequeue(self):
return self.items.pop(0)
def is_empty(self):
return len(self.items) == 0
# 使用队列
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print("队列元素:", queue.items)
在这个例子中，我们展示了如何实现队列的数据结构。
实例10：散列表的实现
class HashTable:
def __init__(self):
self.table = [None] * 10
def hash(self, key):
return key % 10
def insert(self, key, value):
index = self.hash(key)
if self.table[index] is None:
self.table[index] = [(key, value)]
else:
self.table[index].append((key, value))
def search(self, key):
index = self.hash(key)
if self.table[index] is not None:
for k, v in self.table[index]:
if k == key:
return v
return None
# 使用散列表
hash_table = HashTable()
hash_table.insert(1, "张三")
hash_table.insert(2, "李四")
print("散列表元素:", hash_table.table)
print("查找元素2:", hash_table.search(2))
在这个例子中，我们展示了如何实现散列表的数据结构。
实例11：排序算法
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
# 使用冒泡排序
arr = [5, 2, 9, 1, 5, 6]
bubble_sort(arr)
print("冒泡排序后:", arr)
在这个例子中，我们展示了冒泡排序算法的实现。
实例12：查找算法
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
# 使用二分查找
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
target = 5
print("二分查找结果:", binary_search(arr, target))
在这个例子中，我们展示了二分查找算法的实现。
实例13：快速排序
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
# 使用快速排序
arr = [5, 2, 9, 1, 5, 6]
print("快速排序后:", quick_sort(arr))
在这个例子中，我们展示了快速排序算法的实现。
实例14：归并排序
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
# 使用归并排序
arr = [5, 2, 9, 1, 5, 6]
print("归并排序后:", merge_sort(arr))
在这个例子中，我们展示了归并排序算法的实现。
实例15：堆排序
def heapify(arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
def heap_sort(arr):
n = len(arr)
for i in range(n, -1, -1):
heapify(arr, n, i)
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i]
heapify(arr, i, 0)
# 使用堆排序
arr = [5, 2, 9, 1, 5, 6]
heap_sort(arr)
print("堆排序后:", arr)
在这个例子中，我们展示了堆排序算法的实现。
实例16：选择排序
def selection_sort(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i+1, len(arr)):
if arr[min_idx] > arr[j]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
# 使用选择排序
arr = [5, 2, 9, 1, 5, 6]
selection_sort(arr)
print("选择排序后:", arr)
在这个例子中，我们展示了选择排序算法的实现。
实例17：插入排序
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i-1
while j >= 0 and key < arr[j]:
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
# 使用插入排序
arr = [5, 2, 9, 1, 5, 6]
insertion_sort(arr)
print("插入排序后:", arr)
在这个例子中，我们展示了插入排序算法的实现。
实例18：冒泡排序（优化版）
def bubble_sort_optimized(arr):
n = len(arr)
for i in range(n):
swapped = False
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
swapped = True
if not swapped:
break
# 使用冒泡排序（优化版）
arr = [5, 2, 9, 1, 5, 6]
bubble_sort_optimized(arr)
print("冒泡排序（优化版）后:", arr)
在这个例子中，我们展示了冒泡排序算法的优化版。
实例19：二分查找（优化版）
def binary_search_optimized(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
# 使用二分查找（优化版）
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
target = 5
print("二分查找（优化版）结果:", binary_search_optimized(arr, target))
在这个例子中，我们展示了二分查找算法的优化版。
实例20：快速排序（优化版）
def quick_sort_optimized(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort_optimized(left) + middle + quick_sort_optimized(right)
# 使用快速排序（优化版）
arr = [5, 2, 9, 1, 5, 6]
print("快速排序（优化版）后:", quick_sort_optimized(arr))
在这个例子中，我们展示了快速排序算法的优化版。
实例21：归并排序（优化版）
def merge_sort_optimized(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort_optimized(arr[:mid])
right = merge_sort_optimized(arr[mid:])
return merge_optimized(left, right)
def merge_optimized(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
# 使用归并排序（优化版）
arr = [5, 2, 9, 1, 5, 6]
print("归并排序（优化版）后:", merge_sort_optimized(arr))
在这个例子中，我们展示了归并排序算法的优化版。
实例22：堆排序（优化版）
def heapify_optimized(arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify_optimized(arr, n, largest)
def heap_sort_optimized(arr):
n = len(arr)
for i in range(n, -1, -1):
heapify_optimized(arr, n, i)
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i]
heapify_optimized(arr, i, 0)
# 使用堆排序（优化版）
arr = [5, 2, 9, 1, 5, 6]
heap_sort_optimized(arr)
print("堆排序（优化版）后:", arr)
在这个例子中，我们展示了堆排序算法的优化版。
实例23：选择排序（优化版）
def selection_sort_optimized(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i+1, len(arr)):
if arr[min_idx] > arr[j]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
# 使用选择排序（优化版）
arr = [5, 2, 9, 1, 5, 6]
selection_sort_optimized(arr)
print("选择排序（优化版）后:", arr)
在这个例子中，我们展示了选择排序算法的优化版。
实例24：插入排序（优化版）
def insertion_sort_optimized(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i-1
while j >= 0 and key < arr[j]:
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
# 使用插入排序（优化版）
arr = [5, 2, 9, 1, 5, 6]
insertion_sort_optimized(arr)
print("插入排序（优化版）后:", arr)
在这个例子中，我们展示了插入排序算法的优化版。
实例25：冒泡排序（优化版2）
def bubble_sort_optimized2(arr):
n = len(arr)
for i in range(n):
swapped = False
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
swapped = True
if not swapped:
break
# 使用冒泡排序（优化版2）
arr = [5, 2, 9, 1, 5, 6]
bubble_sort_optimized2(arr)
print("冒泡排序（优化版2）后:", arr)
在这个例子中，我们展示了冒泡排序算法的另一个优化版。
实例26：二分查找（优化版2）
def binary_search_optimized2(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
# 使用二分查找（优化版2）
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
target = 5
print("二分查找（优化版2）结果:", binary_search_optimized2(arr, target))
在这个例子中，我们展示了二分查找算法的另一个优化版。
实例27：快速排序（优化版2）
”`python def quick_sort_optimized2(arr