简单算法

  partial class Program
    {
        //初始数组
        static int[] array = { 12, 16, 17, 19, 10, 2, 18 };

        static void Main(string[] args)
        {
            //原始输出
            //array.Print();

            ////顺序查找
            //int pos = Search(17);
            //Console.WriteLine(pos == -1 ? "无" : "位置索引:" + pos);

            ////折半查找
            //int pos = BinarySearch(17);
            //Console.WriteLine(pos == -1 ? "无" : "位置索引:" + pos);
            
            //冒泡排序
            //BubbleSort();

            //选择排序
            //SelectionSort();

            //插入排序
            InsertSort();

            //希尔排序
            //ShellSort();

            //快速排序
            //QuickSort(array,0,array.Length-1);

            //array.Print();

            Console.ReadLine();
        }

 

partial class Program
    {
        /// <summary>
        /// 顺序查找
        /// </summary>
        /// <param></param>
        /// <returns></returns>
        static int Search(int value)
        {
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] == value)
                {
                    return i;
                }
            }
            return -1;

        }

        /// <summary>
        /// 二分法查找
        /// </summary>
        /// <param></param>
        /// <returns></returns>
        static int BinarySearch(int value,int [] array)
        {
            int low = 0;
            int pow = array.Length;
            int middle = 0;

            while (true)
            {
                middle = (low + pow) / 2;
                if (array[middle] == value)
                {
                    return middle;
                }
                else if (low > pow)
                {
                    return -1;
                }
                else
                {
                    if (array[middle] > value)
                    {
                        pow = middle - 1;
                    }
                    else
                    {
                        low = middle + 1;
                    }
                }
            }
        }
    }

 

partial class Program
    {
        /// <summary>
        /// 冒泡排序
        /// </summary>
        static void BubbleSort()
        {
            int tmp = 0;
            for (int i = 0; i < array.Length-1; i++)
            {
                for (int j = array.Length - 1; j > i; j--)
                {
                    if (array[j] < array[j - 1])
                    {
                        tmp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = tmp;
                    }
                }
            }
        }

        /// <summary>
        /// 选择排序
        /// </summary>
        static void SelectionSort()
        {
            int tmp = 0;
            int k = 0;
            for (int i = 0; i < array.Length - 1; i++)
            {
                k = i;
                for (int j = i; j < array.Length ;j++ )
                {
                    if (array[j] < array[k])
                    {
                        k = j;
                    }
                }
                tmp = array[i];
                array[i] = array[k];
                array[k] = tmp;
            }
        }

        /// <summary>
        /// 直接插入排序
        /// </summary>
        static void InsertSort()
        {
            int tmp = 0;            
            for (int i = 1; i < array.Length ; i++)
            {
                tmp = array[i];
                int j = i;
                while (j > 0 && array[j] >= tmp)
                {
                    array[j] = array[j - 1];
                    j--;
                }
                array[j] = tmp;
            }
        }

        /// <summary>
        /// 希尔排序---改进的插入排序
        /// </summary>
        static void ShellSort()
        {
            // 求最大步长
            int h = 1;
            while (h < array.Length / 3)
            {
                h = h * 3 + 1;
            }
            //插入排序
            while (h > 0)
            {
                int tmp = 0;
                for (int i = h; i < array.Length; i++)
                {
                    tmp = array[i];
                    int j = i;
                    while (j > h-1 && array[j - h] >= tmp)
                    {
                        array[j] = array[j - h];
                        j-=h;
                    }
                    array[j] = tmp;
                }
                //减少步长
                h = (h - 1) / 3;
            }          

        }

        /// <summary>
        /// 分组
        /// </summary>
        /// <param>排序数组</param>
        /// <param>排序元素起始索引</param>
        /// <param>排序元素结束索引</param>
        /// <param'>关键点key</param>
        /// <returns>返回关键点</returns>
        static int Partition(int[] arr,int left, int right, int point)
        {
            int leftptr = left - 1;
            int rightptr = right;
            int tmp = 0;

            while (true)
            {
                while (leftptr < rightptr && arr[++leftptr] < point) ;

                while (leftptr < rightptr && arr[--rightptr] > point) ;

                if (leftptr >= rightptr)
                {
                    break;
                }
                else
                {
                    tmp = arr[leftptr];
                    arr[leftptr] = arr[rightptr];
                    arr[rightptr] = tmp;
                }                
            }
            tmp=arr[leftptr];
            arr[leftptr] = arr[rightptr];
            arr[rightptr] = tmp;

            return leftptr;
            
        }

        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param>排序数组</param>
        /// <param>排序元素起始索引</param>
        /// <param>排序元素结束索引</param>
        static void QuickSort(int[] arr,int left,int right)
        {
            if (right <= left)
            {
                return;
            }
            else
            {
                int point = arr[right];

                //找到的中间点
                int partition = Partition(arr, left, right, point);
                //将中间点置于partition位置
                int i = right;
                for (; i > partition; i--)
                {
                    arr[i] = arr[i - 1];
                }
                arr[i] = point;
                //递归
                QuickSort(arr, left, partition - 1);

                QuickSort(arr, partition + 1, right);
            }
        }
    }