各种排序的动态原理图

http://www.webhek.com/misc/comparison-sort/

看了这个，尝试自己写写

插入排序
*---------------------------*
用递归

首先如果（IntArr[x]）的比后面（IntArr[x+1]）的数大，交换位置
64、13、78、13、46、13、3...
64 > 13
13、64、78、13、46、13、3...
交换位置后，再判断（IntArr[x-1]）是否大于（IntArr[x]）如果大于继续交换位置，反之比对下一个位置（要记住之前处理到何位置）
78 > 13
13、64、13、78、46、13、3...
13、13、64、78、46、13、3...

如果处理位置上[x]的元素比后面元素[x+1]大，那么，交换位置

交换位置后，[x]比前面元素[x-1]小，交换位置，

交换位置后，[x-1]比前面元素[x-2]小，交换位置，

----

直到 [x-n]比前面元素[x-n-1]大或相等，比对[x+1][x+2]

 

循环反复，后面小的元素的位置不断提前，直到比前面元素大或相等，停下

 

        #region 插入排序

        /// <summary>        
        /// http://www.webhek.com/misc/comparison-sort/ 实现插入排序
        /// 前面的比后面的数大，不断的交换位置
        /// </summary>
        /// <param name="intArr"></param>
        /// <returns></returns>
        public int[] GetSort(int[] intArr, int location, ref int count)
        {
            count++;//调用次数            
            if (location >= intArr.Length - 1)//不超过数组范围
            {
                return intArr;
            }
            if (intArr[location] > intArr[location + 1])//和后元素比对
            {
                //调换位置
                int temp = intArr[location];
                intArr[location] = intArr[location + 1];
                intArr[location + 1] = temp;
                //和前元素比对
                if (location > 0 && intArr[location - 1] > intArr[location])
                {
                    GetSort(intArr, location - 1, ref count);
                }
            }
            //下一个位置比对
            GetSort(intArr, location + 1, ref count);
            return intArr;
        }

        //优化，上一个方法，只利用一个变量记录处理位置
        //location有时候升到10，发现前面还有更小的数，10又会减到0，之后+1在升到10

        /// <summary>        
        /// http://www.webhek.com/misc/comparison-sort/ 实现插入排序 //优化版本
        /// 前面的比后面的数大，不断的交换位置
        /// </summary>
        /// <param name="intArr">数组</param>       
        /// <param name="location">数组开始处理下标</param>
        /// <param name="PLocation">已经处理的数组下标</param>
        /// <returns></returns>
        public int[] GetSort(int[] intArr, int location, int PLocation, ref int count)
        {
            count++;
            //限制数组下标，不能超过数组长度
            if (location >= intArr.Length - 1)
            {
                return intArr;
            }

            //记住正在处理的数组下标，
            int processingLocation = location >= PLocation ? location : PLocation;

            //相邻的两个比对
            if (intArr[location] > intArr[location + 1])
            {
                //前面一位比后面大，交换位置
                int temp = intArr[location];
                intArr[location] = intArr[location + 1];
                intArr[location + 1] = temp;
                //交换后，如果前面的数，还是有比之更大的数，再交换
                if (location > 0 && intArr[location - 1] > intArr[location])
                {
                    GetSort(intArr, location - 1, processingLocation, ref count);
                }
            }
            //处理位置不超过数组长度-2，如果等于数组长度-2表示数组数据遍历完成
            if (processingLocation <= intArr.Length - 2)
            {
                GetSort(intArr, processingLocation + 1, processingLocation, ref count);
            }
            return intArr;
        }

        #endregion

 

            //测试
            label1.Text = "";
            int count = 0;
            int[] intArr = new int[] { 64, 13, 78, 13, 46, 13, 3, 73, 17, 24, 64, 14, 27, 74, 97, 61, 41, 31, 5, 2, 6 };//1224 638
            //int[] intArr = new int[] { 9, 4, 5, 7, 6, 8, 3, 1, 2 };//123 65
            //int[] intArr = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 }; //205 121
            int[] result = GetSort(intArr, 0, ref count);
            //int[] result = GetSort(intArr, 0, 0, ref count);
            foreach (var item in result)
            {
                label1.Text += item + "  ";
            }
            MessageBox.Show(count + "");

 

 

选择排序
*---------------------------*

选择排序一直以为是这个

            for (int i = 0; i < intArr.Length; i++)
            {
                for (int j = 0; j < intArr.Length; j++)
                {
                    if (intArr[i] > intArr[j])
                    {
                        .....
                    }
                }
            }

看完图解，感觉不是那么回事

一个数组，两个元素对比，这得双循环

从开头取出一个值，与整个数组对比，取出数组中的最小值，放到开头，

然后从第二个位置取出值与整个数组对比，从剩下的数组元素中找到最小值，放在第二个位子

依次类推...

好友为我找到了一段定义，比我说的好

            //每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，
            //直到全部待排序的数据元素排完。

 

        #region 选择排序
        /// <summary>
        /// 选择排序
        /// </summary>
        /// <param name="intArr">要处理的数组数据</param>
        /// <returns>排序处理后的数组数据</returns>
        public int[] SelectionSort(int[] intArr)
        {

            //每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，
            //直到全部待排序的数据元素排完。
            for (int i = 0; i < intArr.Length; i++)
            {
                int min = intArr[i];//数组中的最小值
                int tempLoction = 0;//数组中最小值的位置
                //j=i+1 被比对的数是比对数的下一个，如果是从0开始，被排除数就从1开始，直到数组结束
                for (int j = i + 1; j < intArr.Length; j++)
                {
                    if (intArr[j] < min)//发现数组中的最小值
                    {
                        min = intArr[j];//记录最小值
                        tempLoction = j;//最小值的下标
                    }
                    //知道循环结束
                }
                if (tempLoction == 0)//这是在位置[i]上没有发现比[i]更小的值，所以不用交换位置
                {
                    continue;
                }
                //对比值交换
                int temp = intArr[i];//取出[i]上的值
                intArr[i] = min;//赋最小值
                intArr[tempLoction] = temp;
                //继续循环
            }
            return intArr;
        }
        #endregion

            //测试
            label1.Text = "";
            //int[] intArr = new int[] { 64, 13, 78, 13, 46, 13, 3, 73, 17, 24, 64, 14, 27, 74, 97, 61, 41, 31, 5, 2, 6 };//1224 638
            //int[] intArr = new int[] { 9, 4, 5, 7, 6, 8, 3, 1, 2 };//123 65
            int[] intArr = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 }; //205 121
            //int[] result = GetSort(intArr, 0, 0, ref count);
            int[] result = SelectionSort(intArr);
            foreach (var item in result)
            {
                label1.Text += item + "  ";
            }

 

冒泡排序
*---------------------------*

 这个排序就不用多说了，敲的最多的一个

和插入排序很想，但是没位置调换后，向前比较的动作，它是一直往前或往后排，不到黄河心不死哈

相邻的两个数组元素比较，如果前元素大，换位，再用换位后的前元素与后一个比对，直到数组界限

        #region 冒泡排序
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="intArr">需处理的数组</param>
        /// <returns>返回已经排序完的数组数据</returns>
        public int[] BubbleSort(int[] intArr)
        {
            //外围控制排序个数
            for (int i = 0; i < intArr.Length - 1; i++)
            {
                //控制排序次数
                for (int j = 0; j < intArr.Length - 1 - i; j++)
                {
                    //相邻的两个数，前一个大于后一个，交换位置
                    if (intArr[j] > intArr[j + 1])
                    {
                        int temp = intArr[j];
                        intArr[j] = intArr[j + 1];
                        intArr[j + 1] = temp;
                    }
                }
            }
            return intArr;
        }
        #endregion

我想，这个也是可以用递归实现的？

        /// <summary>
        /// 冒泡排序--递归
        /// </summary>
        /// <param name="intArr">需要排序处理的数组</param>
        /// <param name="arratLength"></param>
        /// <param name="loction">开始处理的数组下标位置</param>
        /// <returns>排序完的数组</returns>        
        /// <returns></returns>
        public int[] BubbleSort(int[] intArr, int arratLength, int loction)
        {
            if (loction < 0)//防止参数乱插入，-1什么的
            {
                return intArr;
            }
            if (arratLength == 1)//递归中断条件，数组处理的长度，递减
            {
                return intArr;
            }
            if (loction < arratLength - 1)//数组下标不超过数组长度
            {
                if (intArr[loction] > intArr[loction + 1])//比对
                {
                    //变换位置
                    int temp = intArr[loction];
                    intArr[loction] = intArr[loction + 1];
                    intArr[loction + 1] = temp;
                }
            }
            if (loction == arratLength - 1)//其中一个最大数已冒泡至顶端，切换下一个最大数
            {
                arratLength = arratLength - 1;
                loction = 0;
            }
            else
            {
                loction = loction + 1;//冒泡
            }
            BubbleSort(intArr, arratLength, loction);//递归调用，最大数冒泡
            return intArr;
        }

 

 快速排序(未完)
*---------------------------*
int[] intArr
首先有连个下标 i和j,还有一个基数 intBase
i=1 ==> intArr[1]
j=intArr.Length-1 ==> intArr[intArr.Length-1]
intBase = intArr[0]

比对 第一轮
1.0

if(intBase<intArr[i])
{
    if(intBase<intArr[j])
    {
        j--;
        //比对intBase和intArr[j]，直到有比intBase小的intArr[j]
        if(intBase>intArr[j])
        {
            //换位
            temp = intArr[i];
            intArr[i]=intArr[j];
            intArr[j]=intArr[i];
        }
        i++
        //回到1.0
    }
}
直到i = j，
if（intBase < intArr[j]）
{
    j--;    //直到intBase>intArr[i]
    int[0]=intArr[i]
    intArr[i]=intBase;;
}

第一轮结束;成功将大于intBase的所有数字，移到右边去了

2.0
j 还是上面的那个下标，i = 1 改变了就是，再来一遍

 intBase重新赋值 intBase = intArr[0];

 直到j--  ==》 j=0

然后，......

 

 待续......

 

参考

选择排序：http://www.cnblogs.com/skywang12345/p/3597641.html