C語言中有多種排序算法可以實現對數組或鏈表的排序，常見的排序算法如下：

1. 冒泡排序（Bubble Sort）：通過比較相鄰的元素，將較大的元素逐步交換到末尾，時間復雜度為O(n^2)。

   void bubbleSort(int arr[], int n) {
       for (int i = 0; i < n-1; i++) {
           for (int 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. 插入排序（Insertion Sort）：將數組分為已排序和未排序兩部分，每次從未排序部分取一個元素插入到已排序部分的適當位置，時間復雜度為O(n^2)。

   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;
       }
   }
   

3. 選擇排序（Selection Sort）：每次從未排序部分選擇最小（或最大）的元素，將其與未排序部分的第一個元素交換，時間復雜度為O(n^2)。

   void selectionSort(int arr[], int n) {
       for (int i = 0; i < n-1; i++) {
           int minIndex = i;
           for (int j = i+1; j < n; j++) {
               if (arr[j] < arr[minIndex]) {
                   minIndex = j;
               }
           }
           int temp = arr[i];
           arr[i] = arr[minIndex];
           arr[minIndex] = temp;
       }
   }
   

4. 快速排序（Quick Sort）：選擇一個基準元素，將小于基準的元素移動到基準的左側，大于基準的元素移動到基準的右側，然后對左右兩部分遞歸地進行快速排序，時間復雜度為O(nlogn)。

   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++;
               int temp = arr[i];
               arr[i] = arr[j];
               arr[j] = temp;
           }
       }
       int temp = arr[i+1];
       arr[i+1] = arr[high];
       arr[high] = temp;
       return i+1;
   }
   

5. 歸并排序（Merge Sort）：將數組分割成兩個子數組，分別對兩個子數組進行遞歸的歸并排序，然后將兩個有序子數組合并成一個有序數組，時間復雜度為O(nlogn)。

   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