编写编程中的基础算法可以按照以下步骤进行：
明确问题和约束
确定算法的目标和需要解决的问题。
明确问题的输入、输出以及可能的约束条件。
选择合适的算法
根据问题的性质选择合适的算法。例如，对于排序问题，可以选择冒泡排序、插入排序、快速排序等。
考虑算法的正确性、效率和可行性。
设计算法
使用伪代码、流程图或具体的编程语言描述算法步骤。
确定算法的输入、输出和中间过程。
考虑算法的边界情况和异常处理。
实现算法
选择合适的编程语言和数据结构。
将算法步骤转化为计算机可执行的代码。
注意代码的结构、可读性和可维护性。
测试和验证
对算法进行单元测试，确保其正确性。
使用不同的输入数据验证算法的鲁棒性。
分析和评估算法的时间复杂度和空间复杂度。
优化和重构
根据测试结果对算法进行优化，提高效率。
重构代码以提高可读性和可扩展性。
排序算法
冒泡排序：
```python
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]
```
快速排序：
```python
def quick_sort（arr, low, high）:
if low < high:
pi = partition（arr, low, high）
quick_sort（arr, low, pi-1）
quick_sort（arr, pi+1, high）
def partition（arr, low, high）:
pivot = arr[high]
i = low - 1
for j in range（low, high）:
if arr[j] < pivot:
i += 1
arr[i], arr[j] = arr[j], arr[i]
arr[i+1], arr[high] = arr[high], arr[i+1]
return i + 1
```
查找算法
线性查找：
```python
def linear_search（arr, target）:
for i in range（len（arr））:
if arr[i] == target:
return i
return -1
```
二分查找：
```python
def binary_search（arr, target）:
low, high = 0, len（arr） - 1
while low <= high:
mid = （low + high） // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
low = mid + 1
else:
high = mid - 1
return -1
```
动态规划
背包问题：
```python
def knapsack（values, weights, capacity）:
n = len（values）
dp = [[0 for _ in range（capacity + 1）] for _ in range（n + 1）]
for i in range（1, n + 1）:
for w in range（1, capacity + 1）:
if weights[i-1] <= w:
dp[i][w] = max（dp[i-1][w], values[i-1] + dp[i-1][w-weights[i-1]]）
else:
dp[i][w] = dp[i-1][w]
return dp[n][capacity]
```
回溯算法
八皇后问题：