这可能是我见过最详细的选择排序!

Posted 咕咚

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了这可能是我见过最详细的选择排序!相关的知识,希望对你有一定的参考价值。

关于快速排序,网上,和维基都有完成的解释,他们都是。。。。。。,俺觉得都是,太过于总结话语在概述一些东西;

而我却从最本质的东西,一步一步的深入;在深入的学习过程中,我得到如下非代码层面上的感悟;

A.一个完整的模式(代码或者其他东西)都是通过没有=>part0=>part1=>part2>version0=>viersion1.......versionN=>perfect  最后达到一个完成的形式;

如果你只是去学习和体会最后的那一个完成的版本,而没有经历整个探索的过程,你的体会也不会太多;

 

B.有时候要学会抽象化和跳跃化的去思考问题,而不是step by step(这有点不具体,下次我结合具体的实例来解释)

 

C.帮助别人解决问题;并不是直接给出问题的答案或者结果;而是给别人一些引导和资源,让他自己去解决;(这点来自使用stackoverflow提问的感受)

 

D.还有第四点,要学会从特殊(具体)到一般(抽象)的探索过程;比如,我们可以先总结出满足大于零的规律,然后是小于零的规律,然后是等于零的规律,这些都是特殊(或者你可以理解成具体);从这些特殊规律总结出一般性(通用性)的规律;

 

E.还有当研究出了算法之后,要学会如何去验证自己的一般性规律,在我们的code,就是要学会写测试用例,进行验证;

 

好了,废话不多了;直接从代码开始;开始之前,想尝试做下面的practice;

 

1.选择数组的第一个data(target)将数组分成两部分;满足:   minArr<target<=maxArr;

 

2.选择数组的第一个data(target)将数组分成两部分;满足:   minArr<target<=maxArr; 并将target 放入数组“中间位置“;满足:  target greater than left data and less than right data;

 

3.找出value 在有序数组中的位置;

 

4.找出value 在无序数组中的位置;这个位置应该满足,它在有序数组中应该具有的位置;greater than left data and less than right data;

 

5.在不开辟内存的情况下(使用新的数组来存储值)完成问题2;

 

6.关于递归的学习和使用(具体看这篇文章的后半部分:http://www.cnblogs.com/mc67/p/5114008.html

 

7.三种方式来实现我们的额快速排序;(本质的区别只有两种)

 

8.通过Unit Test 来验证我们的代码;

 

 

关于前面的 5个问题,我就直接上代码;你细细品味(建议在没有看代码前,完成上面的问题)

 

 /// <summary>
        /// 最基本的;将数组分成两部分;一部分比target小,一部分比target大;
        /// </summary>
        /// <param name="arr"></param>
        static void SplitArray(int[] arr)
        {
            int len = arr.Length;
            int target = arr[0];
            List<int> min = new List<int>(len); //为了方便,这里我使用List
            List<int> max = new List<int>(len); //为了方便,这里我使用List
            for (int i = 1; i < len; i++) //从第二个元素开始查找;
            {
                if (arr[i] < target)
                {
                    min.Add(arr[i]);
                }
                else
                {
                    max.Add(arr[i]);  // as euqual condition,I put it into max;
                }
            }

        }
        /// <summary>
        /// split the arr and put the target in the right position(greater than left ,less than right)
        /// </summary>
        /// <param name="arr"></param>
        static void SplitArray1(int[] arr)
        {
            int len = arr.Length;
            int target = arr[0];
            List<int> min = new List<int>(len); //为了方便,这里我使用List
            List<int> max = new List<int>(len); //为了方便,这里我使用List
            for (int i = 1; i < len; i++) //从第二个元素开始查找;
            {
                if (arr[i] < target)
                {
                    min.Add(arr[i]);
                }
            }
            //put it in the last of min, that can make sure target greater than min(left)
            min.Add(target);
            for (int i = 1; i < len; i++) //从第二个元素开始查找;
            {
                if (arr[i] > target)
                {
                    max.Add(arr[i]);
                }
            }

            min.AddRange(max); //that can make sure  min<target<max
        }

        /// <summary>
        /// optimze the SplitArray1
        /// 上面的代码,还是有问题的,如果有重复的值,那么,将在判断max的时候丢掉;
        /// 那么问题来了,如果相等的如何判断呢;
        /// </summary>
        /// <param name="arr"></param>
        static void SplitArray2(int[] arr)
        {
            int len = arr.Length;
            int target = arr[0];
            List<int> min = new List<int>(len); //为了方便,这里我使用List
            List<int> max = new List<int>(len); //为了方便,这里我使用List
            for (int i = 1; i < len; i++) //从第二个元素开始查找;
            {
                if (arr[i] < target)
                {
                    min.Add(arr[i]);
                }
            }
            //put it in the last of min, that can make sure target greater than min(left)
            min.Add(target);
            for (int i = 1; i < len; i++) //从第二个元素开始查找;
            {
                if (arr[i] >= target) //我们把等于符号加上,就解决问了???? 对于本例子,是从arr[0] 开始的;//那如果是从别的位置开始呢;
                {
                    max.Add(arr[i]);
                }
            }

        }


        /// <summary>
        /// start from random index;
        /// </summary>
        /// <param name="arr"></param>
        static void SplitArray3(int[] arr)
        {
            int len = arr.Length;
            int randomIndex = 2;
            int target = arr[randomIndex]; //假设,我们从index=2 开始,这里,我们肯定满足arr.length>=2;

            List<int> min = new List<int>(len); //为了方便,这里我使用List
            List<int> max = new List<int>(len); //为了方便,这里我使用List
            for (int i = 0; i < len; i++) //这里,我们就要从0 开始了,遍历整个数组;
            {
                if (arr[i] < target)
                {
                    min.Add(arr[i]);
                }
            }
            min.Add(target);
            for (int i = 0; i < len; i++) //这里,我们就要从0 开始了,遍历整个数组;
            {
                if (arr[i] >= target && i != randomIndex) //加上这个条件,我们就可以过滤到我们的 randomIndex 避免重复添加的问题; 
                {
                    max.Add(arr[i]);
                }
            }

            //最后,我们的数组,就是符合我们要求的数组;
        }


        //上面的做法;可以满足  min<target<=max
        /// <summary>
        /// 我们来找出元素所在的位置 index 首先是我们的有序数组中
        /// 通过值相等来进行判断的话,可以满足;
        /// 不管值有序 还是 无序的值;
        /// </summary>
        static void FindIndex(int[] arr, int value)
        {

            int len = arr.Length;
            int index = -1;
            for (int i = 0; i < len; i++)
            {
                if (arr[i] == value)
                {
                    index = i;
                    break;
                }
            }
        }

        /// <summary>
        /// 两种思维方式,
        /// 两种思维方式;第二种,更接近普通人的表达方式;
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="value"></param>
        static void FindIndex1(int[] arr, int value)
        {

            int len = arr.Length;
            int index;
            bool isExist = false;
            for (int i = 0; i < len; i++)
            {
                if (arr[i] == value)
                {
                    index = i;
                    isExist = true;
                    break;
                }
            }
            if (isExist == false) { index = 1; }
        }

        /// <summary>
        /// 上面的方法是找到,value,在数组中的第一个index 值; 不管它是否有序;
        /// 现在我们要找一个元素,在有序列表中的(应该插入的值,但是我们不插入)
        /// </summary>
        static void FindIndex2(int[] arr, int value)
        {

            int len = arr.Length;
            int index = -1;
            for (int i = 0; i < len; i++)
            {
                //你可以这么想;
                //如果找到大于大的数就停止;否则就继续
                if (arr[i] >= value)  //考虑到取等情况;
                {
                    index = i; //这个时候,我们的数据,就可以插入在改元素的的后面;
                    index = index - 1;  //这样就返回了可以直接插入的位置;
                    //并且停止我们的循环;
                    break;    //前提是有序的数组列表中
                }
            }

            //在插入的时候,就必须把后面的元素往后面挪动;
            //插入的时候,
        }

        /// <summary>
        /// 上面的方法是找到,value,在数组中的第一个index 值; 不管它是否有序;
        /// 现在我们要找一个元素,在有序列表中的(应该插入的值,但是我们不插入)
        ///  2 和 3 两种不同的想法,写出来的code 就不太一样;
        /// </summary>
        static void FindIndex3(int[] arr, int value)
        {

            int len = arr.Length;
            int index = -1;
            for (int i = 0; i < len; i++)
            {
                //我们可以可以这么想; 
                if (arr[i] <= value)
                {
                    index++;  //小于它的值,我们的index 就 keep move forward;  还没考虑,我们取等的情况滴呀;
                }
                else
                {
                    //遇到,不满足的情况,我们就退出
                    //原本的我们的index 是落后于我们的i,出去的时候;再加一次,
                    index++;
                    break;
                }
            }

            //这样就找到了我们的index;在一个可以插入的位置;
        }


        /// <summary>
        /// 先这样来想,找出小于 value的count,那么value在的位置应该就是在我们的count+1;
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="value"></param>
        static void FindCountLessThan(int[] arr, int value)
        {
            int len = arr.Length;
            int count = 0;
            for (int i = 0; i < len; i++)
            {
                if (arr[i] <= value)
                {
                    count++;
                }
            }

            //这样,我们就能够找出小于count的数量;那么 我们value所在的位置就是我们count+1
        }

        /// <summary>
        /// 关键的来了:找到value 应该在的位置;在一个无序的数组中;
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="value"></param>
        static void FindIndexInUnSortArr(int[] arr, int value)
        {
            int len = arr.Length;
            int rightPosition = 0;  //初始化,默认我们的指针在0位置;
            for (int i = 0; i < len; i++)
            {
                //通过遍历来查找;
                if (arr[i] <= value)
                {
                    rightPosition++;
                }
            }
        }

        /// <summary>
        /// 找到index在的位置,并将小于value的数据放在左边,大于value的数据放在右边
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="value"></param>
        static void FindeAndSwap(int[] arr)
        {

            int len = arr.Length;
            int middleIndex = 1;
            int value = arr[0];//target;

            // i 能找到一个小于value的值;
            //middleIndex 始终指向一个大于或等于 value的值;
            for (int i = 1; i < len; i++)
            {
                if (arr[i] <= value) //当找到一个小于value的值之后,进行交换,和那个值进行交换呢;(原则:小的值移动到左边,大的值移动到右边;)
                {                    //现在,我们找到了小的值,那么大的值呢;????
                    if (i == middleIndex)
                    {
                        //不进行交换; keep move
                    }
                    else
                    {
                        Swap(arr, middleIndex, i);
                    }
                    middleIndex++;
                }
            }

            //最后出来后,我们要将第一个元素和中间的元素进行交换,也就是讲value放在middle的位置;
            Swap(arr, 0, middleIndex - 1);
        }

        /// <summary>
        ///  上面的代码,基本上已经满足了我们额基本要求;
        ///  完美的代码,解决了这个问题;
        /// </summary>
        /// <param name="arr"></param>
        static int FindeAndSwap1(int[] arr, int start, int end)
        {
            int middlePosition = start + 1;
            int pivot = arr[start];

            for (int i = start + 1; i <= end; i++)
            {

                if (arr[i] <= pivot)
                {
                    if (i == middlePosition)
                    {
                        //there is need to swap 
                    }
                    else
                    {
                        Swap(arr, middlePosition, i);
                    }
                    middlePosition++;
                }

            }
            //put the arr[start] in "middle position"(greater than left,less than right)
            int position = middlePosition - 1;
            Swap(arr, arr[start], position);
            return position;
        }

        /// <summary>
        /// 同样,我们又第二种方式来实现,
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        static void FindeAndSwap2(int[] arr, int low,int high)
        {
            
            int l = low-1;  //make sure pointer move firstly (before take value from arr to compare with pviot)
            int h = high+1; //make sure pointer move firstly (before take value from arr to compare with pviot)
            int pviot = arr[low]; 
            while (l<h)
            {
                while (arr[--h]> pviot) //find some value less than pvoit
                {

                }
                while (arr[++l] <= pviot) //find some value greater than pvoit   we use <= instead of <;beacause we don\'t let arr[start] swap 
                {

                }
                if (l < h)
                {
                  Swap(arr, h, l);  //swap
                }
            }            
            Swap(arr, low, h);    //put the povit in the "middle" Position

        }

        /// <summary>
        /// 同样,我们也有第三种写法;
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        static int FindeAndSwap3(int[] arr, int low, int high)
        {
            int l = low;
            int h = high;
            int pviot = arr[low];

            while (l < h)
            {
                while (arr[h] >= pviot) //chose >= instead of >; beca if the first value arr[h] equal  pviot ,this will enter endless loop;(don\'t enter {} do h--;)
                {
                    h--;
                }
                while (arr[l] <= pviot)  //we chose <= instead of < to make sure pviot don\'t take part in swap, we will swap in the last step with "middle" position
                {
                    l++;
                }
                if (l >= h)
                    break;
                Swap(arr,l,h);
            }
            int middlePosition = h;
            Swap(arr,low, middlePosition);
            return middlePosition;
        }

        /// <summary>
        /// 当然,就有了,我们的第四种方法;
        /// 你会发现,前面的方法都是,先找到一个小于的index  high 然后找到一个大于的index low
        /// 然后进行交换;
        /// 然后有没有其他的方式呢? 
        /// 答案是有的;
        /// 而且,你会发现,我们的额pvoit 是没有参与swap的,直到我们的最后一步,然后将起放在 middle position(这一步,是不可避免滴呀)
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        static int FindeAndSwap4(int[] arr, int low, int high)
        {
            int pviot = arr[low];

            while (low < high)
            {
                while(arr[high]>=pviot && low < high)
                {
                    high--;
                }
                //一旦,找到了,我们就替换;
                arr[low] = arr[high];  //这样,会覆盖我们的第一个值,不过,在最后,我们会将第一个值,放在“中间”位置;
                while (arr[low] <= pviot && low < high)
                {
                    low++;
                } //这样做的话,在没有,进行到最后一步,数组中会有一个重复的值,不过,我们最后将被我们pviot
                arr[high] = arr[low];
            }
            arr[low] = pviot;
            return high;
        }

        //到了这一步,我们的基本核心的单元,算是基本基本完整了;
        //然后,我们这里,再实现,三个版本的快速排序;方法;


        /// <summary>
        /// 交换
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="i"></param>
        /// <param name="j"></param>
        static void Swap(int[] arr, int i, int j)
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

 

 1.然后是快速排序的第一种实现方式:(从两端申明指针然后,开始查找; 这个算法是有问题的:to do.....做单元测试来一步一步的发现问题)

        /// <summary>
        /// 第一种实现方式,从两边开始查找;
        /// 还有一个值得考虑问题就是,等于的数据,如何处理呢;从我们的代码看出,等于pviot的数据,没有参与到交换中;
        /// 第一次交换之后将流在我们的 两端;参与下一次的交换;
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        static int QuickSortUnit(int[] arr, int low, int high)
        {
int pviot=arr[low]; //we chose the first value as pivot;
while (low < high) { while (arr[high] >= pviot && low<high) //>= instead of > because: if the arr[high] less than pviot,that will result in endless loop(high index never do high--;) { high--; //start search from high address } while (arr[low] <= pviot && low<high) // <= instead of < becuase:we can make sure arr[first] did\'t involve the whole swap until the ending { low++; //start search from low address } //we both chose equal,after first loop,the equivalent will remianing the origial positon and take part in next sort; that does\'t affect the final result; if (low >= high) break; Swap(arr, low, high); } //because we firstly star from high; so the last value that must less than pviot;so high is our "middle" position; int middlePosition = high; //make the code easy to read; Swap(arr,middlePosition,low); return high; } /// <summary> /// recurion to resolve the same problem; /// </summary> /// <param name="arr"></param> /// <param name="low"></param> /// <param name="high"></param> static void QuickSort(int [] arr,int low,int high) { if (low >= high) //make sure recusion can stop return; int middlePositon=QuickSortUnit(arr,low,high); //star from left; QuickSort(arr,low, middlePositon-1); //star from right QuickSort(arr, middlePositon+1,high); }

2.然后是快速排序的第二种实现方式(本质上和第一种方式一样的,只不过写法(想法),略有不同,一旦找到元素就开始覆盖指定位置的值,这样每次都会有一个重复的值,不过这个重复的值,最后会被我们的pivot给占据)

        /// <summary>
        /// 
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        static int QuickSortUnit(int[] arr, int low, int high)
        {
            int pviot = arr[low];

            while (low < high)
            {
                while (arr[high] >= pviot && low<high)
                {
                    high--;
                }
                arr[low] = arr[high]; //once find the value less than pviot ,put it in low address;
                while (arr[low] <= pviot && low < high)
                {
                    low++;
                }
                arr[high] = arr[low]; //once find the value greater than pviot, put it in high address;
            }

            int middlePositon = high;
            arr[low] = pviot; 
            return middlePositon;

        }

        /// <summary>
        /// use recursion to resovle the same problem;
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        static void QuickSort(int [] arr,int low,int high)
        {

            if (low >= high)
                return;
            int middlePosition = QuickSortUnit(arr,low,high);

             QuickSortUnit(arr, low, middlePosition-1);

             QuickSortUnit(arr, middlePosition+1, high);

        }

思考:

   最后一步交互为哈一定要取low呢;(debug 一下这个:    var arr = new[] { 7, 8, 7 };)

 

 

第三种方式;其实,本质是一样,不过,这种方式,不用从两端申明pointer,去查找(伴随着两个while循环);这里我们用一个循环,还是两个pointer,不过他们的出发位置,就有所不同了,都从左边开始;

 提现了不同的思路去解决问题;

 

 

 最后一种,我们就直接给链接吧;

 https://www.hackerearth.com/zh/practice/algorithms/sorting/quick-sort/tutorial/

非常好的网站;

 

这里,我们再来总结一下,整个执行过程:

1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;
 
2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];
 
3)从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]和A[i]互换;
 
4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]和A[j]互换;