面试算法的复习和整理，争取每天一个算法[常更长新]

　　一哥们去一著名跨国大大大的公司去面试。在很多项目经验，设计，架构，前台，后端都考察个遍后...私以为快要拿到Offer的时候... 不信的事情发生了。
考官出了两道大二时候经常考的算法题。用惯了IDE的他居然一时蒙掉了，提笔多次却无从落笔。悲剧之余，只得铩羽而归...
　　为了不和这哥们一样，我觉得好好复习复习算法相关的问题，争取每天一个算法题，以题促进。对于我个人的解决方案肯定有部分是比较粗陋的，希望各位大牛不吝赐教，留下各位的算法。当然我觉得各位在看我的算法之前自己动手写写应该也是有提高的，最好是用记事本写，然后直接Copy到IDE中测试，看看离开了Intelligence还能不能直接Run的起来...
　　1： 经典的冒泡排序
　　简述：给出一组乱序数组 如： int[] a = new int[10]{4,3,5,1,6,2,9,10,8,7};
　　要求：写出f(n)， 使得乱序数组按序排列。　　  

public static void RunSnippet()
{
    int[] a = new int[] {4, 3, 5, 1, 6, 2, 9, 10, 8, 7};
    //int[] a = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    //int[] a = new int[] {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
     int temp = 0, count = 0;
    for (int i = 1; i < a.Length; i++)
    {
        for (int j = 0; j < a.Length - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                temp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = temp;
                count += 1;
            }
        }
    }
    //for (int i = 0; i < a.Length; i++)
    //{
    //    for (int j = i + 1; j < a.Length; j++)
    //    {
    //        if (a[j] < a[i])
    //        {
    //            temp = a[i];
    //            a[i] = a[j];
    //            a[j] = temp;
    //            count += 1;
    //        }
    //    }
    //}
     for (int i = 0; i < a.Length; i++)
    {
        Console.WriteLine(a[i].ToString());
    }
    Console.WriteLine("Count:" + count);
    Console.ReadLine();
}

　　解析：面试最常见的排序之一，按顺序将每一个值和后面的所有值作一次比较，符合要求（如 a[0] > a[1]）则a[0]与a[1]交换，否则不变；这样一轮下来总能保证最小的冒到最上面（给出的算法一为最大的沉到最下面，两种算法稍有不同，自己体会下）。N(数组的Length-1)轮过后，对每一个数字都进行了调换，于是排序成功。
　　扩展：待补充...
　　2： 面试题：菲薄那题数列
　　简述：给出一数字序列 {1,1,2,3,5,8...}
　　要求：写出f(n)， 计算第N位数字的值。

public static void RunSnippet()
{
    int a = 1,b = 1,total = 0;
    int n;
    n = int.Parse(Console.ReadLine());
    n = n -2;
    if(n<=0)
    {
        total = 1;
    }
    else
    {
        for(int i =0;i<n;i++)
        {
            total = a+b;
            a=b;
            b=total;
        }
    }
    Console.WriteLine(total);
}

　　解析：同样常见的面试题，有题可知，每个数字均为前两个数字之和，由于规定不能用递归，所以用循环的方法就是只能由小做到大。设定两个变量存储前两位值，每次循环为这两个变量重新赋值，直到循环到需求的次数为止。
　　扩展：待补充...
　　3： 面试题：任意插入排序
　　简述：给出两数字序列 int[] a = new int[]{1,2,3,4,7,8,9,10}; 和 int[] b = new int[]{2,5,6,8};
　　要求：写出f(n)， 把b中的数字按顺序插入到a中，为了简便，默认a,b中数字已经排序。   

public static void RunSnippet()
{
    int[] a = new int[]{1,2,3,4,7,8,9,10};
    int[] b = new int[]{2,5,6,8};
    int z= 0;
    int[] result = new int[a.Length+b.Length];
    for(int i = 0;i<a.Length;i++)
    {
        for(int j=0;j<b.Length;j++)
        {
            if(a[i]>b[j])
            {
                result[z]=b[j];
                b[j] = int.MaxValue;
                z+=1;
            }
        }
        result[z] = a[i];
        z+=1;
    }
    for(int i = 0;i<result.Length;i++)
    {
        Console.WriteLine(result[i]);
    }
}

 　  解析：典型的插值，我稍加改变，本来是插入一个数，我改成了插入一个数组。实现原理就是new新的数组result，然后按顺序把a中元素和b中的每个元素比较，符合要求的(a[i]>b[j])家，先插入b[j]到result数组，在插入a[i]，否则直接插入a[i]。这里设置b[j]为int.MaxValue是为了不对b中元素重复操作。我想肯定有更好的算法，希望大家不吝赐教。
　　扩展：待补充...
　　4： 直接插入排序
　　简述：给出一数字序列 int[] a = new int[10]{4,3,5,1,6,2,9,10,8,7};
　　要求：写出f(n)，使得无序数组按序排列。  

public static void RunSnippet()
{
    int[] a = new int[] { 4, 3, 5, 1, 6, 2, 9, 10, 8, 7 };
    //int[] a = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    //int[] a = new int[] {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    int count = 0,temp = 0;
    for (int i = 1; i < a.Length; i++)
    {
        temp = a[i];
        int j = i - 1;
        while (j >= 0 && a[j] > temp)
        {
            a[j + 1] = a[j];
            j--;
            count += 1;
        }
        a[j + 1] = temp;
    }
//    temp = 0;
//    for (int i = 1; i < a.Length; i++)
//    {
//        for (int j = 0; j < i; j++)
//        {
//            if (a[i] < a[j])
//            {
//                for (int k = i; k > j; k--)
//                {
//                    temp = a[k];
//                    a[k] = a[k - 1];
//                    a[k - 1] = temp;
//                    count += 1;
//                }
//                break;
//            }
//        }
//    }
    for (int i = 0; i < a.Length; i++)
    {
        Console.WriteLine(a[i].ToString());
    }
    Console.WriteLine("Count:" + count);
    Console.ReadLine();
}

　　解析：直接插值排序，将a[n]和a[0]比较，如果符合要求(如:a[n]<a[0])，移动数字到a[0]前，否则继续比较a[n]和a[1]，共需要比较n-1次。因为每次和前面比较的数列必定是已经排好序的，所以只要命中一次符合条件的判断，就可以退出比较循环了，两种算法是一样的，写法不同，可以在VS中跟踪一下。
　　扩展：待补充...

　　5： 希尔排序
　　简述：给出一数字序列 int[] a = new int[10]{4,3,5,1,6,2,9,10,8,7};
　　要求：写出f(n)，使得无序数组按序排列。　　

public static void RunSnippet()
{
    int[] a = new int[] { 4, 3, 5, 1, 6, 2, 9, 10, 8, 7 };
    //int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    //int[] a = new int[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
    int count = 0, temp = 0;
    for (int h = a.Length/3; h > 0; h /= 2)
    {
        for (int i = h; i < a.Length; i+=h)
        {
            for (int j = 0; j < i; j += h)
            {
                if (a[i] < a[j])
                {
                    for (int k = i; k > j; k -= h)
                    {
                        temp = a[k];
                        a[k] = a[k - h];
                        a[k - h] = temp;
                        count += 1;
                    }
                    break;
                }
            }
        }
    }
    
    for (int i = 0; i < a.Length; i++)
    {
        Console.WriteLine(a[i]);
    }
    Console.WriteLine("Count:" + count);
    Console.ReadLine();
}

　　解析：直接排序的升级版，开始会去一个跳跃值，使得每个数字不用和相邻的比较交换，而是根据跳跃值得到不同间隔值的若干组数，并在组内采用直接插入排序，最后的一组的间隔为1。如题中，总长度为10，跳跃值为3，分成的组为{a[3],a[6],a[9]},{a[*]}，间隔分别为3和1。　
　　扩展：选取不同的跳跃值对排序的性能有比较大的影响，怎么选取合适的跳跃值是个问题...

　　6： 面试题：数列替换
　　简述：给出两字串序列 string[] a = new string[]{"a","b","c","d","e","f","a","b","c","d","e"}; string[] b = new string[]{"b","c","d"};
　　要求：写出f(n)， 把a串中同b的字串队列用空格代替。　　

public static void RunSnippet()
{
    string[] a = new string[]{"a","b","c","d","e","f","a","b","c","d","e"};
    string[] b = new string[]{"b","c","d"};
    int temp;
    for(int i=0;i<a.Length;i++)
    {
        temp = i;
        for(int j=0;j<b.Length;j++)
        {
            if(a[i]==a[j])
            {
                i+=1;
            }
            else
            {
                i=temp;
                break;
            }
            if(j==b.Length-1)
            {
                for(int k=0;k<b.Length;k++)
                {
                    a[i]="";
                    i-=1;
                }
                i=temp+b.Length;
            }
        }
    }
    for(int i=0;i<a.Length;i++)
    {
        Console.WriteLine(a[i].ToString());
    }
}

　　解析：不知道算不算是最简陋的算法了，基本不用解释也是一看就明白了。思路是将a中的字符轮序与b中的字符比较，碰到第一个不同就退出，如果都相同倒过来全部置为空，跳过b的长度继续比较。
　　扩展：待补充...

　　7： 面试题：求小于某数字的所有素数
　　简述：输入一个正整数。求出所有素数
　　要求：写出f(n)， 列出所有仅能被2和自身整除的数。　　

public static void RunSnippet()
{
    int a = Convert.ToInt32(Console.ReadLine());
    if(a<3) 
    {
        Console.WriteLine(2);
        return;
    }
    IList<int> su = new List<int>();
    for(int i=3;i<a;i+=2)
    {
        int j=0;
        for(j=2;j<=i/2;j++)
        {
            if(i%j==0)
            {
                break;
            }
        }
        if(j>i/2)
        {
            su.Add(i);
        }
    }
    foreach(int i in su)
    {
        Console.Write(i.ToString()+';');
    }
}

　　解析：比较简单的题目，按照题意遍历就可以了，不过个人感觉效率不行，大于100W速度就不行了。
　　扩展：待补充...

　　8： 面试题：求两个数字的最大公约数
　　简述：输入两个正整数，求出最大公约数。
　　要求：写出f(n)，求出最大的能被两个数整除的数。　　

public static void RunSnippet()
{
    int a= Convert.ToInt32(Console.ReadLine());
    int b= Convert.ToInt32(Console.ReadLine());
    int temp = 1;
    while(temp != 0)
    {
        if(a>b)
        {
            temp=a%b;
            a=b;
            b=temp;
        }
        else
        {
            temp=b%a;
            b=temp;
        }
    }
    Console.WriteLine(a);
}

　　解析：根据最大公约数的定义来编程，大数整除小数取余；然后小数作为大数，余数作为小数继续上一步骤，直到余数为0，则最后那个小数为最大公约数。
　　扩展：待补充...

　　9： 面试题：产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
　　简述：生成一个数组，长度为100，用1-100的随机数填充此数组，数组中的数字不能重复。
　　要求：写出f(n)，完成需求，不能使用hashtable等集合类型。　

public static void RunSnippet()
{
    int[] all = new int[100];
        Random ro = new Random();
        int newInt = 0;
        for (int i = 0; i < 100; i++)
        {
            bool insert = false;
            while (insert == false)
            {
                insert = true;
                newInt = ro.Next(1, 101);
                for (int j = 0; j < i; j++)
                {
                    if (all[j] == newInt)
                    {
                        insert = false;
                        break;
                    }
                }
            }
            all[i] = newInt;
        }

        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(all[i]);
        }
        Console.ReadLine();
}

　　解析：题目不难，就是取随机数插入数组，每次取得随机数都和数组中现有数字比较，如果已经存在那就重新取随机数，当然我提供的算法只是简单的提供一下思路，还有很大的优化空间。
　　扩展：待补充...