算法-“选择排序”程序模拟

1 选择排序的思想

1）初始状态：无序区为R[1..n]，有序区为空。

2）第1趟排序：在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

3）第i趟排序：第i-1趟排序完毕 ，第i趟未开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

---

2 选择排序的代码实现

前面编码模拟了100个关键码组成的无序序列分别通过“冒泡排序”和“插入排序”变为有序序列的过程。
可以分别查看：

算法-模拟冒泡排序

算法-一种性能稳定的“插入排序”实现

源码下载地址：
http://download.csdn.net/detail/daigualu/9776250

在这个代码结构基础上，编写选择排序并模拟，
选择排序核心代码：

 public static MyArray Show1(MyArray myarr, int size)
        {
            //随机生成方法
            myarr.FillRandomValue();
            Console.Write("初始：");
            myarr.Printf();
            Console.Write("\n-------------------------------------------------\n");

            for (int i = 0; i < size; i++)
            {
                int minvalIndex = myarr.FindIndexOfMinVal(i, size-1);
                //交换MyElement，minvalIndex归位到i的位置上。
                MyArray.Swap(myarr.GetAt(i), myarr.GetAt(minvalIndex));

            }
            Console.Write("\n");
            myarr.Printf();

            return myarr;
        }

FindIndexOfMinVal实现如下：

                /// <summary>
        /// 搜索区间找到最小值
        /// </summary>
        /// <param name="begin">搜索区间的起始位置</param>
        /// <param name="end">终止</param>
        /// <returns></returns>
        public int FindIndexOfMinVal(int begin, int end)
        {
            if (begin > end) return -1;
            if (begin >= _size || end >= _size)
                throw new IndexOutOfRangeException();
            if (begin < 0 || end < 0)
                throw new IndexOutOfRangeException();
            int minval = _array[begin].Val;
            int minvalIndex = begin;
            for(int i=begin+1;i<=end;i++)
            {
                if (_array[i].Val < minval)
                {
                    minval = _array[i].Val;
                    minvalIndex = i;
                }
            }
            return minvalIndex;
        }    

测试用例100个MyElement，

选择排序后的结果，

总结

选择排序总的比较次数，

(n-1）+(n-2）+...+1=n*(n-1）/2

**交换次数**O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

选择排序不是稳定的排序算法，比如5，5，3， 经过第一次交换后，5，3，5，第一个5跑到了第二个5的后面。