daofu

• 快排排序算法

 public class QuickSort
    {
        public static void Main(String[] args)
        {
            int[] array = { 9, 2, 4, 0, 4, 1, 3, 5 };
            quickSort(array, 0, array.Length - 1);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
            Console.ReadKey();
        }
        //分化好后就是简单的递归
        public static void quickSort(int[] array, int start, int end)
        {
            if (start < end)
            {
                int position = partition(array, start, end);
                quickSort(array, start, position - 1);
                quickSort(array, position + 1, end);
            }
        }
        //重排array，并找出“临界”位置的索引
        //分化（Partition）的步骤,划分数组
        public static int partition(int[] array, int start, int end)
        {
            int position = start - 1;
            int base1 = array[end];
            for (int i = start; i < end; i++)
            {
                if (array[i] <= base1)
                {
                    position++;
                    int temp = array[position];
                    array[position] = array[i];
                    array[i] = temp;
                }
            }
            int temp1 = array[position + 1];
            array[position + 1] = array[end];
            array[end] = temp1;
            return position + 1;
        }
    }
}

• C#中的委托,匿名方法和Lambda表达式

委托就是把方法当参数进行传递！还有匿名委托

　　 delegate int NumOpe(int a, int b); //第一步:委托声明

    class Class1
    {
        static void Main(string[] args)
        {
            Class1 c1 = new Class1();
            NumOpe p1 = new NumOpe(c1.Add); //委托实例化,注意参数是要使用的参数名,且不带括号
            NumOpe p2 = new NumOpe(c1.Sub);
            Console.WriteLine(p1(1, 2)); //委托调用
            Console.WriteLine(p2(1, 2)); //委托调用
            Console.ReadLine();
        }

        private int Add(int num1, int num2)
        {
            return (num1 + num2);
        }
        private int Sub(int num1, int num2)
        {
            return (num1 - num2);
        }
    }

• 冒泡排序

public class BubbleSort
    {
        static void Main(string[] args)
        {
            int temp;
            int[] arrShort = { 10, 5, 9, 7, 2 };
            for (int i = 0; i < arrShort.Length; i++)
            {
                for (int j = i + 1; j < arrShort.Length; j++)
                {
                    if (arrShort[j] < arrShort[i])
                    {
                        temp = arrShort[j];
                        arrShort[j] = arrShort[i];
                        arrShort[i] = temp;
                    }
                }
            }

            for (int i = 0; i < arrShort.Length; i++)
            {
                Console.WriteLine(arrShort[i]);
            }
            Console.ReadKey();
        }
    }

• 递归

递归是指在函数的定义中使用函数自身的方法。

• 深拷贝和浅拷贝

浅拷贝 只拷贝指针，深拷贝就是拷贝他的值，重新生成的对像。就像是浅拷贝就是你的影子，深拷贝是你的克隆人，你没了影子也就没了，但是克隆人还活着。

简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误！

• 对.NET框架的认识 异常处理

自己定义异常类，异常消息

.Net Framework包括CLR 公共语言运行时和一组统一的类库

C#源代码--->中间语言（IL），通常扩展名为.exe或.dll--->CLR--->本机机器指令

• truancate和drop区别

truncate 和 delete 只删除数据不删除表的结构
drop 语句将删除表的结构被依赖的约束(constrain)、触发器(trigger)、索引(index)；依赖于该表的存储过程/函数将保留,但是变为 invalid 状态。
想删除表,当然用 drop
想保留表而将所有数据删除，如果和事务无关，用truncate即可。
如果和事务有关,或者想触发trigger,还是用delete。

• oop概念

封装、继承、多态

• 虚方法与抽象方法

相同：都可以在派生类中重写；
不同点：虚方法在基类中可以有实现的部分，在派生类中可重写也可不重写；

　　　　而抽象方法在基类中没有实现的部分，在派生类中必须重写；

• 重载 重写

重载就是方法的名称相同，参数的个数或类型不同，进行多次重载以实现不同的需求；
重写就是对基类中函数的重写，为了实现具体的功能；
不同点：1.方法的重写是子类和父类的关系，属于垂直关系；方法的重载是同一个类中方法之间的关系，属于水平关系；
           2.重写只能有一个方法，或者说只能有一对方法产生关系；方法的重载是多个方法之间的关系；
           3.重写要求参数列表相同；重载要求参数列表不同；

• 值类型和引用类型的区别

所有继承System.ValueType的类型都是值类型，其他类型都是引用类型。
引用类型可以派生出新的类型，而值类型不能。
引用类型存储在堆中，而值类型存储在栈中。
引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型）。
引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。
当比较两个值类型时，进行的是内容比较；而比较两个引用类型时，进行的是引用比较。
值类型在内存管理方面具有更好的效率，并且不支持多态，适合用作存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。

• 用foreach语句遍历数组，找出最大数和最小数

int[] values = { 1, 3, 5, 7, 9, 10, 8, 6, 4, 2 };
int max = int.MinValue, min = int.MaxValue;
foreach (int value in values)
{
    if (value < min)
        min = value;
    if (value > max)
        max = value;
}
Console.WriteLine("最大数：" + max + "；最小数：" + min);
Console.ReadKey();

• 抽象类和接口

相同点：1.都不能被实例化，都可以通过继承实现其抽象方法；
           2.都是面向抽象编程的技术基础；
不同点：1.接口支持多继承，也就是说一个类可以实现多个接口；抽象类不能实现多继承；
           2.接口只能定义抽象规则或对象；抽象类即可以定义抽象的，也可以提供一些已经实现的成员或方法；
           3.接口只包含方法、属性、索引器、事件的签名，但却不能定义字段和包含实现的方法；抽象类可以
              定义字段、属性和包含有实现的方法；