10个经典的C语言基础算法及代码

10个经典的C语言基础算法及代码
1.冒泡排序算法
冒泡排序是一种简单但效率较低的排序算法，在每一轮遍历中比较相邻的两个元素，如果顺序不正确则交换它们，直到整个数组有序为止。

```c
void bubbleSort(int arr[], int n)
for (int i = 0; i < n-1; i++)
for (int j = 0; j < n-1-i; j++)
if (arr[j] > arr[j+1])
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
```
2.选择排序算法
选择排序是一种简单直观的排序算法，它每次从待排序的数组中选择最小（或最大）的元素，并放到已排序的数组末尾。

```c
void selectionSort(int arr[], int n)
for (int i = 0; i < n-1; i++)
int min_index = i;
for (int j = i+1; j < n; j++)
if (arr[j] < arr[min_index])
min_index = j;
}
}
int temp = arr[i];
arr[i] = arr[min_index];
arr[min_index] = temp;
}
```
3.插入排序算法
插入排序的基本思想是将数组分为已排序和未排序两部分，每次将未排序的元素插入到已排序的合适位置。

```c
void insertionSort(int arr[], int n)
for (int i = 1; i < n; i++)
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key)
arr[j+1] = arr[j];
j--;
}
arr[j+1] = key;
}
```
4.快速排序算法
快速排序使用分治法的思想，每次选择一个基准元素，将小于基准的元素放到左边，大于基准的元素放到右边，然后递归地对左右两个子数组进行排序。

```c
void quickSort(int arr[], int low, int high)
if (low < high)
int pivot = partition(arr, low, high);
quickSort(arr, low, pivot - 1);
quickSort(arr, pivot + 1, high);
}
int partition(int arr[], int low, int high) int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++)
if (arr[j] < pivot)
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i+1], &arr[high]);
return i+1;
void swap(int *a, int *b)
int temp = *a;
*a=*b;
*b = temp;
```
5.归并排序算法
归并排序采用分治法的思想，将数组分成两个子数组，分别进行排序，然后合并这两个子数组以得到完整的有序数组。

```c
void mergeSort(int arr[], int left, int right)
if (left < right)
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid+1, right);
merge(arr, left, mid, right);
}
void merge(int arr[], int left, int mid, int right)
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++)
L[i] = arr[left + i];
}
for (int j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
}
int i = 0, j = 0, k = left;
while (i < n1 && j < n2)
if (L[i] <= R[j])
arr[k++] = L[i++];
} else
arr[k++] = R[j++];
}
}
while (i < n1)
arr[k++] = L[i++];
}
while (j < n2)
arr[k++] = R[j++];
}
```
6.线性查找算法
线性查找算法是最简单、直观的查找算法，遍历数组中的所有元素，逐个比较目标值。

```c
int linearSearch(int arr[], int n, int target)
for (int i = 0; i < n; i++)
if (arr[i] == target)
return i;
}
}
return -1;
```
7.二分查找算法
二分查找算法是一种高效的查找算法，要求待查找数组必须有序。

通过不断缩小范围来寻找目标值。

```c
int binarySearch(int arr[], int left, int right, int target) while (left <= right)
int mid = left + (right - left) / 2;
if (arr[mid] == target)
return mid;
} else if (arr[mid] < target)
left = mid + 1;
} else
right = mid - 1;
}
}
return -1;
```
8.斐波那契数列
斐波那契数列是指每个数都是前两个数的和：0、1、1、2、3、5、8、13、21、34...
```c
int fibonacci(int n)
if (n <= 1)
return n;
}
int a = 0, b = 1, c;
for (int i = 2; i <= n; i++)
c=a+b;
a=b;
b=c;
}
return b;
```
9.阶乘
阶乘是指连乘一个正整数及其之前所有正整数的乘积：n!=n*(n-1)*(n-2)*...*2*1
```c
int factorial(int n)
if (n == 0)
return 1;
}
int result = 1;
for (int i = 2; i <= n; i++)
result *= i;
}
return result;
```
10.斐波那契堆
斐波那契堆是一种用于实现优先队列的数据结构，它结合了二叉堆和双向链表的优点，具有较高的合并和分割效率。

```c
typedef struct _FibNode
int key;
int degree;
int marked;
struct _FibNode *parent;
struct _FibNode *child;
struct _FibNode *left;
struct _FibNode *right;
} FibNode;
typedef struct _FibHeap
int num_nodes;
FibNode *min;
} FibHeap;
```
以上是10个经典的C语言基础算法及其代码，每个算法的实现都包含了完整的函数定义和关键代码片段，希望对你的学习有所帮助。