【面试】Dell

　　昨天去了慕名已久的Dell面试（Dell自2015年退出了世界500强的评比），一面基本合格，二面基本没答上。。。

　　对公司的整体印象非常好（每个人桌上都有两台很大的显示器；9：00-15：30，如果能完成任务还不需要严格遵守作息时间；茶水间有微波炉、烤箱、冰箱等）。下面简单记录下招聘会流程。

招聘会流程：

　　调查问卷：几道选择题，包括应聘职位、意向部门、获取Dell招聘信的渠道等。

　　笔试：全英文共40分钟，主要靠基本功。题型和分值如下：

　　　　　　单选题5'*5，

　　　　　　写输出结果（当天考的线程await和async），

　　　　　　编程题40‘：用Array实现Stack，用到设计模式有额外加分（此题的关键是用泛型T实现一个Node类，类中包含一个T字段，指向上一个节点的引用和指向下一个节点的引用）

　　　　　　算法题30’：一个含99个元素的int数组，数组元素值范围是1-100中不重复的数，要求写出查找缺失元素的最优时间复杂度算法和最优空间复杂度的算法。~~o(>_<)o ~~，没有复习这一块，加上毕业这么久，数据结构和算法全还给老师了，写了个错的答案，回头复习下再补充。

　 一面：一面是资深员工面试。一般问些很基础的问题，如：值类型和应用类型的区别和应用场景,C#从SQL Server读取数据的流程，实体框架，SQL的join和union，设计模式等。

　　二面：二面师部门Leader面试，先要求做自我介绍（PS：面试官很忙，以致于简历他只会扫一眼，所以一些简历上的内容需要口述一遍）；然后是介绍一个自己参与比较多的项目，介绍自己的工作，面试官会从项目的核心技术点出发提问，主要有微软的测试工具、数据库优化工具、分布式、多线程，我基本答不上来，面试官还是都指点了一下。完了，说映像不错，让等（wei）通（tong）知（guo）。

　　C#实现栈和队列，原文地址：http://www.cnblogs.com/mycom/archive/2013/03/24/Csharpcustomstackandqueue.html

C#实现简单的栈和队列

C#提供了栈和队列，我们自己也可以尝试简单实现。
而且这可以作为一个很好的面试题，主要考察c#基础、类的设计以及数据结构。根据不同的职位需求可以考察选择不同的考察难度和角度。4年前我第一次参加面试并进现在的公司，职位基本是公司的最低岗位了。当时面的题目就是：实现一个栈。

简单的实现如下（考虑到顺序结构实现队列比较麻烦，采用链式结构）：
PS：感谢@LoveZmJ的提醒，下面的代码有个bug，对Test有兴趣的人可以先不要看评论，玩玩“大家来找茬”~~

首先是结点类的实现：

// 结点类
// 注意应该使用泛型
public class MyNode<T>
{
// 存储的数据
public T Data
{
get { return _data; }
set { _data = value; }
}

// 指向下一个结点
public MyNode<T> next { get { return _next; } set { _next = value; } }

//构造函数，不提供无参版本
public MyNode(T data)
{
_data = data;
_next = null;
}

// 私有字段
private T _data;
private MyNode<T> _next;
}

然后抽象一个简单的父类：

// 为栈和队列提取一些通用的成员，抽象出一个父类，此处用接口还是抽象函数？
// 在C#中Stack和Queue继承自两个接口：IEnumerable<T>, ICollection
// 但是作为简单的实现（特别是作为面试题答案），还是写成抽象类比较好，原因有二：
// 1. 可以在抽象类中实现一些通用方法，子类只需要继承就可以直接用，可以简化代码
// 2. 抽象出来的父类，和子类Stack、Queue可以看做“is-a”的关系。
// 当然也可以是非抽象的普通类，但是处于“不能实例化”的考虑，应该是抽象的
// 注意使用泛型
public abstract class AbstactList<T>
{
// 头结点，其后才是第一个结点
// 注意应该是protected，对外是不可见的
protected MyNode<T> Header { get; set; }
// 尾结点，即是最后一个结点
protected MyNode<T> Tail { get; set; }
// 当前结点个数，注意是只读属性
public int NoteCount { get { return _noteCount; } }

// 构造函数，初始化头结点和结点个数
public AbstactList()
{
// 注意此处default(T)的使用
Header = new MyNode<T>(default(T));
Tail = Header;
_noteCount = 0;
}

// “出的操作”，对于栈和队列都是一样的，所以可以写在父类里
// 注意应该从“头”端出，时间复杂度为O（1）
// 如果从“尾”端出，则会造成时间复杂度为O（n）
protected T Out()
{
// 注意判空，只要一个条件就可以了，将所有的条件都写在这里可以有利于在测试的时候检测出bug
if (Header.next == null && _noteCount == 0 && NoteCount == 0 && IsEmpty())
{
throw new InvalidOperationException("Is empty!");
}

MyNode<T> outNode = Header.next;
Header.next = Header.next.next;
_noteCount--;
return outNode.Data;
}

// 判空
public bool IsEmpty()
{
return _noteCount == 0 ? true : false;
}

// 对于“出”的操作，栈和队列是有区别的，所以申明成抽象方法
// 到子类中去具体实现
protected abstract void In(T NodeData);

// 子类中还要用到，所以是Protected
protected int _noteCount;
}

栈的具体实现：

// 栈的实现，继承自抽象类
public class MyStack<T> : AbstactList<T>
{
// 实现“进”的方法，在“头”端
// 由于实现抽象类方法的当前方法默认是虚的，所以无法设为private
protected override void In(T NodeData)
{
MyNode<T> Node = new MyNode<T>(NodeData);
Node.next = Header.next;
Header.next = Node;
_noteCount++;
}

// 进栈，只是将操作改个名字
public void Push(T NodeData)
{
In(NodeData);
}

// 出栈，只是将操作改个名字
public T Pop()
{
return Out();
}
}

队列的实现：

// 队列的实现，继承自抽象类
public class MyQueue<T> : AbstactList<T>
{
// 实现“进”的方法，在“尾”端
// 由于实现抽象类方法的当前方法默认是虚的，所以无法设为private
protected override void In(T NodeNode)
{
MyNode<T> Node = new MyNode<T>(NodeNode);
Tail.next = Node;
Tail = Node;
_noteCount++;
}

public void EnQue(T NodeData)
{
In(NodeData);
}

public T DeQue()
{
return Out();
}
}

单元测试：

对栈和队列的单元测试
[TestClass]
public class UnitTest1
{
[TestMethod]
public void StackTest()
{
MyStack<char> charStack = new MyStack<char>();
Assert.IsTrue(charStack.IsEmpty());
charStack.Push('a');
Assert.IsFalse(charStack.IsEmpty());
charStack.Push('b');
Assert.AreEqual(charStack.Pop(), 'b');
charStack.Push('c');
Assert.AreEqual(charStack.NoteCount,2);
Assert.AreEqual(charStack.Pop(), 'c');
Assert.AreEqual(charStack.Pop(), 'a');
Assert.IsTrue(charStack.IsEmpty());

try
{
charStack.Pop();
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex,typeof(InvalidOperationException));
}
}

[TestMethod]
public void QueueTest()
{
MyQueue<int> intQueue = new MyQueue<int>();
Assert.IsTrue(intQueue.IsEmpty());
intQueue.EnQue(1);
intQueue.EnQue(2);
Assert.AreEqual(intQueue.DeQue(), 1);
intQueue.EnQue(3);
Assert.AreEqual(intQueue.NoteCount,2);
Assert.AreEqual(intQueue.DeQue(), 2);
Assert.AreEqual(intQueue.DeQue(), 3);
Assert.IsTrue(intQueue.IsEmpty());

try
{
intQueue.DeQue();
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(InvalidOperationException));
}
}
}