C#4种基础排序算法

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

namespace DS_Sort
{
    /// <summary>
    /// 四种排序算法
    /// </summary>
    class DSSort
    {
        //----------------直接插入排序------------------------------------

        public void InsertASC(int[] arrar)         //直接插入 升序排序
        {
            if (arrar == null || arrar.Length <= 0)
            {
                Console.WriteLine("找不到可排序的元素！");
                return;
            }
            for (int i = 1; i < arrar.Length; i++)
            {
                if (arrar[i] < arrar[i - 1])
                {
                    int tmp = arrar[i];
                    int j = i - 1;
                    for (; j >= 0 && tmp < arrar[j]; j--)
                    {
                        arrar[j + 1] = arrar[j];
                    }
                    arrar[j + 1] = tmp;
                }
            }
            foreach (int i in arrar)
            {
                Console.Write(i + " ");
            }
        }

        public void InsertDESC(int[] arrar)       //直接插入 降序排序
        {
            if (arrar == null || arrar.Length <= 0)
            {
                Console.WriteLine("找不到可排序的元素！");
                return;
            }
            for (int i = 1; i < arrar.Length; i++)
            {
                if (arrar[i] > arrar[i] - 1)
                {
                    int tmp = arrar[i];
                    int j = i - 1;
                    for (; j >= 0 && tmp > arrar[j]; j--)
                    {
                        arrar[j + 1] = arrar[j];
                    }
                    arrar[j + 1] = tmp;
                }
            }
            foreach (int i in arrar)
            {
                Console.Write(i + " ");
            }
        }

        //-------------冒泡排序---------------------------------------

        public void BubbleASC(int[] arrar)       //冒泡排序 升序
        {
            if (arrar == null || arrar.Length <= 0)
            {
                Console.WriteLine("找不到可排序的元素！");
                return;
            }

            for (int i = 0; i < arrar.Length - 1; i++)
            {
                for (int j = arrar.Length - 1; j > i; j--)
                {
                    if (arrar[j] < arrar[j - 1])
                    {
                        int tmp = arrar[j];
                        arrar[j] = arrar[j - 1];
                        arrar[j - 1] = tmp;

                    }
                }
            }
            foreach (int B in arrar)
            {
                Console.Write(B + " ");
            }
        }

        public void BubbleDESC(int[] arrar)     //冒泡排序 降序
        {
            if (arrar == null || arrar.Length <= 0)
            {
                Console.WriteLine("找不到可排序的元素！");
                return;
            }

            for (int i = 0; i < arrar.Length - 1; i++)
            {
                for (int j = arrar.Length - 1; j > i; j--)
                {
                    if (arrar[j] > arrar[j - 1])
                    {
                        int tmp = arrar[j];
                        arrar[j] = arrar[j - 1];
                        arrar[j - 1] = tmp;
                    }
                }
            }
            foreach (int B in arrar)
            {
                Console.Write(B + " ");
            }
        }

        public void Buffer()   //用一个循环写的冒泡，性能上要差得多
        {
            int[] a = { 7, 4, 9, 3, 2 };
            for (i = 0; i < 4; )
            {
                if (a[i] > a[i + 1])
                {
                    b = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = b;
                    i = 0;          //关键在这里
                }
                else
                {
                    i++;
                }
            }
        }

        //----------------直接选择排序--------------------------------------------------

        public void SelectASC(int[] arrar)      //直接选择排序 升序  , 是一种不稳定排序
        {
            int tmp = 0;
            if (arrar == null || arrar.Length <= 0)
            {
                Console.WriteLine("找不到可排序的元素！");
                return;
            }

            for (int i = 0; i < arrar.Length - 1; i++)
            {
                int Min = i;
                for (int j = i + 1; j <= arrar.Length - 1; j++)
                {
                    if (arrar[j] < arrar[Min])
                    {
                        Min = j;
                    }
                }
                if (Min != i)
                {
                    tmp = arrar[i];
                    arrar[i] = arrar[Min];
                    arrar[Min] = tmp;
                }
            }
            foreach (int S in arrar)
            {
                Console.Write(S + " ");
            }
        }

        public void SelectDESC(int[] arrar)      //直接选择排序 降序  , 是一种不稳定排序
        {
            int tmp = 0;
            if (arrar == null || arrar.Length <= 0)
            {
                Console.WriteLine("找不到可排序的元素！");
                return;
            }

            for (int i = 0; i < arrar.Length - 1; i++)
            {
                int Max = i;
                for (int j = i + 1; j <= arrar.Length - 1; j++)
                {
                    if (arrar[j] > arrar[Max])
                    {
                        Max = j;
                    }
                }
                if (Max != i)
                {
                    tmp = arrar[i];
                    arrar[i] = arrar[Max];
                    arrar[Max] = tmp;
                }
            }
            foreach (int S in arrar)
            {
                Console.Write(S + " ");
            }
        }



        // ------------快速排序算法,是一种不稳定排序-------------------------------------------------

        public void QuickASC(int[] arrar, int low, int high)
        {
            if (low < high)
            {
                int Pivot = DichotomyASC(arrar, low, high);
                QuickASC(arrar, low, Pivot - 1);
                QuickASC(arrar, Pivot + 1, high);
            }
        }
        public void QuickDESC(int[] arrar, int low, int high)
        {
            if (low < high)
            {
                int Pivot = DichotomyDESC(arrar, low, high);
                QuickDESC(arrar, low, Pivot - 1);
                QuickDESC(arrar, Pivot + 1, high);
            }
        }

        public int DichotomyASC(int[] arrar, int low, int high)     //快速排序 升序
        {
            int p = arrar[low];
            while (low < high)
            {
                //如果high的数据大于等于支点p的数据时，将high指针依次向低端移动1个一个位置
                while (low < high && arrar[high] >= p)
                {
                    high--;
                }
                if (low != high)
                {
                    arrar[low] = arrar[high];     //将high的数据复制到low中，low向高端移动一个位置
                    low++;
                }

                //如果low的数据小于支点p的数据，将low指针向高端移动一个位置
                while (low < high && arrar[low] <= p)
                {
                    low++;
                }
                if (low != high)
                {
                    arrar[high] = arrar[low];    //将low的数据复制到high中 ，high向低端移动一个位置
                    high--;
                }
            }
            arrar[high] = p;
            return high;
        }

        public int DichotomyDESC(int[] arrar, int low, int high)    //快速排序 降序
        {
            int p = arrar[low];
            while (low < high)
            {
                while (low < high && arrar[high] <= p)
                {
                    high--;
                }
                if (low != high)
                {
                    arrar[low] = arrar[high];
                    low++;
                }
                while (low < high && arrar[low] >= p)
                {
                    low++;
                }
                if (low != high)
                {
                    arrar[high] = arrar[low];
                    high--;
                }
            }
            arrar[high] = p;
            return high;
        }
    }
}