10个经典的c语言基础算法及代码是什么，10个经典的C语言基础算法及代码

1. 冒泡排序算法

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。时间复杂度为O(n^2)。

代码实现：

void bubbleSort(int arr[], int n)

{

int i, j;

for (i = 0; i < n-1; i++)

{

for (j = 0; j < n-i-1; j++)

{

if (arr[j] >arr[j+1])

{

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

}

2. 快速排序算法

快速排序是一种常用的排序算法，它采用分治的思想，将一个大问题分解成若干个小问题，然后递归求解。时间复杂度为O(nlogn)。

代码实现：

void quickSort(int arr[], int left, int right)

{

int i, j, pivot;

if (left < right)

{

i = left;

j = right;

pivot = arr[left];

while (i < j)

{

while (i < j && arr[j] >= pivot)

j--;

if (i < j)

arr[i++] = arr[j];

while (i < j && arr[i] < pivot)

i++;

if (i < j)

arr[j--] = arr[i];

}

arr[i] = pivot;

quickSort(arr, left, i-1);

quickSort(arr, i+1, right);

}

}

3. 插入排序算法

插入排序是一种简单的排序算法，它将一个元素插入到已经排好序的序列中，使得插入后仍然有序。时间复杂度为O(n^2)。

代码实现：

void insertionSort(int arr[], int n)

{

int i, j, key;

for (i = 1; i < n; i++)

{

key = arr[i];

j = i - 1;

while (j >= 0 && arr[j] >key)

{

arr[j+1] = arr[j];

j--;

}

arr[j+1] = key;

}

}

4. 选择排序算法

选择排序是一种简单的排序算法，它每次从未排序的序列中选择最小的元素，放到已排序的序列末尾。时间复杂度为O(n^2)。

代码实现：

void selectionSort(int arr[], int n)

{

int i, j, min_idx;

for (i = 0; i < n-1; i++)

{

min_idx = i;

for (j = i+1; j < n; j++)

{

if (arr[j] < arr[min_idx])

min_idx = j;

}

int temp = arr[min_idx];

arr[min_idx] = arr[i];

arr[i] = temp;

}

}

5. 归并排序算法

归并排序是一种分治的排序算法，它将一个序列分成两个子序列，分别排序后再合并。时间复杂度为O(nlogn)。

代码实现：

void merge(int arr[], int left, int mid, int right)

{

int i, j, k;

int n1 = mid - left + 1;

int n2 = right - mid;

int L[n1], R[n2];

for (i = 0; i < n1; i++)

L[i] = arr[left+i];

for (j = 0; j < n2; j++)

R[j] = arr[mid+1+j];

i = 0;

j = 0;

k = left;

while (i < n1 && j < n2)

{

if (L[i] <= R[j])

{

arr[k] = L[i];

i++;

}

else

{

arr[k] = R[j];

j++;

}

k++;

}

while (i < n1)

{

arr[k] = L[i];

i++;

k++;

}

while (j < n2)

{

arr[k] = R[j];

j++;

k++;

}

}

void mergeSort(int arr[], int left, int right)

{

if (left < right)

{

int mid = left + (right-left)/2;

mergeSort(arr, left, mid);

mergeSort(arr, mid+1, right);

merge(arr, left, mid, right);

}

}

6. 希尔排序算法

希尔排序是一种改进的插入排序算法，它将序列分成若干个子序列，对每个子序列进行插入排序，然后逐步缩小子序列的长度，最终完成排序。时间复杂度为O(nlogn)。

代码实现：

void shellSort(int arr[], int n)

{

int i, j, gap;

for (gap = n/2; gap > 0; gap /= 2)

{

for (i = gap; i < n; i++)

{

int temp = arr[i];

for (j = i; j >= gap && arr[j-gap] > temp; j -= gap)

arr[j] = arr[j-gap];

arr[j] = temp;

}

}

}

7. 堆排序算法

堆排序是一种树形选择排序算法，它将序列构建成一个二叉堆，然后依次取出堆顶元素，再将剩余元素重新构建成一个堆。时间复杂度为O(nlogn)。

代码实现：

void heapify(int arr[], int n, int i)

{

int largest = i;

int l = 2*i + 1;

int r = 2*i + 2;

if (l < n && arr[l] >arr[largest])

largest = l;

if (r < n && arr[r] >arr[largest])

largest = r;

if (largest != i)

{

int temp = arr[i];

arr[i] = arr[largest];

arr[largest] = temp;

heapify(arr, n, largest);

}

}

void heapSort(int arr[], int n)

{

int i;

for (i = n/2-1; i >= 0; i--)

heapify(arr, n, i);

for (i = n-1; i >= 0; i--)

{

int temp = arr[0];

arr[0] = arr[i];

arr[i] = temp;

heapify(arr, i, 0);

}

}

8. 计数排序算法

计数排序是一种非比较排序算法，它统计每个元素出现的次数，然后依次输出。时间复杂度为O(n+k)，其中k为元素的范围。

代码实现：

void countingSort(int arr[], int n)

{

int i, j, max = arr[0], min = arr[0];

for (i = 1; i < n; i++)

{

if (arr[i] >max)

max = arr[i];

if (arr[i] < min)

min = arr[i];

}

int range = max - min + 1;

int count[range];

for (i = 0; i < range; i++)

count[i] = 0;

for (i = 0; i < n; i++)

count[arr[i]-min]++;

for (i = 1; i < range; i++)

count[i] += count[i-1];

int output[n];

for (i = n-1; i >= 0; i--)

{

output[count[arr[i]-min]-1] = arr[i];

count[arr[i]-min]--;

}

for (i = 0; i < n; i++)

arr[i] = output[i];

}

9. 桶排序算法

桶排序是一种非比较排序算法，它将元素分配到不同的桶中，然后对每个桶进行排序，最后依次输出。时间复杂度为O(n+k)，其中k为桶的数量。

代码实现：

void bucketSort(int arr[], int n)

{

int i, j;

int max = arr[0], min = arr[0];

for (i = 1; i < n; i++)

{

if (arr[i] >max)

max = arr[i];