我的读书笔记（排序算法）

1.快速排序

• 假设待排序的序列为L[m...n],而一趟排序目的就是将其分割为两个子序列，分别为L[m...middle-1]和L[middle+1...n]，其中L[m...middle-1]中的每个元素都小于L[middle],而L[middle+1...n]中的每个元素都大于L[middle]
• 递归调用快速排序算法，对L[m...middle-1]和L[middle+1..n]分别进行排序
• 由于是原地排序，所以递归结束后就自然形成了有序序列

　　　　　/// <summary>
        /// 快速排序算法
        /// </summary>
        /// <param name="data">排序数组</param>
        /// <param name="low">排序下限</param>
        /// <param name="high">排序上限</param>
        static void Run(int[] data,int low, int high) 
        {
            //简单设定中间值，并以此为一趟排序的分割点
            //注意这里是一个简单的算法
            //如果想对这个算法进行优化的话，可以采取随机的方法来获取分割点
            int middle = data[(low+high)/2];
            int i = low;
            int j = high;
            do
            {
                //扫描middle值左边的元素
                while (data[i] < middle && i < high)
                    i++;
                //扫描middle值右边的元素
                while (data[j] > middle && j > low)
                    j--;
                //找到了一个可以交换的值
                if (i <= j)
                {
                    //交换
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                    i++;
                    j--;
                }

            } while (i <= j);
            //递归对比分割点元素都小的那个序列进行快速排序
            if (j > low)
                Run(data,low,j);
            //递归对比分割点元素都大的那个序列进行快速排序
            if(i<high)
                Run(data,i,high);
        }

　　快速排序在最坏的情况下运行时间为0（n*n）平均运行时间为O(nlgn),快速排序的排序对象都读入内存中，所以输入内部排序，快速排序基于比较关键字来确定元素的位置，所以它属于比较排序，同时，快速排序具有原地排序特性和不稳定特性，这意味着快速排序不需要额外的排序空间，但是不能确保相等元素位置不被交换。

2.二分法查找算法

• 在一个有序序列L[m...n]查找元素k,先比较L[(m+n)/2]的值和元素K，如果相等则返回（m+n）/2
• 如果L[(m+n)/2]的值比K小，则在L[(m+n)/2+1...n]中使用二分法查找K
• 如果L[(m+n)/2]的值比K大，则在L[m...(m+n)/2-1]中使用二分法查找K

static int Search(int[] data ,int val) 
        {
            //如果数组为空，则直接返回-1
            if (data.Length <= 0) return -1;
            //设置初始化上下限为数组的上下限
            int low = 0;
            int high = data.Length - 1;
            //循环二分法查找，直至找到或者查找完毕
            while(low<=high)
            {
                //找到制定元素
                int middle = (low + high) / 2;
                if (data[middle] == val)
                    return middle;
                //对二分后较大的那一半序列进行查找
                else if (data[middle] < val)
                    low = middle + 1;
                //对二分后较小的那一半序列进行查找
                else
                    high = middle - 1;
            }
            //二分结束仍没找到指定元素
            return -1;
        }