C#基础查找算法总结：顺序查找，优化顺序查找，二叉查找（递归和非递归）

一、顺序查找：顾名思义，就是从头开始一直找到结束，找到了就返回，否则继续找，找完了没找到就返回-1

        static int SequenceFind(int[] arr,int value)
        {
            for (int i = 0; i < arr.Length-1; i++)
            {
                if(arr[i] == value)
                {
                    return i;
                }
            }
            return -1;
        }

注：顺序查找不要求序列有序的。

问题：每次都这样找比较耗时，我们可以将常查找的数据移到序列的前面。函数修改为：

        static int SequenceFind(int[] arr,int value)
        {
            int count = 0;
            for (int i = 0; i < arr.Length-1; i++)
            {
                count++;
                if(arr[i] == value)
                {
                    WriteLine("查找次数为：" + count);
                    if(i!= 0)
                    {
                        Swap(ref arr[i-1],ref arr[i]);
                    }
                    return i;
                }
            }
            return -1;
        }
        static void Swap(ref int a , ref int b)
        {
            int temp = a;
            a = b;
            b = temp;
        }

注：由于int是值类型，在参数传递的时候是传的拷贝，为了传引用我们需要使用引用传递。当然，还有一些优化办法，例如如果数据所在的位置在后80%才进行交换。

二、二叉查找

二叉查找也叫二分查找（跟二叉查找树原理类似，但数据存储方式不同），它效率高，但是有一个明确的要求就是必须是有序的线性结构，在C#中常用Array，ArrayList，List等数据结构。

二叉查找非递归版：

        static int BinaryFind1(int[] arr, int value)
        {
            int upperBound, lowerBound, mid;
            upperBound = arr.Length - 1;
            lowerBound = 0;
            int count = 1;
            while (lowerBound <= upperBound)
            {
                mid = (upperBound + lowerBound) / 2;
                if (arr[mid] == value)
                {
                    WriteLine(count);
                    return mid;
                }
                else
                {
                    if (value < arr[mid])
                    {
                        count++;
                        upperBound = mid - 1;
                    }
                    else
                    {
                        count++;
                        lowerBound = mid + 1;
                    }
                }
            }
            return -1;
        }

二分查找递归版：

static int BinaryFind2(int[] arr, int lowerBound, int upperBound, int val)
        {
            if (lowerBound > upperBound)
            {
                return -1;
            }
            int mid = (lowerBound + upperBound) / 2;
            if (arr[mid] == val)
            {
                return mid;
            }
            else if (arr[mid] > val)
            {
                return BinaryFind2(arr, lowerBound, mid - 1, val);
            }
            else
            {
                return BinaryFind2(arr, mid + 1, upperBound, val);
            }
        }

递归版代码更加简洁，但是注意，递归版的效率较循环来说是更差的。