在编程中，基础算法是解决问题的基础，掌握它们对于编写高效、可靠的代码至关重要。以下是几种常见的基础算法的简要介绍和示例代码：
排序算法 冒泡排序：
通过不断比较相邻元素并交换位置，将较大的元素“冒泡”到数组的末尾。
插入排序：将未排序的元素插入到已排序部分的正确位置。
选择排序：每次从未排序的元素中选择最小（或最大）的元素，放到已排序部分的末尾。
快速排序：通过选择一个“基准”元素，将数组分为两部分，再递归地对两部分进行排序。
归并排序：将数组分成两半，分别排序，然后将结果合并。
示例代码（Python）：
```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]
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
```
查找算法 线性查找：
从数组的第一个元素开始，逐个检查直到找到目标元素或遍历完整个数组。
二分查找：利用数组的有序性，每次将查找范围缩小一半。
示例代码（Python）：
```python
def linear_search（arr, target）:
for i in range（len（arr））:
if arr[i] == target:
return i
return -1
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
```
动态规划 斐波那契数列：
通过递推关系 F（n） = F（n-1） + F（n-2） 来计算第 n 个斐波那契数。
示例代码（Python）：
```python
def fibonacci（n）:
if n <= 1:
return n
a, b = 0, 1
for _ in range（2, n + 1）:
a, b = b, a + b
return b
```
回溯算法
八皇后问题： 在 8x8 的棋盘上放置八个皇后，使它们互不攻击。 示例代码（Python）： ```python def is_safe（board, row, col, n）: for i in range（col）: if board[row][i] == 1: return False for i, j in zip（range（row, -1, -1）, range（col, -1, -1））: if board[i][j] == 1: return False for i, j in zip（range（row, n, 1）, range（col, -1, -1））: if board[i][j] == 1: return False return True def solve_n_queens（board, col, n）: if col >= n: return True for i in range（n）: if is_safe（board, i, col, n）: board[i][col] = 1 if solve_n_queens（board, col + 1, n）: return True board[i][col] = 0 return False ```分治算法
归并排序：
将数组分成两半，分别排序，然后将结果合并。
示例代码（Python）：