折半查找的递归实现和非递归实现

namespace 折半查找实现
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] nums = { 1, 6, 0, 3, 5, 7, 9, 5, 23, 2, 43, 64, 644, 5, 8 };
            //int[] nums = { 0, 3, 6, 9, 13, 15, 23, 56, 89, 100 };
            QuickSort(nums, 0, nums.Length - 1);
            for (int i = 0; i < nums.Length; i++)
            {
                Console.WriteLine(nums[i]);
            }

            if (ZheBan_Search(nums, 0, nums.Length - 1, 9) == -1)
            {

                Console.WriteLine("不存在");
            }
            else
            {
                Console.WriteLine("存在" + "_" + ZheBan_Search(nums, 0, nums.Length - 1, 9));
            }
            Console.ReadKey();
        }

        static int ZheBan_Search(int[] nums, int low, int high, int target)
        {
            #region 递归实现
            if (low <= high)
            {
                int mid = (low + high) / 2;

                if (target == nums[mid])
                {
                    return mid;
                }
                else if (nums[mid] > target)
                {
                    return ZheBan_Search(nums, low, mid - 1, target);
                }
                else if (nums[mid] < target)
                {
                    return ZheBan_Search(nums, mid + 1, high, target);
                }
            }

            return -1;
            #endregion

            #region 非递归实现
            //int low = 0;
            //int high = nums.Length - 1;
            //int mid;

            //while (low <= high)
            //{
            //    mid = (low + high) / 2;
            //    if (nums[mid] < target)
            //    {
            //        low = mid + 1;
            //    }
            //    else if (nums[mid] > target)
            //    {
            //        high = mid - 1;
            //    }
            //    else
            //    {
            //        return true;
            //    }
            //}
            //return false;
            #endregion
        }

        public static void QuickSort(int[] nums, int low, int high)
        {
            if (low < high)
            {
                int pos = FindPos(nums, low, high);
                QuickSort(nums, low, pos - 1);
                QuickSort(nums, pos + 1, high);
            }
        }

        static int FindPos(int[] nums, int low, int high)
        {
            int val = nums[low];

            while (low < high)
            {
                while (low < high && nums[high] >= val)
                {
                    --high;
                }
                nums[low] = nums[high];

                while (low < high && nums[low] <= val)
                {
                    ++low;
                }
                nums[high] = nums[low];
            }
            nums[low] = val;
            return low;
        }
    }
}