排序及查找----[(冒泡,快速)(拉格朗日,二分)]

代码展示:

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

namespace paixu
{
    class Program
    {
        static void Main()
        {
            int[] Array = { 1, 45, 8, 65, 478, 5, 56, 1, 0, -87, 878, 4, 64 };

            MaoPao(Array);
             Console.WriteLine("-----------冒泡--------------------------");
            KuaiSu01(Array);
             Console.WriteLine("-----------快速法(一)-------------------");            
             KuaiSu02(Array);
             Console.WriteLine("-----------快速法(二)-------------------");
            
string x = "=========以下两种查找方法必须要有序数组=============";

             LaGeLangRi(Array, 878);
             Console.WriteLine("-----------拉格朗日插值查找法-----------");           
            Dichotomy(Array,0);
             Console.WriteLine("-----------二分法查找法-----------------");
            
             Console.Read();
        }
//---------------------冒泡------------------------------------------------
        public static void MaoPao( int [] array) 
        {
            int temp = 0;
            for (int i = 0; i < array.Length-1; i++)
            {
                for (int j = 0; j < array.Length - 1 - i; j++)
                {
                    if (array[j] > array[j + 1])
                    {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;                    
                    }               
                }
            }
            foreach (int  item in array)
            {
                Console.WriteLine(item);
            }
        }
//---------------------快速(法一)------------------------------------------------------
        public static void KuaiSu01( int [] array)
        {
            List <int> list = array.ToList();
            QuickSort(list, 0, array.Length - 1);
            foreach (int  i in list)
            {
                Console.WriteLine(i.ToString());
            }
        }
        private static int Division(List<int> list, int left, int right)//获取按枢轴值左右分流后枢轴的位置
        {
            while (left < right)
            {
                int num = list[left]; //将首元素作为枢轴
                if (num > list[left + 1])
                {
                    list[left] = list[left + 1];
                    list[left + 1] = num;
                    left++;
                }
                else
                {
                    int temp = list[right];
                    list[right] = list[left + 1];
                    list[left + 1] = temp;
                    right--;
                }  
            }
            return left; //指向的此时枢轴的位置
        }
        private static void QuickSort(List<int> list, int left, int right)//递归进行操作
        {
            if (left < right)
            {
                int i = Division(list, left, right);
                //对枢轴的左边部分进行排序
                QuickSort(list, i + 1, right);
                //对枢轴的右边部分进行排序
                QuickSort(list, left, i - 1);
            }
        }
//---------------------快速(法二)-------------------------------------------------------
        public static void KuaiSu02(int[] array)
        {
          
            Sort(array, 0, array.Length);
            foreach (int i in array)
            {
                Console.WriteLine(i.ToString());
            }
        }
       public static void Sort(int[] nums, int left, int right)//数组,起始下标,数组长度
        {
            if (left < right)    //直到排序的左右区间只剩一个值
            {
                int i = left;
                int j = right - 1;
                int middle = nums[(left + right) / 2];
                while (true)
                {
                    while (i < right && nums[i] < middle) { i++; }; 
                       //在middle左边找到一个比middle小的值
                    while (j > 0 && nums[j] > middle) { j--; };   
                          //在middle右边找到一个比middle大的值
                    if (i == j) {break; } 
               //当i=j时,middle左边都是比middle小的数,右边都是比middle大的;跳出循环
                    nums[i] = nums[i] + nums[j];
                    nums[j] = nums[i] - nums[j];
                    nums[i] = nums[i] - nums[j];     //两个值交换位置
                    if (nums[i] == nums[j]) { j--; }
                       //如果两个值相等,且等于middle,为避免进入死循环,j--
                }
                Sort(nums, left, i);           //递归 
                Sort(nums, i + 1, right);
            }
        }

       //--------拉格朗日插值查找法(相同元素返回第一个元素下标)-----------------         
       public static int LaGeLangRi(int[] a, int key)
        {
             int tou=0;
            int wei=a.Length-1;
            int  zhong =0;
            while(tou<=wei)
            {
                zhong = tou + (wei - tou) * (key - a[tou]) / (a[wei] - a[tou]);
                if (key == a[zhong]) { break; }
                else if (key > a[zhong]) { tou = zhong + 1; }
                else{wei=zhong-1;}
            }
            Console.Write(key); Console.WriteLine("---->对应的下标是：" + zhong);           
            return zhong;
            
        }
//-------------------二分查找法(相同元素返回第一个元素下标)------------------------
       public static void Dichotomy(int[] array,int item)
       {          
           int x = BinarySearch(array, 0, array.Length - 1, item);
           Console.Write(item); Console.WriteLine("---->对应的下标是：" + x);                
       } 
        public  static int BinarySearch(int[] arr, int low, int high, int key)
        {
            int mid = (low + high) / 2;
            if (low > high){return -1;}               
            else
            {
                if (arr[mid] == key){ return mid;}                   
                else if (arr[mid] > key){return BinarySearch(arr, low, mid - 1, key);}                    
                else{return BinarySearch(arr, mid + 1, high, key);}                    
            }
            
        }
    }
}

备注:

排序的话,快速排序效率是较高的.