C#算法收集

 很多程序员朋友都抱怨着算法的枯燥，同样也说着算法就像初中高中的物理化学，现在学的计算机和他们挂个毛的边。 也许我是个另类，我觉得算法就是告诉你，怎么佯作，才能提高你的程序效率。通俗点说：你有两台电脑，打游戏的时候你会使用非常卡的那台还是流畅的那台？当然两台的cpu和Gpu完全是不同的，如果你不去了解cpu和Gpu，你能知道那台电脑打起游戏来比较爽吗？ 
废话少说，切入主题。 从前，上山有座庙，庙里有个老和尚，老和尚在说：从前，上山有座庙，庙里有个老和尚，老和尚在说：从前，上山有座庙，庙里有个老和尚，老和尚在说：（Repeating……）。 
这就是一个递归。当然在数学里，我们把它叫做“菲波拉契数” Eg：计算1,1,2,3,5,8....... 第30位值。 

1.递归算法：

思想：在函数或子过程的内部，直接或者间接地调用自己的算法。

递归算法解决问题的特点：
　　(1) 递归就是在过程或函数里调用自身。
　　(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
　　(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
　　(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

让我们先考虑下： 
序号 结果
0------1
1------1 
2------2 
3------3 
4------5 
5------8 
。 
。 
。 
30------？？？ 
可以清楚的看出他们的对应关系：结果小于2且大于等于0的时候，结果为1,。序号大于等于2时，其结果，等于（结果-1+结果-2）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ArithMetic
{
    class Program
    {
        static void Main(string[] args)
        {
            //计算数组1,1,2,3,5,8.......第30位的值
            Console.WriteLine(RecursiveAlgorithm.Fibonacci(3));
            Console.ReadKey();
        }
        //1.递归算法 Eg：计算1,1,2,3,5,8....... 第30位值
        class RecursiveAlgorithm//递归算法类
        {
            /// <summary>
            /// 菲波拉契数
            /// </summary>
            /// <param name="i"></param>
            /// <returns></returns>
            public static int Fibonacci(int i)
            {
                if (i < 0)
                    return 0;
                if (i >= 0 && i < 2)
                    return 1;
                else
                    return Fibonacci(i - 1) + Fibonacci(i - 2);
            }
        }
    }
}

 2 .冒泡排序算法

 思想：

冒泡排序算法:将n个记录看作按纵向排列，每趟排序时自下至上对每对相邻记录进行比较，若次序不符合要求（逆序）就交换。每趟排序结束时都能使排序范围内关键字最小的记录象一个气泡一样升到表上端的对应位置，整个排序过程共进行n-1趟，依次将关键字最小、次小、第三小…的各个记录“冒到”表的第一个、第二个、第三个…位置上。

   初态      第1趟   第2趟  第3趟  第4趟  第5趟  第6趟  第7趟
    38        12      12      12      12      12      12      12                               
    20        38      20      20      20      20      20      20 
    46        20      38      25      25      25      25      25 
    38        46      25      38      38      38      38      38 
    74        38      46      38      38      38      38      38 
    91        74      38      46      46      46      46      46 
    12        91      74      74      74      74      74      74
    25        25      91      91      91      91      91      91

 一般来说，网上很多的源码，都没有加判断：判断是否进行过排序。

下面，让我们来看看冒泡排序的代码（从小打大）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BubbleSort
{
    //冒泡排序算法:将n个记录看作按纵向排列，每趟排序时自下至上对每对相邻记录进行比较，
    //若次序不符合要求（逆序）就交换。
    //每趟排序结束时都能使排序范围内关键字最小的记录象一个气泡一样升到表上端的对应位置，
    //整个排序过程共进行n-1趟，依次将关键字最小、次小、第三小…的各个记录“冒到”表的第一个、
    //第二个、第三个…位置上。 
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 38, 20, 46, 38, 74, 91, 12, 25 };
            BubbleSort(array);
            Console.ReadKey();
        }
        public static void BubbleSort(int[] ints)
        {
            int numberOfLoop = 0;
            bool flag = true;
            for (int i = 0; i < ints.Length - 1; i++)
            {
                numberOfLoop++;//排序一次增加一次。
                for (int j = 0; j < ints.Length - i - 1; j++)
                {
                    //两个数作比较，把小的排在前边，最大的就会走到最后
                    if (ints[j] > ints[j + 1])
                    {
                        int temp = ints[j];
                        ints[j] = ints[j + 1];//交换两个变量的位置
                        ints[j + 1] = temp;
                        flag = false;
                    }
                }
                if (flag)
                {
                    break;
                }
            }
            DisplaySortResult(numberOfLoop, ints);//调用输出方法
        }
        private static void DisplaySortResult(int numberOfLoop, int[] array)
        {
            foreach (int i in array)
            {
                Console.Write(i.ToString() + " ");
            }
            Console.WriteLine("\n循环次数：" + numberOfLoop.ToString());
        }
    }
}

3.选择排序：在算法中，选择排序是最不稳定的。

选择排序的思想:

每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

Eg:使用选择排序算法将下列数据从小到大的排列起来。

38, 20, 46, 38, 74, 91, 12, 25

让我们用code来解释：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _3_SelectSort
{
    //选择排序算法
    /*每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
     * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。*/
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 38, 20, 46, 38, 74, 91, 12, 25 };
            Selectort(array);
            Console.ReadKey();
        }
        static void Selectort(int[] ints)
        {
            int numberOfLoop = 0;
            int numberOfMin;//最小的元素
            //第一层循环--元素的位置
            for (int i = 0; i < ints.Length - 1; i++)
            {
                numberOfMin = i;
                //第二层循环：元素位置上的值
                for (int j = i + 1; j < ints.Length; j++)
                {
                    numberOfLoop++;
                    //获取最小元素
                    if (ints[numberOfMin] > ints[j])//ru
                    {
                        numberOfMin = j;
                    }
                }
                if (numberOfMin != i)
                {
                    //交换变量的位置
                    int temp = ints[i];
                    ints[i] = ints[numberOfMin];
                    ints[numberOfMin] = temp;
                }
            }
            //输出数据
            DisplaySortResult(numberOfLoop, ints);
        }
        private static void DisplaySortResult(int numberOfLoop, int[] array)
        {
            foreach (int i in array)
            {
                Console.Write(i.ToString() + " ");
            }
            Console.WriteLine("\n循环次数：" + numberOfLoop.ToString());
        }
    }
}

4.插入排序算法：　假定这个数组的序是排好的，然后从头往后，如果有数比当前外层元素的值大，则将这个数的位置往后挪，直到当前外层元素的值大于或等于它前面的位置为止.这具算法在排完前k个数之后，可以保证a[1…k]是局部有序的，保证了插入过程的正确性.

算法描述

　　一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下： 

　　⒈ 从第一个元素开始，该元素可以认为已经被排序 

　　⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描 

　　⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置 

　　⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 

　　⒌ 将新元素插入到下一位置中 

　　⒍ 重复步骤2 

　　如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找排序。

让我来看看，插入排序算法是怎么样工作的：

下面，我们用Code来说明：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _4_InsertSort
{
    //插入排序算法
    /*思想：
1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果该元素（已排序）大于新元素，将该元素移到下一位置
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置中
6.重复步骤2~5*/
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 12,15,9,20,6,31,24 };
            InsertSiort(array);
            Console.ReadKey();
        }

        public static void InsertSiort(int[] ints)
        {
            int numberOfLoop = 0;//循环累计器
            for (int i = 0; i < ints.Length - 1; i++)
            {
                //处理第i个数。i之前的数字排列是有序的
                int temp = ints[i];
                int j;
                //包含第i个数的前序列
                for (j = i; j > 0; j--)
                {
                    numberOfLoop++;
                    //比较第i个数与第j-1个数，如果第i个数小于第j-1个数，则i应该排在j-1的前边，将第j-1个数后移
                    //这样j-1的位置就是一个可以插入的位置，然后继续比较j-1前边的数，如果仍旧大于第i个数，则继续后移
                    //最后剩下一个位置，插入第i个数，这样包含i的前部分的序列就是有序的了。
                    if (ints[j - 1] > temp)
                    {
                        ints[j] = ints[j - 1];
                    }
                    else
                    {
                        break;
                    }

                }
                //最后一个位置设置成要排序数
                ints[j] = temp;
            }
            DisplaySortResult(numberOfLoop, ints);
        }
        private static void DisplaySortResult(int numberOfLoop, int[] array)
        {
            foreach (int i in array)
            {
                Console.Write(i.ToString() + " ");
            }
            Console.WriteLine("\n循环次数：" + numberOfLoop.ToString());
        }
    }
}