week_1 算法小总结

二分查找法

---

要用二分查找法，首先你要先拥有一个有序数组，这是必须的前提，查找到想要的数之后返回对应的下标值，没找到就返回-1。

二分查找要比利用for循环进行挨个遍历要快得多，二分法的搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

• 查找所给的int数aim是否在一直有序数组中，若没哟就返回-1.

int search(int a[], int n, int aim)
{
    int left = 0;
    int right = n - 1;
  
    while (left <= right) 
    {
        int middle = left + ((right - left) >> 1); 
        if (a[middle] >aim)
            right = middle - 1; 
        else if (a[middle] < aim)
            left = middle + 1;
        else
            return middle;
    }
    return -1;
}

• 查找aim第一次出现的下标值，没找到就返回-1.

int search(int a[], int n, int aim)
{
    int left = 0;
    int right = n - 1;

    while (left <= right)  
    {
        int middle = left + ((right - left) >> 1);
        if (a[middle] >= aim) 
            right = middle - 1;
        else
            left = middle + 1;
    }
    return a[right + 1] == aim ? right + 1 : -1;
}

除此之外，在做算法题时还要格外注意题目所需的输入输出格式，严格按照格式输出。
算法题中经常会出现第一行输入一个数n，然后接下来有n组测试数据等等形式，可以采用

while(n--)
{
...
}

的形式代替for( ; ; )来进行整体的循环，我认为会简洁明了一些。

快速排序

---

首先你要选取一个基准数a来进行以此为标准的比较，再设定两个变量i,j分别从无序数组的左右两边来进行遍历，若选取最左边第一个数为基准数则需要指向最右边的变量j先开始移动，下一步指向左边的变i量紧接着开始移动，j找到一个小于a的值就停下来，等待i找到一个大于a的值，然后互相交换，在i，j没有相遇之前就一直这样相对前进，直到i=j，交换基准数a与变量i，j所指向的数值。
以此将数组分为左右两个，再分别如此进行遍历，一直到待排序的数组不能被分为两半就结束。

#include <stdio.h>
#include <stdlib.h> 

void swap(int *x,int *y)
{
   int temp;
   temp = *x;
   *x = *y;
   *y = temp;
}

int choose_pivot(int i,int j )
{
   return((i+j) /2);
}

void quicksort(int list[],int m,int n)
{
   int key,i,j,k;
   if( m < n)
   {
      k = choose_pivot(m,n);
      swap(&list[m],&list[k]);
      key = list[m];
      i = m+1;
      j = n;
      while(i <= j)
      {
         while((i <= n) && (list[i] <= key))
                i++;
         while((j >= m) && (list[j] > key))
                j--;
         if( i < j)
                swap(&list[i],&list[j]);
      }
     // 交换两个元素的位置
      swap(&list[m],&list[j]);
     // 递归地对较小的数据序列进行排序
      quicksort(list,m,j-1);
      quicksort(list,j+1,n);
   }
}

void printlist(int list[],int n)
{
   int i;
   for(i=0;i<n;i++)
      printf("%d\t",list[i]);
}

void main()
{
   const int MAX_ELEMENTS = 10;
   int list[MAX_ELEMENTS];

   int i = 0;
   
   // 产生填充序列的随机数
   for(i = 0; i < MAX_ELEMENTS; i++ ){
     list[i] = rand();
   }
   printf("进行排序之前的序列:\n");
   printlist(list,MAX_ELEMENTS);
   
   // sort the list using quicksort
   quicksort(list,0,MAX_ELEMENTS-1);

   // print the result
   printf("使用快速排序算法进行排序之后的序列:\n");
   printlist(list,MAX_ELEMENTS);
}

但c库函数中有qsort(),可以更加方便的使用快速排序算法进行排序：

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void , const void))

• base – 指向要排序的数组的第一个元素的指针。
• nitems – 由 base 指向的数组中元素的个数。
• size – 数组中每个元素的大小，以字节为单位。
• compar – 用来比较两个元素的函数。

具体的用法，看一遍之后就会觉得真的方便很多，冒泡排序、简单选择可能以后都不会用啦！！

#include <stdio.h>
#include <stdlib.h>

int values[] = { 88, 56, 100, 2, 25 };

int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int main()
{
   int n;

   printf("排序之前的列表：\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }

   qsort(values, 5, sizeof(int), cmpfunc);

   printf("\n排序之后的列表：\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }
  
  return(0);
}

看到这里，反正我觉得又简单效率又高，i了i了～