CodeKata02 : Karate chop 折半查找

折半查找

折半查找（binary chop）：在一个已排序的数组中找到某个值的位置。
练习方法：使用不同的技术实现，直到有5种完全不同的实现。比如迭代，递归，或使用函数传递部分数组来实现（functional style passing array slices around）。

目标

• 当编写每个算法时，记录你遇到的错误。经过一周，看是否这些错误的出现的频
  率在下降。（当你改用不同技术编码时，是否能从中学到什么？）

• 总结各个技术的长处，哪个更适合用作一个产品的编码？哪个使用起来最有乐趣？哪个执行起来最困难？每个问题，都问why。

• 找到5个方法实现折半查找是相当困难的，你是如何找到这些方法的（What techniques did you use to fire those “off the wall” neurons? 译作：激活这些古怪的神经元？）

说明

写一个折半查找函数，输入参数为已排序的数组和要查找的Integer值。返回值为数组序号，或者-1表示查找失败。假设数组小于100,000个元素。

int chop(int,arrayOfInt)

练习1：迭代法

迭代：将输出作为输入，再次进行处理。

  private static int chop(int search, int[] array)
        {
            int startIndex = 0;
            int endIndex = array.Length-1;
            int midIndex = 0;
            do
            {//迭代法
                midIndex = startIndex + (endIndex - startIndex) / 2;
                if (search == array[midIndex])
                {
                    return midIndex;
                }else if(search > array[midIndex])
                {
                    startIndex = midIndex+1;
                }else if (search < array[midIndex])
                {
                    endIndex = midIndex-1;
                }

            } while (startIndex <= endIndex);
            return -1;
        }

练习2：递归法

递归：自己调用自己，自己包含自己。

private static int chopRecursion(int search, int[] array,int startIndex, int endIndex)
        {
            int midIndex = startIndex + (endIndex - startIndex) / 2;
            if (startIndex <= endIndex)
            {
                if (search == array[midIndex])
                {
                    return midIndex;
                }
                else if (search > array[midIndex])
                {
                    startIndex = midIndex + 1;
                }
                else if (search < array[midIndex])
                {
                    endIndex = midIndex - 1;
                }
                //自己调用自己，递归
                return chopRecursion(search, array, startIndex, endIndex);

            } 
            else
            {
                return -1;
            }

        }

练习3：

使用函数传递部分数组实现折半查找

        private static int chop3(int search, int[] array,int lastIndex)
        {
            int startIndex = 0;
            int endIndex = array.Length - 1;
            int midIndex = 0;
            int[] newArray;
            const int INT_SIZE = 4;
            if (endIndex>=0)
            {//递归法 + 参数为 部分数组
                midIndex = endIndex  / 2;
                if (search == array[midIndex])
                {
                    return lastIndex + midIndex;
                }
                else if (search > array[midIndex])
                {
                    startIndex=  midIndex + 1;
                    lastIndex += startIndex;
                    newArray = new int[endIndex- startIndex + 1];
                    Buffer.BlockCopy(array, startIndex * INT_SIZE, newArray, 0, (endIndex - startIndex + 1) * INT_SIZE);
                    return chop3(search, newArray, lastIndex);

                }
                else if (search < array[midIndex])
                {
                    endIndex = midIndex - 1;
                    newArray = new int[endIndex+1];
                    Buffer.BlockCopy(array, 0, newArray, 0, (endIndex+1) * INT_SIZE);
                    return chop3(search, newArray, lastIndex);

                }

            } 
            return -1;
        }