Microsoft经典面试题集锦

一 检查字符串是否为整数，是则输出该整数

#include <iostream>
#include <string>
#include <cctype>

using namespace std;

const int max = 10;
bool checkNum(string &str) {
	string::iterator it;
	int i;
	long s = 0;
	for(it = str.begin(), i = 0; it != str.end() && i < max; i++, it++) {
		if(!isdigit(*it)) return false;
		s = s*10 + (*it) - '0';
	}
	if(i >= max) {
		cerr<<"整数溢出!"<<endl;
	}
	cout<<str<<"对应的整数是:"<<s<<endl;
	return true;
}

void main() {
	string str;
	cin>>str;
	if(!checkNum(str)) {
		cerr<<str<<"不是整数"<<endl;
	}
}

二 在排序好的整数数组中查找给定数出现的次数

#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <ctime>

using namespace std;

#define ERROR -1
const int M = 1000;
class Solution {
private:
	int N;
	vector<int>v;

	int BinaryLocate(int low, int high, int x) {
		int mid = (low + high) / 2;
		if(low <= high) {
			if(v[mid] == x) return mid;
			else if(v[mid] > x) return BinaryLocate(low, mid-1, x);
			else return BinaryLocate(mid+1, high, x);
		}
		else return ERROR;
	}
public:
	Solution(int n) {
		if(n <= 0 || n > M) {
			cerr<<"参数错误, 程序退出!"<<endl;
			exit(1);
		}
		N = n;
		int i;
		srand(unsigned(time(0)));
		for(i = 0; i< N; i++) {
			int x = rand() % N;
			v.push_back(x);
		}
		sort(v.begin(), v.end());
		copy(v.begin(), v.end(), ostream_iterator<int>(cout," "));
	}

	int JustDoIt(const int e) {
		int i = BinaryLocate(0, v.size() - 1, e);
		if(i < 0) {
			cerr<<"不能找到"<<e<<endl;
			return ERROR;
		}
		int cnt =1;
		int j = i;
		/*
		 * j指向第一次出现v[i]的位置,如 1 3 3 3 4 5 6
		 * j会指向位置1
		*/
		while(j > 0 && v[j] == v[j-1]) j--;
		i = j;
		while(i < v.size() -1 && v[i] == v[i+1]) {
			cnt++;
			i++;
		}
		return cnt;
	}
};

void main() {
	int N = 20;
	Solution s(N);
	int e;
	cout<<"请输入0到"<<N-1<<"之间的整数:"<<endl;
	cin>>e;
	if(!cin.good()) {
		cerr<<"输入错误!"<<endl;
		exit(1);
	}
	int cnt = s.JustDoIt(e);
	if(cnt != ERROR) {
		cout<<e<<"出现的次数为:"<<cnt<<endl;
	}
}

三 平面上N个点，每两个点都确定一条直线，求出斜率最大的那条直线所通过的两个点（斜率不存在的情况不考虑）。

#include <iostream>
#include <cstdlib>
#include <vector>
#include <algorithm>

using namespace std;

const double min = - 99999;   // 当两个点的横坐标相同时, 它们的斜率为min

const double minNum = -10000;  // 最小的数
const double maxNum = 10000;  // 最大的数

class Point {
public:
	double x;
	double y;
	Point(double X = 0, double Y = 0) {
		x = X;
		y = Y;
	}
	bool operator < (const Point & p) {
		return x < p.x;
	}
	friend ostream operator <<(ostream &os, const Point &point) {
		os<<"["<<point.x<<","<<point.y<<"]"<<endl;
		return os;
	}
};

/*
 * 先对点向量按横坐标排序, 然后计算排序后相邻点的斜率
*/

class Solution {
private:
	vector<Point>v;   // 点向量
	int n;            // 点的个数     
	double maxK;      // 最大的斜率
public:
	Solution(int N) {
		if(N <= 0) {
			cerr<<"参数不合法, 程序退出!"<<endl;
			exit(1);
		}
		n = N;
		int i;
		double x, y;
		for(i = 0; i < n; i++) {
			cout<<"第"<<i<<"个点:"<<endl;
			cin>>x>>y;
			if(!cin.good()) {
				cout<<"输入不合法, 程序退出!"<<endl;
				exit(1);
			}
			if(x < minNum || x > maxNum) {
				cerr<<"参数不合法, 程序退出!"<<endl;
				exit(1);
			}
			if(y < minNum || y > maxNum) {
				cerr<<"参数不合法, 程序退出!"<<endl;
				exit(1);
			}
			Point p = Point(x, y);
			v.push_back(p);
		}
		maxK = 0;
	}
	void JustDoIt() {
		sort(v.begin(), v.end());     // 按点的横坐标x快速升序排序
		int len = n - 1;
		double *k = new double(len);    // 斜率数组

		int i;
		for(i = 0; i < n-1; i++) {
			k[i] = slop(v[i], v[i+1]);      // 求出相邻两个点的斜率
		}
		maxK = *max_element(k, k + len);      // 求出数组k中最大值
		i = max_element(k, k + len) - k;	    // 求出数组k中最大值的索引
		showmaxK();

		cout<<v[i];                         // 求出哪两个点的斜率最大
		cout<<v[i+1];
	}
	double slop(const Point& start, const Point& end) {
		if(end.x - start.x == 0) return min;
		return 1.0 * (end.y - start.y) / (end.x - start.x);
	}
	void showV() {
		vector<Point>::iterator it;
		for(it = v.begin(); it != v.end(); it++) {
			cout<<*it;
		}
	}
	void showmaxK() {
		cout<<"最大斜率是:"<<maxK<<endl;
	}
};

void main() {
	Solution s(10);
	s.JustDoIt();
}

测试：

四一个整数数列，元素取值可能是0~65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。
请设计一个算法，当你从该数列中随意选取5个数值，判断这5个数值是否连续相邻。
注意：
- 5个数值允许是乱序的。比如： 8 7 5 0 6
- 0可以通配任意数值。比如：8 7 5 0 6 中的0可以通配成9或者4
- 0可以多次出现。
- 复杂度如果是O(n2)则不得分。

#include <iostream>
#include <cstdlib>
#include <vector>
#include <ctime>
#include <algorithm>

using namespace std;

const int Max = 65535;
class Solution {
private:
	vector<int>v;
	vector<int>selection;
	int n;
	int m;
public:
	Solution(int N) {
		if(N <= 0) {
			cerr<<"参数不合法, 程序退出!"<<endl;
			exit(1);
		}
		if(!cin.good()) exit(1);
		n = N;
		int i;
		srand(unsigned(time(NULL)));
		for(i = 0; i < n; i++) {
			int e = rand() % Max;
			if(v.empty() == true) v.push_back(e);
			else if(e == 0) {  
				v.push_back(e);
			}
			else if(find(v.begin(), v.end(), e) == v.end())  {
				v.push_back(e);
			}
		}
	}
	/*
	 * 随机选择M个整数
	*/
	void RandomSelectM(int M) {
		if(M <= 0) {
			cerr<<"参数不合法, 程序退出!"<<endl;
			exit(1);
		}
		if(!cin.good()) exit(1);
		m = M;
		srand(unsigned(time(NULL)));
		int i = 0;
		int j;
		while(i < m) {
			j = rand() % v.size();               //随机产生一个索引号
			if(selection.empty() == true) {
				selection.push_back(v[j]);
				i++;
			}
			/*
			 * 刚随机选择的数之前没有选择过
			*/
			else if(find(selection.begin(), selection.end(), v[j]) == selection.end()) {
				selection.push_back(v[j]);
				i++;
			}
		}
	}
	
	void IsSequence() {
		int Max = *max_element(selection.begin(), selection.end());    // 找到数组中最大值
		int Min = *min_element(selection.begin(), selection.end());
		if(Max - Min <= m - 1) {
			cout<<"这"<<m<<"个整数连续"<<endl;
		}
		else cout<<"这"<<m<<"个整数不连续"<<endl;
	}
	void show() {
		vector<int>::iterator it;
		cout<<"这"<<n<<"个数是:";
		for(it = v.begin(); it != v.end(); it++) {
			cout<<*it<<" ";
		}
		cout<<endl;
		cout<<"从这"<<n<<"个数中选择"<<m<<"个数是:";
		for(it = selection.begin(); it != selection.end(); it++) {
			cout<<*it<<" ";
		}
		cout<<endl;
	}
};
void main() {
	Solution s(10);
	s.RandomSelectM(5);
	s.show();
	s.IsSequence();
}

五 设计一个算法，找出二叉树上任意两个结点的最近共同父结点。复杂度如果是O(n2)则不得分。

#include <iostream>
#include <cstdlib>
#include <string>

using namespace std;

template<class T>
/*
 * 二叉树结点类
*/
class BinNode {
	public:
		T data;
		BinNode<T>*lchild;
		BinNode<T>*rchild;
		BinNode<T>(T e =NULL, BinNode<T>*left = NULL, BinNode<T>*right = NULL) {
			data = e;
			lchild = left;
			rchild = right;
		}
		BinNode<T>(const BinNode<T> &binNode) {
			data = binNode.data;
			lchild = binNode.lchild;
			rchild = binNode.rchild;
		}
		BinNode<T> operator = (const BinNode<T> &binNode) {
			data = binNode.data;
			lchild = binNode.lchild;
			rchild = binNode.rchild;
			return *this;
		}
};

/*
 * 二叉树类
*/
template<class T>
class BinTree {
	private:
		BinNode<T>*root;       // 二叉树根结点指针
		BinNode<T>*result;     // 最近公共父结点指针

		/*
		 * 递归构造二叉树 
		*/
		void CreateBinTree(BinNode<T>*&p) {
			T data;
			cin>>data;
			if(data != "#") {
				p = new BinNode<T>(data);
				CreateBinTree(p->lchild);
				CreateBinTree(p->rchild);
			}
		}
		/*
		 * 前序遍历二叉树
		*/
		void Tranvser(BinNode<T>*p) {
			if(p != NULL) {
				cout<<p->data<<" ";
				Tranvser(p->lchild);
				Tranvser(p->rchild);
			}
		}
		bool NearestParent(BinNode<T>*root, BinNode<T>*parent, BinNode<T>*&result, const T&a, const T&b) {
			/*
			 * left = true 表示a或b在当前结点的左子树中
			*/
			bool left = false;       
			/*
			 * right = true 表示a或b在当前结点的右子树中
			*/
			bool right = false;
			/*
			 * 从当前结点的左子树返回后, left = true表示a或b在它的左子树中
			*/
			if(!result && root->lchild) left = NearestParent(root->lchild, root, result, a, b);
			/*
			 * 从当前结点的右子树返回后, right = true表示a或b在它的右子树中
			*/
			if(!result && root->rchild) right = NearestParent(root->rchild, root, result, a, b);
			/*
			 * cur = true 表示a或b就是当前正在访问的结点
			*/
			bool cur = false;

            // 当root指向的当前结点是a或b时
			if(root->data == a || root->data == b) {
				cur = true;
			}
			// 此时a和b位于同一分支或者a和b位于不同分支
			if(!result && cur + left + right == 2) {
				if(cur == true) {      // 此时a和b同时位于左分支或右分支
					result = parent;
				}
				else result = root;
			}
			return left | right | cur;
		}
	public:
		BinTree() {
			root = NULL;
			CreateBinTree(root);
		}
		void Tranvser() {
			Tranvser(root);
		}
		void NearestParent(const T&a, const T&b) {
			result = NULL;
			NearestParent(root, NULL, result, a, b);
		}
		void getResult() {
			cout<<result->data<<endl;
		}
};

void main() {
	BinTree<string>binTree;
	cout<<"输入的二叉树是:";
	binTree.Tranvser();
	cout<<endl;
	string a, b;
	cout<<"请输入两个结点值:";
	cin>>a>>b;
	binTree.NearestParent(a, b);
	binTree.getResult();
	cout<<a<<"和"<<b<<"最近公共父结点是:";
	binTree.getResult();
}

测试：

六 一棵排序二叉树，令 f=(最大值+最小值)/2， 设计一个算法，找出距离f值最近、大于f值的结点。

#include <iostream>
#include <cstdlib>

using namespace std;

template<class T>
class BSTNode {
	public:
		T data;
		BSTNode<T>*lchild;
		BSTNode<T>*rchild;

		BSTNode(const T &e, BSTNode<T>*left = NULL, BSTNode<T>*right = NULL) {
			data = e;
			lchild = left;
			rchild = right;
		}

		BSTNode(const BSTNode<T> &bst) {
			data = bst.data;
			lchild = bst.lchild;
			rchild = bst.rchild;
		}

		BSTNode<T>& operator =(const BSTNode<T> &bst) {
			data = bst.data;
			lchild = bst.lchild;
			rchild = bst.rchild;
			return *this;
		}
};

template<class T>
class BST {
	friend class Solution;
	private:
		BSTNode<T>*root;
		int N;
		/*
		 * 后序遍历
		*/
		void tranverseBST(BSTNode<T>*root) {
			if(root) {
				tranverseBST(root->lchild);
				cout<<root->data<<" ";
				tranverseBST(root->rchild);
			}
		}
		/*
		 * 插入结点
		*/
		void insertBST(BSTNode<T>*&root, const T& e) {
			if(root == NULL) {
				root = new BSTNode<T>(e);
			}
			else if(e >= root->data) {
				insertBST(root->rchild, e);
			}
			else insertBST(root->lchild, e);
		}

	public:
		BST() {
			root = NULL;
		}

		void createBST(int n) { 
			if(n <= 0) {
				cerr<<"参数错误, 程序退出!";
				exit(1);
			}
			int i;
			T e;
			for(i = 0; i < n; i++) {
				cout<<"请输入第"<<i<<"个值:";
				cin>>e;
				insertBST(root, e);
			}
		}
		void tranverseBST() {
			tranverseBST(root);
		}
};

class Solution {
private:
	BST<double>bst;
	double max;
	double min;
	double f;
	bool find;
	BSTNode<double>*result;

	void Setmax(BSTNode<double>*node) {
		while(node->rchild) {
			node = node->rchild;
		}
		max = node->data;
	}

	void Setmin(BSTNode<double>*node) {
		while(node->lchild) {
			node = node->lchild;
		}
		min = node->data;
	}

	void Setf() {
		f = (min + max)/2;
	}

	void Setresult(BSTNode<double>*node) {
		if(node) {
			if(find == false) { 
				Setresult(node->lchild);
			}
			if(find == false && node->data > f) {
				result = node;
				find = true;

			}
			if(find == false) {
				Setresult(node->rchild);
			}
		}
	}
public:
	Solution(int n):max(0), min(0), result(NULL), find(false) {
		bst.createBST(n);

	}

	void JustDoIt() {
		Setmax(bst.root);
		Setmin(bst.root);
		Setf();
		Setresult(bst.root);
	}
	void show() {
		cout<<"最大值是:"<<max<<endl;
		cout<<"最小值是:"<<min<<endl;
		cout<<"中值是:"<<f<<endl;
		cout<<"最接近中值的结点是:"<<result<<endl;
		cout<<"最接近中值的值是:"<<result->data<<endl;
	}
};

void main() {
	Solution s(6);
	s.JustDoIt();
	s.show();
}

测试：