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

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

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

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 的指针。

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

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

5、面试中如问到memcpy的实现，那就要小心了，这里有陷阱。先看下标准memcpy()的解释：注意下面的注释，对于地址重叠的情况，该函数行为是未定义的。事实上所说的陷阱也在于此，自己动手实现memcpy()时就需要考虑地址重叠的情况。

另外，标准库也提供了地址重叠时的内存拷贝函数：memmove()，那么为什么还要考虑重写memcpy()函数呢?因为memmove()函数的实现效率问题，该函数把源字符串拷贝到临时buf里，然后再从临时buf里写到目的地址，增加了一次不必要的开销。

void* Memcpy(void *dst, const void *src, size_t size)//size_t它是一个与机器相关的unsigned类型，其大小足以保证存储内存中对象的大小。
{                                                    //注意形参类型和返回值类型都是void*
    char *psrc;
    char *pdst;
        
    if(NULL == dst || NULL == src)//要注意对传入的形参进行检查
    {
        return NULL;
    }
        
    if((src < dst) && (char *)src +size > (char *)dst) // 内存重叠时要注意自后向前拷贝
    {
        psrc = (char *)src + size - 1;
        pdst = (char *)dst + size - 1;
        while(size--)
        {
            *pdst-- = *psrc--;
        }
    }
    else
    {
        psrc = (char *)src;
        pdst = (char *)dst;
        while(size--)
        {
            *pdst++ = *psrc++;
        }
    }
        
    return dst;
}

6、编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

class String
{
　public:
　　String(constchar *str = NULL); // 普通构造函数
　　String(constString &other); // 拷贝构造函数
　　~String(void); // 析构函数
　　String& operate =(const String &other); // 赋值函数
　private:
　　char*m_data; // 用于保存字符串
};

//普通构造函数
String::String(const char *str) 
{
　if(str==NULL) 
　{
　　m_data = new char[1];  //得分点：对空字符串自动申请存放结束标志'\0'的空
　　                      //加分点：对m_data加NULL 判断
　　*m_data = '\0'; 
　} 
　else
　{
　　int length = strlen(str); 
　　m_data = new char[length+1]; // 若能加 NULL 判断则更好 
　　strcpy(m_data, str); 
　}
}

// String的析构函数
String::~String(void) 
{
　delete [] m_data;  // 或delete m_data;
}

//拷贝构造函数
String::String(const String &other) 　　　// 得分点：输入参数为const型
{ 
　int length = strlen(other.m_data); 
　m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断
　strcpy(m_data, other.m_data); 
}

//赋值函数
String & String::operate =(const String &other) // 得分点：输入参数为const型
{ 
　if(this == &other) 　　//得分点：检查自赋值
　　return *this; 
　delete [] m_data; 　　　　//得分点：释放原有的内存资源
　int length = strlen( other.m_data ); 
　m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断
　strcpy( m_data, other.m_data ); 
　return *this; 　　　　　　　　//得分点：返回本对象的引用
}

剖析：

能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！
在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。
仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基本功！

7、输入一个表示整数的字符串，把该字符串转换成整数并输出。例如输入字符串"1234"，则输出整数1234。

enum Status {kValid=0,kInvalid};
int g_nStatus = kValid;

int StrToInt(const char *str)
{
	g_nStatus = kInvalid;
	long num = 0;

	if(str != NULL)
	{
		const char *digit = str;
		bool minus = false;
   
        //第一个字符可能是'+'或'-'
		if(*digit == '+')
			digit++;
		else if(*digit == '-')
		{
			digit++;
			minus = true;
		}
        
        //处理余下的字符
		while(*digit != '\0')
		{
			if(*digit>='0' && *digit<='9')
			{
				num = num*10 + (*digit - '0');

				if(num > std::numeric_limits<int>::max())
				{
					num = 0;
					break;
				}

				digit++;
			}
			else   //如果字符不是数字，则是无效的输入
			{
				num = 0;
				break;
			}
		}

		if(*digit == '\0')
		{
			g_nStatus = kValid;
			if(minus)
				num = 0 - num;
		}
	}
	return static_cast<int>(num);
}