常见几种排序讨论

今天，我准备简单的过一遍基本的几种排序算法，算是一个记录，因为基本的几种排序算法在理解的时候也没有什么难度，这里仅仅用代码实现一些，做个记录而已。

一：冒泡

最常见的面试题中经常有这个考察：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 冒泡排序
{
    class Program
    {
        //static int[] mainarray = new int[] { 5, 7, 4, 9, 3, 8, 2, 1, 6, 0 };
        static int[] mainarray = new int[] { 5, 7, 4, 9, 3 };
        static void Main(string[] args)
        {
            DisplayNums(mainarray);
            BubbleSort1();
            
            Console.ReadKey();
        }
        /// <summary>
        /// 升序
        /// </summary>
        static void BubbleSort()
        {
            for (int i = 0; i < mainarray.Length;i++ )
            {
                for (int j = mainarray.Length - 1; j > i;j-- )
                {
                    //从最后一位开始检测
                    //如果小者在后就交换 不然不交换向前检测
                    //一直检测到当前I的索引位
                    if (mainarray[j-1]>mainarray[j])
                    {
                        int temp = mainarray[j];
                        mainarray[j] = mainarray[j - 1];
                        mainarray[j - 1] = temp; 
                    }
                   
                }
            }
        }
        /// <summary>
        /// 降序
        /// </summary>
        static void BubbleSort1()
        {
            for (int i = 0; i < mainarray.Length; i++)
            {
                for (int j = mainarray.Length - 1; j > i; j--)
                {
                    //从最后一位开始检测
                    //如果小者在后就交换 不然不交换向前检测
                    //一直检测到当前I的索引位
                    if (mainarray[j - 1] < mainarray[j])
                    {
                        int temp = mainarray[j];
                        mainarray[j] = mainarray[j - 1];
                        mainarray[j - 1] = temp;
                    }
                    DisplayNums(mainarray);
                }
            }
        }
        static void DisplayNums(int[] arr)
        {
            for (int i = 0; i <= arr.GetUpperBound(0); i++)
                Console.Write(arr[i] + " ");
            Console.WriteLine();
        }


    }
}

二：插入排序

插入排序说白了就是找到目标值后然后插入到正确位置，然后其他元素依次移动：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 插入排序
{
    class Program
    {
        static int[] mainarray = new int[] { 5, 7, 4, 9, 3, 8, 2, 1, 6, 0 };
        static void Main(string[] args)
        {
            DisplayNums(mainarray);
            InsertionSort();
            Console.ReadKey();
        }
        /// <summary>
        /// 插入排序的原理是如果将当前值放到合理的位置 然后移动当前值所在索引以及目标索引之间的值
        /// </summary>
        static void InsertionSort()
        {
            //从第一个数开始检查，第0个无需检查
            for (int i = 1; i < mainarray.Length;i++ )
            {
                //当前数字之前的所有数
                for (int j = 0; j < i;j++ )
                {
                    //如果当前数字的前面有比他大的数字，就要吧当前数字插入到这个位置
                    //并且将那个目标位置之后的数后移
                    if (mainarray[j]>mainarray[i])
                    {
                        int temp = mainarray[i];
                        for (int k = i; k > j;k--)
                        {
                            mainarray[k] = mainarray[k-1];
                        }
                        mainarray[j] = temp;
                        break;
                    }
                }
                DisplayNums(mainarray);
            }
        }
        static void DisplayNums(int[] arr)
        {
            for (int i = 0; i <= arr.GetUpperBound(0); i++)
                Console.Write(arr[i] + " ");
            Console.WriteLine();
        }
    }
}

三：选择排序

于插入排序唯一的不同，就是找到目标值后和目标位置的当前值交换，而不是移动数组：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 选择排序
{
    class Program
    {
        static int[] mainarray = new int[] { 5, 7, 4, 9, 3, 8, 2, 1, 6, 0 };
        static void Main(string[] args)
        {
            DisplayNums(mainarray);
            SelectionSort();
            Console.ReadKey();
        }
        static void SelectionSort()
        {
            int index;
            for (int i = 0; i < mainarray.Length - 1;i++ )
            {
                index = i;
                for (int j = mainarray.Length - 1; j > i;j-- )
                {
                    //遍历当前元素及后面的所有元素，找出最小值的索引
                    if (mainarray[j]<mainarray[index])
                    {
                        index = j;
                    }
                }
                //将最小值存储在一个临时变量中，然后将最小值和当前值调换位置。
                //如果最小值就是当前值 不做处理。
                if (index!=i)
                {
                    int temp = mainarray[index];
                    mainarray[index] = mainarray[i];
                    mainarray[i] = temp;
                }
                DisplayNums(mainarray);
            }
        }

        static void DisplayNums(int[] arr)
        {
            for (int i = 0; i <= arr.GetUpperBound(0); i++)
                Console.Write(arr[i] + " ");
            Console.WriteLine();
        }
    }
}

四：三种排序的比较

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TimeSpcan;

namespace 三种排序的比较
{
    class Program
    {
        static void Main(string[] args)
        {
            TimeTest timescap = new TimeTest();
            Random rnd = new Random(1000);
            int numItems = 20000;
            Console.WriteLine("对于一个{0}长度的数组进行排序：", numItems);
            int[] theArray = new int[numItems];
            for (int i = 0; i < numItems; i++)
                theArray[i] = (int)(rnd.NextDouble() * 10000);
            timescap.startTime();
            BubbleSort(theArray);
            timescap.stopTime();
            Console.WriteLine("冒泡：" + timescap.Result()+"ms");
            Array.Clear(theArray, 0, numItems);
            for (int i = 0; i < numItems; i++)
                theArray[i] = (int)(rnd.NextDouble() * 10000);
            timescap.startTime();
            SelectionSort(theArray);
            timescap.stopTime();
            Console.WriteLine("选择：" + timescap.Result() + "ms");
            Array.Clear(theArray, 0, numItems);
            for (int i = 0; i < numItems; i++)
                theArray[i] = (int)(rnd.NextDouble() * 10000);
            timescap.startTime();
            InsertionSort(theArray);
            timescap.stopTime();
            Console.WriteLine("插入：" + timescap.Result() + "ms");

            Console.ReadKey();
        }
        /// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="mainarray"></param>
        /// <returns></returns>
        static int[] InsertionSort(int[] mainarray)
        {
            //从第一个数开始检查，第0个无需检查
            for (int i = 1; i < mainarray.Length; i++)
            {
                //当前数字之前的所有数
                for (int j = 0; j < i; j++)
                {
                    //如果当前数字的前面有比他大的数字，就要吧当前数字插入到这个位置
                    //并且将那个目标位置之后的数后移
                    if (mainarray[j] > mainarray[i])
                    {
                        int temp = mainarray[i];
                        for (int k = i; k > j; k--)
                        {
                            mainarray[k] = mainarray[k - 1];
                        }
                        mainarray[j] = temp;
                        break;
                    }
                }
               
            }
            return mainarray;
        }
        /// <summary>
        /// 选择排序
        /// </summary>
        /// <param name="mainarray"></param>
        /// <returns></returns>
        static int[] SelectionSort(int[] mainarray)
        {
            int index;
            for (int i = 0; i < mainarray.Length - 1; i++)
            {
                index = i;
                for (int j = mainarray.Length - 1; j > i; j--)
                {
                    //遍历当前元素及后面的所有元素，找出最小值的索引
                    if (mainarray[j] < mainarray[index])
                    {
                        index = j;
                    }
                }
                //将最小值存储在一个临时变量中，然后将最小值和当前值调换位置。
                //如果最小值就是当前值 不做处理。
                if (index != i)
                {
                    int temp = mainarray[index];
                    mainarray[index] = mainarray[i];
                    mainarray[i] = temp;
                }
                
            }
            return mainarray;
        }

        /// <summary>
        /// 冒泡排序
        /// </summary>
        static int[] BubbleSort(int[] mainarray)
        {
            for (int i = 0; i < mainarray.Length; i++)
            {
                for (int j = mainarray.Length - 1; j > i; j--)
                {
                    //从最后一位开始检测
                    //如果小者在后就交换 不然不交换向前检测
                    //一直检测到当前I的索引位
                    if (mainarray[j - 1] > mainarray[j])
                    {
                        int temp = mainarray[j];
                        mainarray[j] = mainarray[j - 1];
                        mainarray[j - 1] = temp;
                    }

                }
            }
            return mainarray;
        }
    }
}

结果如下：