IGT 2014年校园招聘笔试题

2014年9月26日

华科

1. 

#include <iostream>
using namespace std;

int main()
{
	int i = 4;
	double d = 5.0;

	cout<<sizeof(i < d ? i : d)<<endl;

	system("pause");
	return 0;
}

由于在i和d比较的时候，i会转换成double类型，所以输出为8.

2.

#include <iostream>
using namespace std;

class Base
{
public:
	virtual void output(int i=4)
	{
		cout<<"Base::output "<<i<<endl;
	}
};

class Derived : public Base
{
public:
	void output(int i=5)
	{
		cout<<"Derived::output "<<i<<endl;
	}
};

int main()
{
	Base *p;
	Derived d;
	p = &d;
	p->output();

	system("pause");
	return 0;
}

当通过基类指针（该基类指针指向派生类对象）调用虚函数的时候，且虚函数有默认参数值的时候，调用派生类的函数，如果不指定参数值，使用默认参数值的话，参数值使用基类的默认参数值。

3. 层次遍历二叉树

#include <iostream>
#include <deque>
using namespace std;

struct BinaryTreeNode
{
	int m_nValue;
	BinaryTreeNode *m_pLeft;
	BinaryTreeNode *m_pRight;
};

void PrintByLevel(BinaryTreeNode *pRoot)
{
	if (NULL == pRoot)
	{
		return ;
	}

	deque<BinaryTreeNode *> dq;

	dq.push_back(pRoot);

	while (dq.size() > 0)
	{
		BinaryTreeNode *pNode = dq.front();
		dq.pop_front();

		cout<<pNode->m_nValue<<endl;

		if (pNode->m_pLeft != NULL)
		{
			dq.push_back(pNode->m_pLeft);
		}

		if (pNode->m_pRight != NULL)
		{
			dq.push_back(pNode->m_pRight);
		}
	}
}

BinaryTreeNode* ConstructBinaryTreeCore(int *startPreOrder, int *endPreOrder, int *startInOrder, int *endInOrder)
{
	BinaryTreeNode *pRoot = new BinaryTreeNode;
	pRoot->m_nValue = startPreOrder[0];
	pRoot->m_pLeft = pRoot->m_pRight = NULL;

	if (startPreOrder == endPreOrder)
	{
		if (startInOrder == endInOrder && *startInOrder == *endInOrder)
		{
			return pRoot;
		}
		else
		{
			return NULL;
		}
	}
	
	int *current = startInOrder;

	while (current <= endInOrder && *current != startPreOrder[0])
	{
		current++;
	}

	if ((current - startInOrder) > 0)
	{
		pRoot->m_pLeft = ConstructBinaryTreeCore(startPreOrder+1, startPreOrder+(current - startInOrder), startInOrder, current-1);
	}

	if ((endInOrder - current) > 0)
	{
		pRoot->m_pRight = ConstructBinaryTreeCore(startPreOrder+(current - startInOrder)+1, endPreOrder, current+1, endInOrder);
	}

	return pRoot;
}

BinaryTreeNode* ConstructBinaryTree(int preOrder[], int inOrder[], int n)
{
	if (n <= 0)
	{
		return NULL;
	}

	return ConstructBinaryTreeCore(preOrder, preOrder+n-1, inOrder, inOrder+n-1);
}

int main()
{
	int preOrder[7] = {1, 2, 4, 5, 3, 6, 7};
	int inOrder[7] = {4, 2, 5, 1, 6, 3, 7};

	BinaryTreeNode *pRoot;

	pRoot = ConstructBinaryTree(preOrder, inOrder, 7);

	PrintByLevel(pRoot);

	system("pause");
	return 0;
}