# 实践和项目：解决实际问题时，选择合适的数据结构和算法

204 篇文章 95 订阅
83 篇文章 11 订阅
23 篇文章 16 订阅

#### 文章目录

🎉欢迎来到数据结构学习专栏~实践和项目：解决实际问题时，选择合适的数据结构和算法

### 选择合适的数据结构

#### 数组

# 创建一个包含10个整数的数组
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 访问数组中的元素
print(arr[0])  # 输出：1
print(arr[5])  # 输出：6


#### 链表

public class Node {
int value;
Node next;

public Node(int value) {
this.value = value;
this.next = null;
}
}

Node newNode = new Node(value);
} else {
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
}

public void remove(int value) {
return;
}
return;
}
while (current.next != null && current.next.value != value) {
current = current.next;
}
if (current.next != null) {
current.next = current.next.next;
}
}
}


#### 栈

stack = []
stack.append(1)  # 插入元素1
stack.append(2)  # 插入元素2
print(stack.pop())  # 删除并返回元素2，输出：2
print(stack.pop())  # 删除并返回元素1，输出：1


#### 队列

queue = []
queue.append(1)  # 插入元素1
queue.append(2)  # 插入元素2
print(queue.pop(0))  # 删除并返回元素1，输出：1
print(queue.pop(0))  # 删除并返回元素2，输出：2


#### 树

class TreeNode:
def __init__(self, value):
self.value = value
self.children = []
self.parent = None
self.is_root = False
self.is_leaf = False
self.level = None

child.parent = self
child.is_root = False
child.level = self.level
if not self.children:
self.is_root = True
child.parent = self
self.children.append(child)

def get_root(node):
if node.is_root:
return node
else:
return node.parent.get_root(node)


#### 图

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

self.edges[node] = []

if from_node not in self.nodes or to_node not in self.nodes:
raise ValueError("Both nodes need to be in graph")
self.edges[from_node].append((to_node, weight))
self.edges[to_node].append((from_node, weight))


#### 哈希表

class HashTable:
def __init__(self):
self.table = {}

def put(self, key, value):
hash_key = hash(key) % len(self.table)
bucket = self.table[hash_key]
for i, kv in enumerate(bucket):
if kv[0] == key:
bucket[i] = ((key, value))
return True
return False


### 选择合适的算法

1. 排序算法：适用于需要对大量数据进行有序处理的情况。例如，冒泡排序、快速排序、归并排序等。
• 冒泡排序：这是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
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]
return arr

• 快速排序：这是一种分治的排序算法。它将一个数组分成两个子数组，然后对子数组进行递归排序。

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)

1. 搜索算法：适用于需要在大量数据中查找特定元素的情况。例如，线性搜索、二分搜索等。
• 线性搜索：这是一种简单的搜索算法，它遍历整个数组，比较每个元素与目标元素，如果匹配则返回该元素。
def linear_search(arr, x):
for i in range(len(arr)):
if arr[i] == x:
return i
return -1

• 二分搜索：这是一种高效的搜索算法，它只在排序的数组中搜索，并且搜索过程是对称的。它首先检查中间元素，如果中间元素是要搜索的元素，则搜索过程结束。如果中间元素大于要搜索的元素，则在数组的左半部分继续搜索。相反，如果中间元素小于要搜索的元素，则在数组的右半部分继续搜索。
def binary_search(arr, low, high, x):
if high >= low:
mid = (high + low) // 2
if arr[mid] == x:
return mid
elif arr[mid] > x:
return binary_search(arr, low, mid - 1, x)
else:
return binary_search(arr, mid + 1, high, x)
else:
return -1

1. 图算法：适用于需要处理图形结构的情况。例如，最短路径算法（Dijkstra、Bellman-Ford等）、最小生成树算法（Kruskal、Prim等）。

def dijkstra(graph, start_vertex):
D = {v:float('infinity') for v in graph}
D[start_vertex] = 0
queue = [(0, start_vertex)]
while queue:
current_distance, current_vertex = min(queue, key=lambda x:x[0])
queue.remove((current_distance, current_vertex))
if current_distance > D[current_vertex]:
continue
for neighbor, weight in graph[current_vertex].items():
old_distance = D[neighbor]
new_distance = current_distance + weight
if new_distance < oldDistance:
D[neighbor] = newDistance
queue.append((newDistance, neighbor))
return D  #returns dictionary of shortest distances from start node to every other node in the graph.

1. 动态规划算法：适用于需要解决复杂问题，且问题的子问题也具有独立性时的情况。例如，背包问题、最长公共子序列问题等。
以背包问题为例：背包问题是一种典型的动态规划问题，其目标是在给定背包容量和物品重量及价值的情况下，选择一系列物品装入背包以使得背包中的总价值最大。

def knapsack(weights, values, W):
n = len(weights)
dp = [[0 for _ in range(W+1)] for _ in range(n+1)]

for i in range(1, n+1):
for w in range(1, W+1):
if weights[i-1] <= w:
dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i-1]] + values[i-1])
else:
dp[i][w] = dp[i-1][w]

return dp[n][W]

1. 分治算法：适用于可以将大问题分解为若干个小问题的情况。例如，归并排序、快速排序等。

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

1. 贪心算法：适用于问题的最优解可以通过一系列局部最优的选择来达到全局最优的情况。例如，霍夫曼编码、最小生成树等。
这里以霍夫曼编码为例：霍夫曼编码是一种用于数据压缩的贪心算法。它通过为每个频繁出现的字符创建一个尽可能短的编码来工作。在编码过程中，每个字符的编码是根据前一个字符的编码来确定的。

class HuffmanNode:
def __init__(self, freq, char=None):
self.freq = freq
self.char = char
self.left = None
self.right = None
self.huff = None

def __cmp__(self, other):
if(other == None):
return -1
if(self.freq == other.freq):
return 0
elif(self.freq > other.freq):
return 1
else:
return -1

def build_heap(arr):
n = len(arr)

for i in range(n//2 - 1, -1, -1):
heapify(arr, n, i)

def heapify(arr, n, i):
smallest = i
left = 2*i + 1
right = 2*i + 2

if left < n and arr[smallest].freq > arr[left].freq:
smallest = left

if right < n and arr[smallest].freq < arr[right].freq:
smallest = right

if smallest != i:
arr[i], arr[smallest] = arr[smallest], arr[i]  # swap
heapify(arr, n, smallest)  # call heapify for the smallest element at root.

def huffman_encode(arr):
arr_min = None  # to store the minimum frequency object
heap = []  # to store the heap  minimum at the root of heap.   //创建最小堆，根节点为最小值。   //将数组转化为最小堆。 build_heap(heap)  for item in arr:   heap.append(item)   build_heap(heap) //删除重复的元素 arr_min = heap[0] //将频率最小的元素移除 heap.remove(arr_min) //添加到 huffman tree 中 if arr_min.charif arr_min.char == None:
arr_min = heap[0]
heap.remove(arr_min)
else:
heap.remove(arr_min)

# The function to print the binary tree.
def print_binary_tree(root):
if root is not None:
print_binary_tree(root.left)
print(root.data, end=" ")
print_binary_tree(root.right)

# The main function to find the Huffman编码 of a string.
def find_huffman_encoding(text):
# Create a frequency table for all characters in the text.
char_freq = {}
for char in text:
char_freq[char] = char_freq.get(char, 0) + 1

# Create a priority queue to store the nodes of the Huffman tree.
# The priority of a node is defined by the sum of the frequencies
# of its two children.
pq = []
for char, freq in char_freq.items():
pq.append((freq, char))
heapq.heapify(pq)

# Create an empty Huffman tree and add the nodes to it in a way
# that maintains the property that the priority of a node is
# defined by the sum of the frequencies of its two children.
while len(pq) > 1:
left = heapq.heappop(pq)
right = heapq.heappop(pq)
merge_node = HuffmanNode(left[0] + right[0], None)
merge_node.left = HuffmanNode(left[0], left[1])
merge_node.right = HuffmanNode(right[0], right[1])
heapq.heappush(pq, merge_node)

# The last element in the priority queue is the root of the Huffman tree.
root = pq[-1]

# Now, we can build the Huffman encoding by traversing the Huffman tree.
huff_enc = []
print_binary_tree(root)print("Huffman encoding for text: ")
huff_enc.reverse()  # reverse the list because the traversal is in reverse order.
print(huff_enc)


### 实践和项目

1. 参与开源项目：许多开源项目都涉及到复杂的数据结构和算法。参与这些项目的开发和维护，可以帮助你了解如何在实际应用中选择和实现数据结构和算法。

1. 构建自己的项目：选择一个实际问题，并尝试用数据结构和算法来解决它。例如，你可以尝试实现一个基于哈希表的字典查找系统，或者实现一个基于二分搜索的查找引擎。

🧸结尾 ❤️ 感谢您的支持和鼓励！ 😊🙏
📜您可能感兴趣的内容：

• 48
点赞
• 46
收藏
觉得还不错? 一键收藏
• 打赏
• 47
评论
09-03

### “相关推荐”对你有帮助么？

• 非常没帮助
• 没帮助
• 一般
• 有帮助
• 非常有帮助

IT·陈寒

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。