C#笔试（程序设计）

1.如何把一个Array复制到ArrayList里，如何把ArrayList复制到Array里？

foreach( object o in array )arrayList.Add(o);

ArrayList.ToArray

2.几种排序算法C#实现

冒泡排序

        public void Action(int[] array)
        {
            for (int a = ; a < array.Length; a++)
            {
                int item = ;
                for (int b = array.Length - ; b > a; b--)
                {
                    if (array[b] < array[b - ])
                    {
                        item = array[b];
                        array[b] = array[b - ];
                        array[b - ] = item;
                    }
                }
            }
        }

直接插入排序

        public void Action(int[] array)
        {
            for (int i = ; i < array.Length; i++)
            {
                if (array[i] < array[i - ])
                {
                    int tem = array[i];
                    int j = ;
                    for (j = i - ; j >=  && tem < array[j]; j--)
                    {
                        array[j + ] = array[j];
                    }
                    array[j + ] = tem;
                }
            }
        }

快速排序

        private void QuickSortArray(int[] arr, int low, int high)
        {
            int i = low;
            int j = high;
            int tmp = arr[low];
            while (low < high)
            {
                while ((low < high) && arr[high] >= tmp)
                {
                    --high;
                }
                arr[low] = arr[high];
                while ((low < high) && arr[low] <= tmp)
                {
                    ++low;
                }
                arr[high] = arr[low];
                --high;
            }
            arr[low] = tmp;
            if (i < low - )
            {
                QuickSortArray(arr, i, low - );
            }
            if (j > low + )
            {
                QuickSortArray(arr, low + , j);
            }

        }

简单选择排序

        public void Action(int[] array)
        {
            int tmp = ;
            int t = ;//最小数标记
            for (int i = ; i < array.Length; i++)
            {
                t = i;
                for (int j = i + ; j < array.Length; j++)
                {
                    if (array[t] > array[j])
                    {
                        t = j;
                    }
                }
                tmp = array[i];
                array[i] = array[t];
                array[t] = tmp;
            }
        }

 3.一列数的规则如下: 1、1、2、3、5、8、13、21、34…… 求第30位数是多少， 用递归算法实现。

public class MainClass
{
public static void Main()
{
Console.WriteLine(Foo());
}
public static int Foo(int i)
{
if (i <= )
return ;
else if(i >  && i <= )
return ;
else return Foo(i -) + Foo(i – );
}
}

4.输出？X=1;Y=2

class A
{
    public static int x;
    static A()
    {
        x = B.Y + 1;
    }
}

class B
{
    public static int Y = A.x + 1;
    static B()
    {

    }
    static void Main()
    {
        Console.WriteLine("X={0},Y={1}",A.x,B.Y);
        Console.Read();
    }
}

首先是字段Y,Y是int型,编译器初始化为0 ,然后Y为static,所以编译器接着执行B的静态构造函数,注意一点,构造函数只执行一次
在static B()里面,Y被赋值为A.X+1,编译器接着去找A.X的值,此时执行A的静态构造函数,x=B.Y+1,因为B的构造函数已经执行了,此时就不执行第二次,Y此时具有
值是0,所以X=1;然后返回Y=A.X+1,Y=2
所以答案就是X=1;Y=2;

5.有一个10个数的数组，计算其中不重复数字的个数。{3,5,9,8,10,5,3}

            int[] values = { , , , , , ,  };
            HashSet<int> set = new HashSet<int>();
            foreach (int i in values)
            {
                set.Add(i);
            }
            foreach (int i in set)
            {
                Console.WriteLine(i);
            }

6.

程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。(C#语言)

要求： 1.要有联动性，老鼠和主人的行为是被动的。

2.考虑可扩展性，猫的叫声可能引起其他联动效应。

要点：1. 联动效果，运行代码只要执行Cat.Cryed()方法。2. 对老鼠和主人进行抽象
评分标准: <1>.构造出Cat、Mouse、Master三个类，并能使程序运行
<2>从Mouse和Master中提取抽象
<3>联动效应，只要执行Cat.Cryed()就可以使老鼠逃跑，主人惊醒。

7.代码中有什么错误吗？请指出来

using System;
     class A
     {
          public virtual void F(){
              Console.WriteLine("A.F");
           }
      }
      abstract class B:A
       {
           public abstract override void F();    
       }

抽象类是无法重载的
所以
 public abstract override void F();  错误
调用虚方法时，将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员，如果没有派生类重写该成员，则它可能是原始成员。

默认情况下，方法是非虚拟的。不能重写非虚方法。

virtual 修饰符不能与 static、abstract, private 或 override 修饰符一起使用。

除了声明和调用语法不同外，虚拟属性的行为与抽象方法一样。

    *

      在静态属性上使用 virtual 修饰符是错误的。
    *

      通过包括使用 override 修饰符的属性声明，可在派生类中重写虚拟继承属性。

8.产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复

int[] arr = new int[];
for (int i = ; i < arr.Length; i++) arr[i] = i;
Random rnd = new Random();
Array.Sort(arr, delegate(int a, int b) { return rnd.Next(); });