归并排序，不错~~

《算法导论》2.3-7很值得一练。其中用到了归并排序、二分查找等等：

Give a Q(n lg n) time algorithm for determining if there exist two elements in an set S whose sum is exactly some value x.

以下是答案，其实想想很简单的。

代码如下，以备日后查找:)

代码

#include  < stdio.h >
#include  < math.h >
#define  N 100

void  quicksort( float   * data,  int  start,  int  end);
void  merge( float   * data1,  int  length1,  float   * data2,  int  length2,
   float   * newlist);
int  binary_search( float *  a,  int  start,  int  end,  double  val);

/* ************************************************************************ */
/*  Purpose: This program reads a list of numbers, divides the list into    */
/*   two sublists, performs a quicksort on each sublist, then merges the    */
/*   two sorted lists of numbers to form a single sorted list.              */
/* ************************************************************************ */

FILE  * datafile;  /*  pointer to data file  */

void  main( int  argc,  char   * argv[])
{
   char  temp[ 60 ];
   int  i, midpoint, X, idx;
   float  data1[N / 2 + 1 ], data2[N / 2 + 1 ], newlist[N];

  strcpy(temp, argv[ 1 ]);

   /*  open data file  */
  datafile  =  fopen(temp, " r " );
   if  ( ! datafile)
  {
    printf( " *** Error opening %s ***\n " ,temp);
     return ;
  }

  midpoint  =  N / 2 ;

   /*  read entries from data file, storing first half in data1 
     and second half in data2  */
   for  (i = 0 ; i < midpoint; i ++ )
    fscanf(datafile,  " %f\n " , & data1[i]);
   for  (i = midpoint; i < N; i ++ )
    fscanf(datafile,  " %f\n " , & data2[i - midpoint]);

   /*  perform quicksort on each list  */
  quicksort(data1, 0 ,midpoint - 1 );
  quicksort(data2, 0 ,N - 1 - midpoint);

   /*  merge the two sublists  */
  merge(data1,midpoint,data2,N - midpoint,newlist);

   /*  print the sorted list  */
//    for (i=0;i<N;++i)
//      printf("newlist[%d] = %f\n", i, newlist[i]);
  X  =   15 ;
   for  (i  =   0 ; i  <  N; i ++ )
  {

      idx  =  binary_search( newlist,  0 , N  -   1 , X  -  newlist[i]);

     if  ( idx  >=   0 )
    {
         // printf("%f\n", newlist[idx]);
        printf( " Yes:\tA[%d] = %f, A[%d] = %f\n " , i, newlist[i], idx, newlist[idx]);
    }
  }

  fclose(datafile);
   return ;
}

void  quicksort( float   * data,  int  begin,  int  end)
{
   /* ********************************************************************* */
   /*  Purpose: sorts a list of numbers in increasing order                 */
   /*  Input:                                                               */
   /*    data: an unsorted array of numbers                                 */
   /*    begin: the beginning index of "data"                               */
   /*    end: the final index of "data"                                     */
   /*  Output:                                                              */
   /*    upon termination of the subroutine, "data" contains the sorted     */
   /*      list of numbers                                                  */
   /* ********************************************************************* */

   int  leftarrow, rightarrow;
   float  temp, pivot;

  leftarrow  =  begin;
  rightarrow  =  end;
  pivot  =  data[(begin + end) / 2 ];
   while  ( 1 )
  {
     while  (data[rightarrow]  >  pivot)
      rightarrow  =  rightarrow  -   1 ;

     while  (data[leftarrow]  <  pivot)
      leftarrow  =  leftarrow  +   1 ;

     if  (leftarrow  <=  rightarrow)
    {
      temp  =  data[leftarrow];
      data[leftarrow]  =  data[rightarrow];
      data[rightarrow]  =  temp;
      leftarrow  =  leftarrow  +   1 ;
      rightarrow  =  rightarrow  -   1 ;
    }

     if  (rightarrow  <  leftarrow)
       break ;
  } 

   if  (begin  <  rightarrow)
    quicksort(data,begin,rightarrow);
   if  (leftarrow  <  end)
    quicksort(data,leftarrow,end);

   return ;
}

void  merge( float   * data1,  int  length1,  float   * data2,  int  length2,
   float   * newlist)
{
   /* ********************************************************************* */
   /*  Purpose: merges two sorted sublists (in increasing order) to form    */
   /*    a single sorted list                                               */
   /*  Input:                                                               */
   /*    data1: a sorted array of numbers                                   */
   /*    length1: the length of array data1                                 */
   /*    data2: a second sorted array of numbers                            */
   /*    length2: the length of array data2                                 */
   /*  Output:                                                              */
   /*    upon termination of the subroutine, "newlist" contains the         */
   /*      merged list of numbers, sorted in increasing order               */
   /* ********************************************************************* */

   int  leftarrow1, rightarrow1, leftarrow2, rightarrow2, i;

   /*  initialize variables  */
  leftarrow1  =   0 ;
  rightarrow1  =  length1 - 1 ;
  leftarrow2  =   0 ;
  rightarrow2  =  length2 - 1 ;
  i = 0 ;
  
   /*  while both arrays are nonempty, copy the smallest element 
     appearing in either array, into newlist  */
   while  ((leftarrow1  <=  rightarrow1)  &&  (leftarrow2  <=  rightarrow2))
  {
     if  (data1[leftarrow1]  <  data2[leftarrow2])
    {
      newlist[i]  =  data1[leftarrow1];
      leftarrow1 ++ ;
    }
     else
    {
      newlist[i]  =  data2[leftarrow2];
      leftarrow2 ++ ;
    }
    i ++ ;
  }
 
   /*  finish nonempty array data1, if necessary  */
   while  (leftarrow1  <=  rightarrow1)
  {
    newlist[i]  =  data1[leftarrow1];
    leftarrow1 ++ ;
    i ++ ;
  }

   /*  finish nonempty array data2, if necessary  */
   while  (leftarrow2  <=  rightarrow2)
  {
    newlist[i]  =  data2[leftarrow2];
    leftarrow2 ++ ;
    i ++ ;
  }

   return ;
}


int  binary_search( float *  a,  int  start,  int  end,  double  val)
{
     int  ii  =  ( int )((end  +  start)  /   2 );
     double  mid  =  ( double )(a[ii]);
     int  res;
     if (mid  ==  val)
    {
        res  =  ii;
         return  res;
    }
     else   if  (val  <  mid)
    {
         if  ( ii  ==  start)
        {
             return   - 1 ;
        }
        res  =  binary_search(a, start, ii  -   1 , val);
    }
     else   if  (val  >  mid)
    {
         if  ( ii  ==  end)
        {
             return   - 1 ;
        }
        res  =  binary_search(a, ii  +   1 , end, val);
    }
     return  res;
    
}