C#公司面试题，和基础感觉也很实用，分享下。顺便给自己打下分数

   前天去面试的时候先做笔试，卷子上面写着“初级程序员面试题”，一共8道题。如下：

    1 这个较简单就不说了。为了题目的完整性还是写下来.  列举C#.NET的基本数据类型

    2   解释泛型

    3  写一个你认为最简单的递归。（例如1，1，2，3，5，8，13，21，34）

    4  写一个简单链表

    5  描述一个常用的设计模式

    6  为数据库修改操作建立触发器，一般要建立几个，简单描述。

    学生成绩管理，有3个表
    S(SNO,SNAME)学生关系。SNO为学号，SNAME为姓名。

    C(CNO,CNAME,CTEACHER)课程关系。CNO为课程号，CNAME为课程名称，CTEACHER为任课教师。

    SC(SNO,CNO,SCGRADE)选课关系。SCGRADE为成绩。

    7  查出所有，2科成绩超过60分的学生姓名，以及各科成绩？

    8  查出所有没选任课老师为莉莉的学生的各科成绩。

34 个解决方案

#1

上面写着初级程序员，当然也希望一些牛人，写出你们的答案，大家参考参考。
说下自己的感受，

就是第4个较麻烦，上大学时候就是数据结构中接触链表，后来一直没有用， 这个题估计我是0分了，这个重点关注，

 再就是设计模式，常见的我知道3，4个，可是感觉自己不能真正的表达清楚。

#2

难道没有人看这个吗？ 奇怪的很。

#3

不奇怪只是你太早了...

#4

不错，只要你基础牢靠，应该还可以解决所有问题

#5

泛型是 C# 语言和公共语言运行库 (CLR) 中的一个新功能。泛型将类型参数的概念引入 .NET Framework，类型参数使得设计如下类和方法成为可能：这些类和方法将一个或多个类型的指定推迟到客户端代码声明并实例化该类或方法的时候。例如，通过使用泛型类型参数 T，您可以编写其他客户端代码能够使用的单个类，而不致引入运行时强制转换或装箱操作的成本或风险

#6

 private int funAA(int k)
        {
            int answer=0;
            if (k > 0)
            {
                if (k == 1 || k == 2)
                {
                    answer = 1;
                }
                else
                {
                    answer = funAA(k - 1) + funAA(k - 2);
                }
            }
            return answer;
        }

#7

 4 写一个简单链表
以下是一个简单的例子
-----------------

举个简单的例子： 
public   class   Node   { 
    public   String   name; 
    public   Node   next; 
    public   void   print()   { 
        Console.Write(Name); 
        if   (next   !=   null)   { 
            Console.Write( "   -->   "); 
            next.print(); 
        } 
    } 
} 

public   static   void   testmethod()   { 
    Node   root   =   new   Node(); 
    root.Name   =   "root "; 
    Node   node   =   root; 
    for   (int   i   =   0;   i   <   10;   i++)   { 
        Node   next   =   new   Node(); 
        next.Name   =   "next "   +   i; 
        node.next   =   next; 
        node   =   next; 
    } 
    root.print(); 
}

--------------------
5 6 7 8就不用说了吧
如果还是回答不起 LZ再找我  但是5-8属于最基础的 我想LZ还是会的吧

#8

确实都不难

#9

那里的公司啊？

#10

写个简单的链表：

#include<stdio.h>
#include<malloc.h>

#define DataType int

typedef struct tagLinkedListNode
{
	DataType data;
	struct tagLinkedListNode *next;
} LinkedListNode;

typedef LinkedListNode Node;

Node *createList();
int length(Node*);
int appendNode(Node*,DataType);
int insertNode(Node*,int,DataType);
int deleteNode(Node*,int);
int update(Node*,int,DataType);
Node *getNode(Node*,int);
int indexOf(Node*,DataType);

int main()			//测试程序
{
	Node *head=createList();    //创建链表

	appendNode(head,0);         //添加元素
	appendNode(head,2);
	appendNode(head,3);
	appendNode(head,4);
	printf("length:%d\n",length(head));  //求长度
	printf("data at index 1:%d\n",getNode(head,1)->data);   //取元素

	insertNode(head,1,1);       //插入元素
	printf("length:%d\n",length(head));
	printf("data at index 1:%d\n",getNode(head,1)->data);

	if(deleteNode(head,3))      //删除元素
	{
		printf("length:%d\n",length(head));
		printf("data at index 3:%d\n",getNode(head,3)->data);
	}

	if(update(head,2,10))       //修改元素
	{
		printf("length:%d\n",length(head));
		printf("the first index of data 10:%d\n",indexOf(head,10));   //查询元素下标
		printf("the first index of data 3:%d\n",indexOf(head,3));
	}

	return(0);
}

Node *createList()
{
	Node *head=(Node*)malloc(sizeof(Node));

	if(head)
		head->next=NULL;

	return(head);
}

int length(Node *head)
{
	int count=0;

	if(head)
		for(;head->next;head=head->next,count++);

	return(count);
}

int appendNode(Node *head,DataType data)
{
	Node *node=(Node*)malloc(sizeof(Node));

	if(head && node)
	{
		while(head->next)
			head=head->next;

		head->next=node;
		node->data=data;
		node->next=NULL;

		return(-1);
	}

	return(0);
}

int insertNode(Node *head,int index,DataType data)
{
	int len=length(head);
	register int i;
	Node *node=(Node*)malloc(sizeof(Node));

	if(!node||!len||index<0||index>len)
		return(0);

	for(i=0;i<index;i++)
		head=head->next;

	node->data=data;
	node->next=head->next;
	head->next=node;

	return(-1);
}

int deleteNode(Node *head,int index)
{
	Node *pNode;
	register int i;

	if(index<0||index>length(head)-1)
		return(0);

	head=head->next;
	for(i=0;i<index-1;i++)
		head=head->next;

	pNode=head->next;
	head->next=pNode->next;

	free(pNode);

	return(-1);
}

int update(Node *head,int index,DataType data)
{
	register int i;

	if(index<0||index>length(head)-1)
		return(0);

	head=head->next;
	for(i=0;i<index;i++)
		head=head->next;

	head->data=data;

	return(-1);
}

Node *getNode(Node *head,int index)
{
	register int i;

	if(index<0||index>length(head)-1)
		return(NULL);

	for(i=0;i<index;i++)
		head=head->next;

	return(head->next);
}

int indexOf(Node *head,DataType data)
{
	register int i;

	if(head)
	{
		head=head->next;
		for(i=0;head;head=head->next,i++)
			if(head->data==data)
				return(i);
	}

	return(-1);
}

#11

学.net时间不短了，但是依旧有的知道掌握不牢

学习一下

#12

那链表到底有什么用，一次没有用过啊。

#13

学习了

#14

引用 12 楼 qq81867376 的回复:

那链表到底有什么用，一次没有用过啊。

链表是线性表这种数据结构模型的一种实现思路，它与静态表相比的优点是长度可变，且插入、删除操作的效率较高。.Net类库里的System.Collections.Generic.LinkedList就是链表的具体实现。
一般可变长的线性表都是链表(有些是链表与静态表相结合)实现的。

突然发现这里是C#版块，自己居然发了一堆C的代码上来  -_-

把C#的链表实现也大致写下吧：

namespace LinkedListTest
{
    public class MyLinkedList<T>
    {
        MyLinkedListNode<T> head;

        int count;
        public int Count
        {
            get { return count; }
        }

        public MyLinkedList()
        {
            head = null;
            count = 0;
        }

        public T this[int index]
        {
            get
            {
                if (index < 0 || index > count - 1)
                    throw new ArgumentOutOfRangeException();

                MyLinkedListNode<T> node = head;

                for (int i = 0; i < index; i++)
                    node = node.Next;

                return (node.Data);
            }
            set
            {
                if (index < 0 || index > count - 1)
                    throw new ArgumentOutOfRangeException();

                MyLinkedListNode<T> node = head;

                for (int i = 0; i < index; i++)
                    node = node.Next;

                node.Data = value;
            }
        }

        public void Add(T data)
        {
            if (count == 0)
                head = new MyLinkedListNode<T>(data);
            else
            {
                MyLinkedListNode<T> node = head;

                while (node.Next != null)
                    node = node.Next;

                node.Next = new MyLinkedListNode<T>(data);
            }
            count++;
        }

        public bool Insert(int index, T data)
        {
            if (index < 0 || index > count)
                return (false);

            MyLinkedListNode<T> node = new MyLinkedListNode<T>(data);

            if (index == 0)
            {
                node.Next = head.Next;
                head = node;
            }
            else
            {
                MyLinkedListNode<T> temp = head;

                for (int i = 0; i < index - 1; i++)
                    temp = temp.Next;

                node.Next = temp.Next;
                temp.Next = node;
            }
            count++;

            return (true);
        }

        public bool RemoveAt(int index)
        {
            if (index < 0 || index > count - 1)
                return (false);

            if (index == 0)
                head = null;
            else
            {
                MyLinkedListNode<T> node = head, temp;

                for (int i = 0; i < index - 1; i++)
                    node = node.Next;

                temp = node.Next;
                node.Next = temp.Next;

                temp.Next = null;
            }

            count--;
            GC.Collect();
            return (true);
        }

        public int IndexOf(T data)
        {
            MyLinkedListNode<T> node = head;

            for (int index = 0; node != null; node = node.Next, index++)
                if (node.Data.Equals(data))
                    return (index);

            return (-1);
        }

        public IEnumerator<T> GetEnumerator()
        {
            MyLinkedListNode<T> node = head;

            while (node != null)
            {
                yield return (node.Data);
                node = node.Next;
            }
        }
    }

    public class MyLinkedListNode<T>
    {
        T data;
        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        MyLinkedListNode<T> next;
        public MyLinkedListNode<T> Next
        {
            get { return next; }
            set { next = value; }
        }

        public MyLinkedListNode()
        {
            next = null;
        }

        public MyLinkedListNode(T data)
        {
            this.data = data;
            next = null;
        }
    }
}

测试代码：

namespace LinkedListTest
{
    class Program
    {
        static void Main(string[] args)
        {
            MyLinkedList<int> list = new MyLinkedList<int>();

            for (int i = 0; i < 5; )        //添加数据
                list.Add(++i);

            DisplayList(list);
            Console.WriteLine();

            list.RemoveAt(2);               //删除数据

            DisplayList(list);
            Console.WriteLine();

            list.Insert(1, 8);              //插入数据

            DisplayList(list);
            Console.WriteLine();

            list[4] = 10;                   //修改数据
            Console.WriteLine("The index of data 10:{0}", list.IndexOf(10));    //查询下标
            Console.WriteLine("The index of data 9:{0}", list.IndexOf(9));
            DisplayList(list);
        }

        static void DisplayList(MyLinkedList<int> list)
        {
            foreach (int item in list)
                Console.Write(item + "\t");

            Console.WriteLine();
        }
    }
}

#15

学习了

#16

打了半年代码了，还是有很多不懂！
up~~~~

#17

晕啊，开发了ERP两年了还有那么基础的我不知道啊

#18

学习了。。。。

#19

初学，受益匪浅。CSDN必须常来啊

#20

该回复于2011-09-04 18:57:30被版主删除

#21

该回复于2011-09-04 18:57:30被版主删除

#22

感觉这个面试的题 还是较好的。

#23

这是招聘 还是考试？搞的像考试一样

#24

学习了

#25

链表有单链表和双链表，其实用一个对象模型来设置一下就行。
下面写一下双链表
id;\\本节点的id
parentid;\\父节点的id
childid;\\子节点的id

有这三个属性就能完成链表的所有操作了

#26

该回复于2011-09-06 14:40:05被版主删除

#27

发觉有不会回答的啊      汗。。。。。。。。。。。

#28

太好了，一个都不会啊

#29

我也是啊，

#30

该回复于2015-10-31 23:44:47被版主删除

#31

--查出所有，2科成绩超过60分的学生姓名，以及各科成绩？
--刷选合格的学号
 select 学号,count(成绩) as 及格成绩数 into TempJGTable from sc where 成绩>60 group by 学号 
--刷选合格2门的学号
select 学号 into TempXHTable from TempJGTable where 及格成绩数=2
--通过连接获得超过60分的学生姓名和各科成绩
select s.姓名,c.课程名称,sc.成绩 from ((TempXHTable a left join sc on a.学号=sc.学号 and sc.成绩>60)
left join s on a.学号=s.学号) left join c on sc.课程号=c.课程号 




--查出所有没选任课老师为莉莉的学生的各科成绩
select s.姓名,c.课程名称,sc.成绩,c.任课教师 from (sc inner join c on (sc.课程号=c.课程号 and c.任课教师!='莉莉'))
left join s on s.学号=sc.学号

#32

学习了

#33

学习了一部分，顶一下！

#34

学习了，感谢分享。