面试中常考的现场写小程序题目

在面试中面试官常常让我们写几个小的程序，以此来考察我们的编程内功。所以在准备面试的过程中在纸上练习着写一些程序是很有必要的。

下面是在面试中常考的几个题，出现频率非常之高！！！！

1、完整正确的写出二分查找的算法

int binary_search(int arr[],int n,int key)
{
        assert(arr!=NULL && n>0);//注意断言的作用
        int left=0;
        int right=n-1;
        int mid=0;
        while(left<=right)
        {
                mid = left + ((right-left)>>1);//不直接用(left+right)/2是防止越界和提高效率
                if(arr[mid]<key)
                        left=mid+1;
                else if(arr[mid]>key)
                        right=mid-1;
                else 
                        return mid;
        }
        return -1;
}

程序中要注意的地方:
 //right=n-1 => while(left <= right) => right=middle-1; 

//right=n   => while(left <  right) => right=middle;  

middle= (left+right)>>1;  这样的话 left 与 right 的值比较大的时候，其和可能溢出。

2、写出你认为效率高且常用的一种排序算法（快速排序、归并排序）

void QSort(int arr[],int low,int high)
{
        int pivot;
        while(low<high)//优化了递归操作
        {
                pivot=Partition(arr,low,high);
                QSort(arr,low,pivot-1);
                low=pivot+1;
        }
}

int Partition(int arr[],int low,int high)
{
        assert(arr!=NULL && low<high);
        int pivotkey=arr[low];//对于关键字的选取我们可以采取3数取中法或9数取中法，还可以随机取数来保证关键字正好是数组的接近中间位置。
        while(low<high)
        {
                while(low<high && arr[high]>=pivotkey)
                        high--;
                arr[low]=arr[high];//采用替换而不是交换的操作（优化不必要的交换）
                while(low<high && arr[low]<=pivotkey)
                        low++;
                arr[high]=arr[low];//采用替换而不是交换的操作
        }
        arr[low]=pivotkey;
        return low;
}

//3数取中法的代码
int m = low+((high-low)>>1);
if(arr[low]>arr[high])
    swap(arr[low],arr[high]);
if(arr[m]>arr[high])
    swap(arr[m],arr[high]);
if(arr[m]>arr[low])
    swap(arr[m],arr[low]);

3、反转链表

struct ListNode
{
        int        m_nValue;
        ListNode*  m_pNext;
};//链表的结构体

ListNode *ReverseList(ListNode *pHead)
{
        assert(pHead!=NULL);//防止传入的是一个空指针，参数检查很重要！！！一定不要忘记写
        ListNode *pReversedList = NULL; //指向反转后的链表的头结点
        ListNode *pNode = pHead;   //指向断开后链表的后面一段链表的第一个结点
        ListNode *pPrev = NULL;    //指向断开后链表的前面一段链表的最后一个结点
        while(pNode!=NULL)
        {
                ListNode *pNext = pNode->m_pNext;
                if(pNext == NULL)
                        pReversedList = pNode;
                pNode->m_pNext = pPrev;
                pPrev = pNode;
                pNode = pNext;
        }
        return pReversedList;
}

4、题目描述：
要求实现库函数 strcpy，
原型声明：extern char *strcpy(char *dest,char *src); 
功能：把 src 所指由 NULL 结束的字符串复制到 dest 所指的数组中。   
说明： src 和 dest 所指内存区域不可以重叠且 dest 必须有足够的空间来容纳 src 的字符串。
返回指向 dest 的指针。

[cpp] view plaincopyprint?

1. //得 10 分，基本上所有的情况，都考虑到了     
2. //如果有考虑到源目所指区域有重叠的情况，加 1 分！        
3. char * strcpy( char *strDest, const char *strSrc )//将源字符串加const，表明其为输入参数   
     
4. {       
5.    if(strDest == strSrc)   
6.        { return strDest; }    
7.    assert( (strDest != NULL) && (strSrc != NULL) );//对源地址和目的地址加非0断言     
     
8.    char *address = strDest;        
9.    while( (*strDest++ = * strSrc++) != '\0');        
10.    return address; //为了实现链式操作，将目的地址返回    
      
11. }  
12.   
13. 类似的我们还可以写出strlen函数的完美版本  
14. int strlen( const char *str ) //输入参数const
      
15. {  
16. 　assert( strt != NULL ); //断言字符串地址非0 
      
17. 　int len;  
18. 　while( (*str++) != '\0' )   
19. 　{   
20. 　　len++;   
21. 　}   
22. 　return len;  
23. }  

//得 10 分，基本上所有的情况，都考虑到了  
//如果有考虑到源目所指区域有重叠的情况，加 1 分！     
char * strcpy( char *strDest, const char *strSrc )//将源字符串加const，表明其为输入参数   
{     
   if(strDest == strSrc) 
       { return strDest; }  
   assert( (strDest != NULL) && (strSrc != NULL) );//对源地址和目的地址加非0断言     
   char *address = strDest;      
   while( (*strDest++ = * strSrc++) != '\0');      
   return address; //为了实现链式操作，将目的地址返回    
}

类似的我们还可以写出strlen函数的完美版本
int strlen( const char *str ) //输入参数const
{
　assert( strt != NULL ); //断言字符串地址非0
　int len;
　while( (*str++) != '\0' ) 
　{ 
　　len++; 
　} 
　return len;
}

关于字符串操作的库函数数有许多，我们可以参照上面的几点写出其它的字符串操作库函数的完美版本。