算法排序

　　　　 #region 二分查找法
        public static int BinarySertch(int[] arr, int startIndex, int endIndex, int result) 
        {
            if (startIndex > endIndex) 
            {
                return -1;
            }

            int midIndex = (endIndex - startIndex) / 2 + startIndex;
            if (result > arr[midIndex])
            {
                return BinarySertch(arr, midIndex + 1, endIndex, result);
            } 
            else if (result < arr[midIndex])
            {
                return BinarySertch(arr, startIndex, midIndex - 1, result);
            }
            else 
            {
                return arr[midIndex];
            }
        }
        #endregion

    public abstract class BaseSort
    {
        public bool Compare(int num1, int num2) 
        {
            return num1 < num2;
        }

        public void Exchange(int[] arrs, int index1, int index2) 
        {
            int item = arrs[index1];
            arrs[index1] = arrs[index2];
            arrs[index2] = item;
        }
        public abstract void Sort(int[] arrs);
    }

　　#region 选择排序
    internal class ChooseSort : BaseSort
    {
        
        public override void Sort(int[] arrs) 
        {
            
            for (int i = 0; i < arrs.Length - 1; i++)
            {
                int length = i;
                for (int j = i + 1; j < arrs.Length; j++)
                {
                    if (!Compare(arrs[i], arrs[j]))
                    {
                        length = j;
                    }
                }
                if (length != i) 
                {
                    Exchange(arrs, i, length);
                }
            }   
        }
        
    }
    #endregion

    #region 插入排序
    internal class InsertionSort : BaseSort
    {

        public override void Sort(int[] arrs)
        {
            for (int i = 1; i < arrs.Length; i++)
            {
                for (int j = i; j > 0 && Compare(arrs[j], arrs[j - 1]); j--)
                {
                    Exchange(arrs, j, j - 1);
                }
            }
        }
    }
    #endregion

    //希尔排序
    internal class ShellSort : BaseSort
    {
        public override void Sort(int[] arrs)
        {
            int arrslength = arrs.Length;
            int temp, len = arrslength / 2;
            while (len > 0)
            {
                for (int i = len; i < arrslength; i++)
                {
                    temp = arrs[i];
                    int preIndex = i - len;
                    while (preIndex >= 0 && arrs[preIndex] > temp)
                    {
                        arrs[preIndex + len] = arrs[preIndex];
                        preIndex -= len;
                    }
                    arrs[preIndex + len] = temp;
                }
                len /= 2;
            }

        }
    }

　　

    
　　//堆排序
　　internal class HeapSort : BaseSort
    {
        public override void Sort(int[] arrs)
        {
            Heap_Sort(arrs, arrs.Length);
        }

        private void Heap_Sort(int[] arr, int n)
        {
            //创建堆 拿最后一个节点的父节点进行排序
            for (int i = n / 2 - 1; i >= 0; i--)
            {
                Heapify(arr, n, i);
            }
            //排序
            for (int i = n - 1; i > 0; i--)
            {
                // 弹出最大的 然后继续按照堆的原则进行排序
                Exchange(arr, i, 0);
                Heapify(arr, i, 0);
            }
        }

        private void Heapify(int[] arr, int n, int i) 
        {
            int largest = i;
            int lson = i * 2 + 1;
            int rson = i * 2 + 2;
            if (lson < n && arr[largest] < arr[lson]) 
            {
                largest = lson;
            }
            if (rson < n && arr[largest] < arr[rson]) 
            {
                largest = rson;
            }
            if (largest != i) 
            {
                Exchange(arr, largest, i);
                Heapify(arr, n, largest);
            }
        }