2014年10-16日中信网络以及欢聚时代笔试记录

最新推荐文章于 2021-07-24 14:57:03 发布

家在深圳

最新推荐文章于 2021-07-24 14:57:03 发布

阅读量582

点赞数

分类专栏：笔试题

本文链接：https://blog.csdn.net/hellen1900/article/details/40157409

版权

笔试题专栏收录该内容

15 篇文章 0 订阅

订阅专栏

上午在参加的中信网络的笔试，感觉不难，但是还是有些题目没做出来。

（1）数字推理题

（2）^ 和 <<的优先级哪个高

（3）数据库的题目

下午又参加某知名公司的笔试，题目感觉没有他们去年的难

（1）网络拓扑结构 ---> 通信子网

（2）父类和子类的关系，指针赋值，以及多态性和虚函数

大题一共六道

（1）线程同步和互斥有哪些方法，以及作用

（1）临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。

（2）互斥量：为协调共同对一共享资源的单独访问而设计。只有拥有互斥对象的线程才有权去访问系统的公共资源，

因为互斥对象只有一个，所以能能够保证资源不会同时被多个线程访问。互斥不仅能实现同一应用程先生的公共资源安全共享，还能实现不同应用程序的公共资源安全共享

（3）信号量：为控制一个具有有限数量的用户资源而设计。它允许多个线程在同一个时刻去访问同一个资源，但一般需要限制同一时刻访问此资源的最大线程数。

（4）事件：用来通知线程有一些事件已经发生，从而启动后继任务的开始。

生产者和消费者模型：

一个生产者，一个消费者，公用n个环形缓冲区：

定义两个同步信号量：

empty——表示缓冲区十分位空，初值为n。

full——表示缓冲区中是否为满，初值为0。

设缓冲区的编号是0 ~ n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，

指向下一个可用的缓冲区。

生产者进程：

while(true)
{
	生存一个产品;
	P(empty);  //empty = empty-1
	产品送往buffer(in);
	in = (in + 1) mod n;
	V(full);   //full = full + 1
}

消费者进程：

while(true)
{
	P(full);  //full = full -1
	从buffer(out)中取出产品；
	out = (out +1) mod n;
	V(empty);  //empty = empty + 1
	消费该产品
}

一组生产者和一组消费者，公用n个环形缓存区

可以理解成有多间牛奶生产厂家，如蒙牛，达能，光明等，消费者也不只小明一人，有许许多多消费者。不同的牛奶生产厂家生产的商品可以放在不同的好又多分店中销售，而不同的消费者可以去不同的分店中购买。当某一分店已放满某个厂家的商品时，下一个厂家只能把商品放在下一间分店。所以在这种情况中，生产者与消费者存在同步关系，而且各个生产者之间、各个消费者之间存在互斥关系,他们必须互斥地访问缓冲区。

解题如下：

定义四个信号量：

empty——表示缓冲区是否为空，初值为n。

full——表示缓冲区中是否为满，初值为0。

mutex1——生产者之间的互斥信号量，初值为1。

mutex2——消费者之间的互斥信号量，初值为1。

设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。

生产者进程

while(TRUE){

生产一个产品;

P(empty);

P(mutex1)；

产品送往buffer（in）；

in=(in+1)mod n；

V(mutex1);

V(full);

}

消费者进程

while(TRUE){

P(full);

P(mutex2)；

从buffer（out）中取出产品；

out=(out+1)mod n；

V（mutex2）；

V(empty);

（2）实现中序遍历

struct TreeNode
{
	int data;
	TreeNode* right;
	TreeNode* left;
};

void print(int val)
{
	printf("%d " , val);
}

//中序遍历递归
void InOrderTraverse(TreeNode* root)
{
	if (root != NULL)
	{
		InOrderTraverse(root->left);
		print(root->data);
		InOrderTraverse(root->right);
	}
}

//中序非递归遍历
void InOrderTraverse1(TreeNode* root)
{
	std::stack<TreeNode*> mystack;
	mystack.push(root);
	TreeNode* p = root;

	while(!mystack.empty())
	{
		while(mystack.top() && p)
		{
			p = p->left;
			mystack.push(p);
		}

		mystack.pop();   //null指针出栈
		
		if(!mystack.empty())
		{
			p = mystack.top();  //栈顶元素
			print(p->data);
			p = p->right;		//右子
			mystack.pop();		//出栈
			mystack.push(p);    //右子入栈
		}
	}
}

（3）实现快速排序

// 快速排序.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

int Partition(int data[], int start, int end)
{
	int key = data[start];  //支点

	while (start < end)
	{
		//从后向前遍历
		while(start < end && data[end]>=key) end--;
		if (start < end)
			data[start] = data[end];

		//从前往后遍历
		while(start < end && data[start]<= key) start++;
		if (start < end)
			data[end] = data[start];

		data[start] = key;  //这个地方容易搞错
	}

	return start;
}

void QuickSort(int data[], int start, int end)
{
	if (data == NULL || start < 0 || end < 0 )
		return;
	
	if (start <= end)
	{
		int index = Partition(data, start, end);
		QuickSort(data, start, index-1);
		QuickSort(data, index+1, end);
	}

}

void print(int data[], int len)
{
	for(int i = 0; i < len; i++)
		printf("%d ", data[i]);
	printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
	int data[] = {72};
	int len = sizeof(data)/sizeof(int);

	QuickSort(data, 0, len-1);
	print(data, len);

	return 0;
}

（4）忘了

（5）改错题，GetMemory(char* p) , 和前几次笔试的一样的题目啊。

（6）海量数据的题目：2.5亿一个有重复的数中，找出不重复的数，