iOS开发-一些面试算法总结

由于最近需要面试,笔试的时候遇到了不同的算法,上网搜了一些

这里把常考到的常用排序算法简单汇总了下。

包括冒泡排序，简单选择排序，直接插入排序，希尔排序，堆排序和快速排序。

 //常用排序汇总

 #include <stdio.h>

 void swap(intint *a, intint *b);
 void bubble_sort(int a[], int n);
 void select_sort(int a[], int n);
 void insert_sort(int a[], int n);
 void shell_sort(int a[], int n);
 void heap_adjust(int a[], int i, int n);
 void heap_sort(int a[], int n);
 void quick_sort(int a[], int low, int high);

 int main()
 {
     int arr[] = {0,2,3,1,6,9,8,7,4,5};

 //    bubble_sort(arr, 10);
 //    select_sort(arr, 10);
 //    insert_sort(arr, 10);
 //    shell_sort(arr, 10);
 //    heap_sort(arr, 10);
     quick_sort(arr, 0, 9);

     for (int i = 0; i < 10; i++)
     {
         printf("%d\n", arr[i]);
     }

     return 0;
 }

 //交换数据
 void swap(intint *a, intint *b)
 {
     int tmp = *a;
     *a = *b;
     *b = tmp;
 }

 //冒泡排序法
 //时间复杂度O(n^2) 空间复杂度O(1)
 void bubble_sort(int a[], int n)
 {
     int i, j;
     //旗帜位，判断这次遍历是否有交换
     int flag = 1;

     for (i = 0; i < n && flag; i++)
     {
         flag = 0;
         for (j = n-2 ; j >= i; j--)
         {
             if (a[j] > a[j+1])
             {
                 swap(&a[j], &a[j+1]);
                 flag = 1;
             }
         }
     }
 }

 //简单选择排序
 //时间复杂度O(n^2) 空间复杂度O(1)
 void select_sort(int a[], int n)
 {
     int i, j, min;

     for (i = 0; i < n ; i++)
     {
         min = i;
         for (j = i+1; j < n; j++)
         {
             if (a[j] < a[min])
             {
                 min = j;
             }
         }
         if (min != i)
         {
             swap(&a[min], &a[i]);
         }
     }
 }

 //直接插入排序
 //时间复杂度O(n^2) 空间复杂度O(1)
 void insert_sort(int a[], int n)
 {
     for (int i = 0; i < n ; i++)
     {
         int temp = a[i];
         int j = i-1;
         while (j>=0 && a[j] > temp)
         {
             a[j+1] = a[j];
             j--;
         }
         a[j+1] = temp;
     }
 }

 //希尔排序
 //时间复杂度为O(nlogn) 空间复杂度为O(1)
 void shell_sort(int a[], int n)
 {
     int i,j,temp;
     int gap = 0;
     while (gap <= n) gap = gap*3+1;
     while (gap > 0)
     {
         for (i = gap; i < n; i++)
         {
             temp = a[i];
             j = i - gap;
             while (j >= 0 && a[j] > temp)
             {
                 a[j+gap] = a[j];
                 j = j - gap;
             }
             a[j+gap] = temp;
         }
         gap = (gap-1)/3;
     }
 }

 //堆排序
 //时间复杂度为O(nlogn) 空间复杂度为O(1)
 void heap_sort(int a[], int n)
 {
     for (int i = n/2 - 1; i >= 0; i--)
     {
         heap_adjust(a, i, n);
     }
     for (int i = n-1; i > 0; i--)
     {
         swap(&a[0], &a[i]);

         heap_adjust(a, 0, i);
     }
 }

 //构建大顶堆
 void heap_adjust(int a[], int i, int n)
 {
     int child, temp;

     for (temp = a[i]; 2*i+1 < n; i = child)
     {
         child = 2*i+1;
         //取得较大子结点索引
         if (child < n -1 && a[child] < a[child+1]) child++;
         //保证父结点大于等于子结点
         if (temp < a[child]) swap(&a[i], &a[child]);
         else break;
     }
 }

 //快速排序
 //时间复杂度为O(nlogn) 空间复杂度为O(logn) ~ O(n)
 void quick_sort(int a[], int low, int high)
 {
     int i = low+1;
     int j = high;
     int key = a[low];

     if (low >= high) return;

     while (1) {
         while (key<a[j]) j--;
         while (key>a[i] && i<j) i++;
         if (i >= j) break;

         swap(&a[i], &a[j]);

         if (a[i] == key) j--;
         else i++;
     }

     swap(&a[low], &a[j]);

     if (i-1>low) quick_sort(a, low, i-1);
     if (j+1<high) quick_sort(a, j+1, high);
 }