2012联发科技（合肥）招聘

联发科技（合肥公司）于2011年9月14号在合肥工业大学宣讲然后笔试的，当时一共要招80人的软件研发工程师，在合工大招24人吧。笔试题目量不大，一个半小时足够的。

选择题：

都是最基本的知识，c++语法、数据结构、软件工程、操作系统都有涉及，一般错一两个差不多。

简答题：

1.      不用if、三元条件表达式实现两个数的比较大小。

[a+b+abs(a-b)]/2;

2.      求一个整数的二进制表示数中1的个数。

int func(x)
{
	int countx = 0;
	while(x)
	{
		countx ++;
		x = x&(x-1);
	}
	return countx;
} 

3.      Singleton模式实例。

第一种形式：
public class Singleton
{
private Singleton(){}
// 注意这是private只供内部调用
private static Singleton instance = new Singleton();

// 这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance()
{
return instance;
}
}
第二种形式：
public class Singleton
{
private static Singleton instance = null;
public static synchronized Singleton getInstance()
{
    If(instance == null)
        Instance = new Singleton();
    return instance;
}
}

4.      重写和重载的区别。

从定义上来说，重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。重写：是指子类重新定义父类虚函数的方法。

从实现原理上来说，

重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和functionfunc(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

算法题：

1.      链表的反向、合并。

struct Node
{
	int data ;
	Node *next ;
};
typedef struct Node Node;

(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)
Node * ReverseList(Node *head) //链表逆序
{
	if ( head == NULL || head->next == NULL )
		return head;
	Node *p1 = head ;
	Node *p2 = p1->next ;
	Node *p3 = p2->next ;
	p1->next = NULL ;
	while ( p3 != NULL )
	{
		p2->next = p1 ;
		p1 = p2 ;
		p2 = p3 ;
		p3 = p3->next ;
	}
	p2->next = p1 ;
	head = p2 ;
	return head ;
}
(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）
Node * Merge(Node *head1 , Node *head2)
{
	if ( head1 == NULL)
		return head2 ;
	if ( head2 == NULL)
		return head1 ;
	Node *head = NULL ;
	Node *p1 = NULL;
	Node *p2 = NULL;
	if ( head1->data < head2->data )
	{
		head = head1 ;
		p1 = head1->next;
		p2 = head2 ;
	}
	else
	{
		head = head2 ;
		p2 = head2->next ;
		p1 = head1 ;
	}
	Node *pcurrent = head ;
	while ( p1 != NULL && p2 != NULL)
	{
		if ( p1->data <= p2->data )
		{
			pcurrent->next = p1 ;
			pcurrent = p1 ;
			p1 = p1->next ;
		}
		else
		{
			pcurrent->next = p2 ;
			pcurrent = p2 ;
			p2 = p2->next ;
		}
	}
	if ( p1 != NULL )
		pcurrent->next = p1 ;
	if ( p2 != NULL )
		pcurrent->next = p2 ;
	return head ;
}
(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。 (Autodesk)
答案：
Node * MergeRecursive(Node *head1 , Node *head2)
{
	if ( head1 == NULL )
		return head2 ;
	if ( head2 == NULL)
		return head1 ;
	Node *head = NULL ;
	if ( head1->data < head2->data )
	{
		head = head1 ;
		head->next = MergeRecursive(head1->next,head2);
	}
	else
	{
		head = head2 ;
		head->next = MergeRecursive(head1,head2->next);
	}
	return head ;
}

2.      判断单链表中是否存在环路。

struct node { char val; node* next;}
bool check(const node* head) {}

//return false : 无环；true: 有环
//一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：
bool check(const node* head)
{
	if(head==NULL) return false;
	node *low=head, *fast=head->next;
	while(fast!=NULL && fast->next!=NULL)
	{
		low=low->next;
		fast=fast->next->next;
		if(low==fast) return true;
	}
	return false;
}

3.      二分查找方法的递归与非递归实现。

(各种数据结构书籍上都有，最基本的)