主流算法的编写通常遵循以下步骤：
理解问题
仔细阅读题目，理解问题的背景和要求。
确定输入、输出和处理过程。
选择合适的算法
根据问题的特性选择合适的算法。例如，对于排序问题，可以选择冒泡排序、快速排序等。
考虑算法的正确性、效率和可行性。
设计算法
使用伪代码、流程图或自然语言描述算法步骤。
确定算法的输入、输出和中间过程。
考虑边界条件和特殊情况。
实现算法
选择合适的编程语言和开发环境。
将算法步骤转化为计算机可执行的代码。
注意代码的结构和可读性，以便于后续的维护和调试。
测试和验证
设计测试用例，覆盖各种可能的输入情况。
运行测试，验证算法的正确性和效率。
调试和修正代码中的错误。
优化和重构
分析算法的性能，寻找优化空间。
重构代码，提高代码的可读性和效率。
可能需要使用更高级的数据结构和算法来改进性能。
冒泡排序
```plaintext
function bubbleSort（arr）:
n = length（arr）
for i from 0 to n-1:
for j from 0 to n-i-2:
if arr[j] > arr[j+1]:
swap（arr[j], arr[j+1]）
```
快速排序
```plaintext
function quickSort（arr, low, high）:
if low < high:
pivotIndex = partition（arr, low, high）
quickSort（arr, low, pivotIndex-1）
quickSort（arr, pivotIndex+1, high）
function partition（arr, low, high）:
pivot = arr[high]
i = low - 1
for j from low to high-1:
if arr[j] < pivot:
i = i + 1
swap（arr[i], arr[j]）
swap（arr[i+1], arr[high]）
return i + 1
```
动态规划
```plaintext
function knapsack（weights, values, capacity）:
n = length（weights）
dp = array of size （n+1） x （capacity+1） filled with 0
for i from 0 to n:
for w from 0 to capacity:
if weights[i] <= w:
dp[i+1][w] = max（dp[i][w], values[i] + dp[i][w-weights[i]]）
else:
dp[i+1][w] = dp[i][w]
return dp[n][capacity]
```
图的最短路径算法（Dijkstra算法）
```plaintext
function dijkstra（graph, start）:
n = length（graph）
dist = array of size n filled with infinity
dist[start] = 0
visited = array of size n filled with false
for i from 0 to n-1:
u = minDistance（dist, visited）
visited[u] = true
for v from 0 to n-1:
if not visited[v] and graph[u][v] + dist[u] < dist[v]:
dist[v] = graph[u][v] + dist[u]
return dist
function minDistance（dist, visited）:
min = infinity
for v from 0 to length（dist）-1:
if not visited[v] and dist[v] < min:
min = dist[v]
return min
```
通过以上步骤和示例，你可以更好地理解和编写主流算法。记住，选择合适的算法并不断优化是实现高效编程的关键。