复习记录10.28(算法，委托)

10月27日复习日记

3种排序算法

插入排序：每次选择一个元素，并将这个元素与前面有序的序列进行比较，然后插到合适的位置。

            void Insertion_sort(int[] arr, int length)
            {
                int i, j;
                for (i = 1; i < length; i++)
                {
                    int temp = arr[i];
                    for (j = i; j > 0 && arr[j - 1] > temp; j--)
                    {
                        arr[j] = arr[j - 1];                   
                    }                   
                    arr[j] = temp;
                }
            }

希尔排序：插入排序的升级版，步长由长到短分组，进行组内排序（用插入排序或者冒泡排序），直到步长为1。

            void shell_sort(int[]arr,int length)
            {
                int i, j, temp, gap;
                for(gap = length/2; gap>0; gap /= 2)  //间隔
                {
                    for ( i = gap; i < length; i++)      //组内插入排序
                    {
                        temp = arr[i];
                        for (j = i;  j>= gap && arr[j-gap] >temp; j -=gap)
                        {
                            a[j] = a[j-gap];
                        }
                        a[j] = temp;               
                    }
                }
            }

冒泡排序：每次选择两个元素，按需求进行交换，每循环一轮都会有最小或者最大值”冒泡“   时间复杂度为 n^2

                 循环的轮数越多，需要交换的次数就越少

                  例如 for(i = 0; i<length - 1;i++){        //这个是循环的轮数

                                比如length  = 10；

                               当 i = 0(循环的轮数)，需要交换9次    i = 1(循环的轮数)，需要交换8次  

                      for(j = 0; j<length -1 -i); j++{}}   //交换的次数

            void Bubble_sort(int[]arr, int length)
            {
                int i, j , temp;
               
                for  (i = 0; i < length - 1; i++) //走得趟数
                {
                    bool haveTemp = false;
                    for (j = 0;  j< length - 1 - i ; j++)   //交换得次数
                    {
                        
                        if (arr[j] > a[j + 1])
                        {
                            temp = arr[j];
                            arr[j] = arr[j + 1];
                            a[j + 1] = temp;
                            haveTemp = true;
                        }
                    }
                    if(haveTemp == false) //当循环下来没有交换时，证明序列已经有序
                    {
                        return;
                    }
                }
            }

 

//从后到前
        void BubbleSort2(SqList *L){
            int i, j;
            Status flag = TRUE;
            for(i = 1; i< L->length && flag;i++){
                flag = false;
                for(j = L->length - 1; j>=i ; j--){
                        if(L->r[j] > L->r[j+1]){
                            swap(L,j,j+1);
                                flag = TRUE
}
}
}           
}

变量（数据）是以某个地址为起点的一段内存中所存储的值。

函数（算法）是以某个地址为起点的一段内存中所存储的一组机器语言指令。

 

直接调用：直接调用函数名所在的地址 

间接调用：通过函数指针来调用。如 func1.Invoke();(仿照函数指针)

 

委托是什么：委托本质上是一种“接口方法”，类似于C/C++的指针函数，但比函数指针安全，在C#中一般用于事件处理

委托等同事件吗? 

我觉得没有可比性，因为委托是类，事件是对象，不过事件的内部是用private委托+Add和Remove方法实现的.

他们的区别：对于事件来说，外部只能进行”注册自己 +=“，”注销自己 -=“，外界不能注销其他的注册者，外界不能主动触发事件，但是如果用Delegate就没办法进行上面的控制，因此诞生了事件这种语法。事件是用来阉割委托实例的。

系统的委托：

Action委托 

            Action<string> action = new Action<string>(d.Report);
            action.Invoke("string类型的Action委托，只有输入值 没有返回值"); //间接调用

Func委托

            Func<int, int, int> func1 = new Func<int, int, int>(d.Add);
            func1.Invoke(1, 2)

自定义委托：

public delegate void myDelegate(string str);  
  //void 目标方法没有返回值，string str 目标方法参数
public static void HellowChinese(string strChinese)  
{  
    Console.WriteLine("Good morning," + strChinese);  
    Console.ReadLine();  
}  
  
myDelegate d = new myDelegate(HellowChinese);  
d("Mr wang");

模板方法： 

            WarpFactory warpFactory = new WarpFactory();
            ProuductFactroy prouductFactroy = new ProuductFactroy();
            Func<Prouduct> setProduct1 = new Func<Prouduct>(prouductFactroy.MakePizz);
            Box box1 = new Box();
            box1 = warpFactory._WarpFactory(setProduct1.Invoke);
class Prouduct  //产品
    {
        public string name { get; set; }
    }
    class Box   //盒子
    {
        public Prouduct prouduct { get; set; }
    }
    class WarpFactory   //包装盒子
    {
        public Box _WarpFactory(Func<Prouduct> getProduct)
        {
            Box box = new Box();
            Prouduct prouduct = getProduct.Invoke();
            box.prouduct = prouduct;
            return box;            
        }
    }
    class ProuductFactroy  //生产产品
    {
        public Prouduct MakePizz()
        {
            Prouduct prouduct = new Prouduct();
            prouduct.name = "Pizz";
            return prouduct;
        }
    }