C#语言实现10大排序算法

C#语言实现10大排序算法

冒泡排序

定义：
比较相邻的两个元素，如果前面的元素比后面的元素大，那就交换这两个元素。

• 第一回走到队尾最大数已经排到了最后面，下次只要交换到倒数第二个数字即可
• 一直重复以上步骤，直到某一次巡回时没有发生元素交换，此时已经实现本数组的升序排列。倒序同理

无脑排序，对于已经排好序的数组或者存在局部实现排序的数组而言效率不高，会从头到尾一直比较,即使中间已经实现了排序效果也会一直运行到所有的步骤完成

using System;
namespace 冒泡排序
{
    class Program
    {
        static void Main(string[] args)
        {
            // 准备排序的数组
            int[] data = new int[10];
            Random random = new Random();
            int counter = 0;
            while(counter<10)
            {
                int temp = random.Next(0, 100);
                data[counter] = temp;
                counter++;

            }
            Console.WriteLine("排序前的数字顺序:");
            PrintData(data);
           
            Console.WriteLine();
            Console.WriteLine("排序后的数字顺序:");
            PrintData(BubbleSort(data));
            Console.ReadKey();

        }
        static void PrintData(int[] data)
        {
            foreach (var item in data)
            {
                Console.Write(item.ToString());
                Console.Write(",  ");
            }
        }
        static int[] BubbleSort(int[] data)
        {
            for(int i=0;i<data.Length-1;i++)
            {
                for(int j=0;j<data.Length-1-i;j++)
                {
                    if(data[j]>data[j+1])
                    {
                        int temp = data[j];
                        data[j] = data[j + 1];
                        data[j + 1] = temp;
                    }
                }
            }
            return data;
        }
    }
   
}

比较高效。当数组在开始就排好序的或者中间实现了排序，立即停止，并返回结果

using System;
namespace 冒泡排序
{
    class Program
    {
        static void Main(string[] args)
        {
            // 准备排序的数组
            int[] data = new int[10];
            Random random = new Random();
            int counter = 0;
            while(counter<10)
            {
                int temp = random.Next(0, 100);
                data[counter] = temp;
                counter++;

            }
            Console.WriteLine("排序前的数字顺序:");
            PrintData(data);
           
            Console.WriteLine();
            Console.WriteLine("排序后的数字顺序:");
            PrintData(BubbleSort(data));
            Console.ReadKey();

        }
        static void PrintData(int[] data)
        {
            foreach (var item in data)
            {
                Console.Write(item.ToString());
                Console.Write(",  ");
            }
        }
        static int[] BubbleSort(int[] data)
        {
            bool flag = true;
            while(flag)
            {
                flag = false;
                for(int i=0;i<data.Length-1;i++)
                {
                    if(data[i]>data[i+1])
                    {
                        int temp = data[i];
                        data[i] = data[i + 1];
                        data[i + 1] = temp;
                        flag = true;
                    }
                }
            }
            return data;
        }
    }
   
}

很高效。可以有效的利用已经有序的元素，可以直接跳过比较，有效的减少了运算次数，提高效率

// 如果尾部存在已经局部有序的元素，可以记录一下最后一次交换的位置，减少比较的次数
using System;
namespace 冒泡排序
{
    class Program
    {
        static void Main(string[] args)
        {
            // 准备排序的数组
            int[] data = new int[10];
            Random random = new Random();
            int counter = 0;
            while(counter<10)
            {
                int temp = random.Next(0, 100);
                data[counter] = temp;
                counter++;

            }
            Console.WriteLine("排序前的数字顺序:");
            PrintData(data);
           
            Console.WriteLine();
            Console.WriteLine("排序后的数字顺序:");
            PrintData(BubbleSort(data));
            Console.ReadKey();

        }
        static void PrintData(int[] data)
        {
            foreach (var item in data)
            {
                Console.Write(item.ToString());
                Console.Write(",  ");
            }
        }
        static int[] BubbleSort(int[] data)
        {
            for(int i=0;i<data.Length-1;i++)
            {
                int exchangedIndex = 0；
                    int endIndex = data.Length - 1 - i;
                for(int j=0;j<=endIndex-1;j++)
                {
                    if(data[j]>data[j+1])
                    {
                        int temp = data[j];
                        data[j] = data[j + 1];
                        data[j + 1] = temp;
                        exchangedIndex = i;//记录最后一次交换的位置，下次只需要比较到这里即可

                    }
                }
                endIndex = exchangedIndex;
            }
            return data;
        }
    }
   
}

排序算法的稳定性：
如果相等的两个元素，在排序前后的两个位置保持不变，那么这是稳定的排序算法。

选择排序

定义：
从序列中找出最大的元素，然后与最末尾的元素进行位置交换。

using System;
namespace 选择排序
{
    class Program
    {
        static void Main(string[] args)
        {
            // 准备排序的数组
            int[] data = new int[10];
            Random random = new Random();
            int counter = 0;
            while (counter < 10)
            {
                int temp = random.Next(0, 100);
                data[counter] = temp;
                counter++;

            }
            Console.WriteLine("排序前的数字顺序:");
            PrintData(data);
            Console.WriteLine();
            Console.WriteLine("排序后的数字顺序:");
            PrintData(SelectionSort(data));
            Console.ReadKey();
        }
        
        static void PrintData(int[] data)
        {
            foreach (var item in data)
            {
                Console.Write(item.ToString());
                Console.Write(",  ");
            }
        }
        static int[] SelectionSort(int[] data)
        {
            for(int i=0;i<data.Length;i++)
            {
                int max = data[0];//默认第一个元素是最大的元素
                int exchangedIndex =0;
                for(int j=0;j<data.Length-i;j++)
                {
                    if(data[j]>max)
                    {
                        max = data[j];
                        exchangedIndex = j;
                    }
                }
                int temp = data[data.Length - 1 - i];
                data[data.Length -1-i] = max;
                data[exchangedIndex] = temp;
                max = data[0];
            }
            return data;
        }
    }
    
}

堆排序

插入排序

归并排序

快速排序

希尔排序

计数排序

基数排序

桶排序