六类排序算法的C#实现

排序算法是最常用的基本算法，也是处理任何逻辑都不可避免要使用的工具，在大学学过的数据结构课程中，都会讲排序和查找，工作一段时间后发现，任何处理逻辑的代码中都排序和查找都是不可或缺的。在二层嵌套循环中，在加了索引的集合中查找数据的时间复杂度是n*log(n)而不加索引的复杂度是n*n，当n=10000时，计算结果的速度会有明显的差异，所以为了能写出比较高效的代码，首先要解决的问题就对排序算法的理解。按照常用的排序算法排序技巧，一般分为 交换排序，插入排序，选择排序。

1.交换排序

冒泡排序

public static void BubbleSort(int[] oriArry)
{
for (int i = 0; i < oriArry.Length - 1; i++)
{
for (int j = 0; j < oriArry.Length - i - 1; j++)
{
if (oriArry[j] > oriArry[j + 1])
{
int temp = oriArry[j + 1];
oriArry[j + 1] = oriArry[j];
oriArry[j] = temp;
}
}
}

foreach (int i in oriArry)
{
Console.WriteLine(i);
}
}

快速排序

      public static void QiuckSort(int[] oriArry)
        {

            QuickSort(oriArry, oriArry.Length, 0, oriArry.Length - 1);

            foreach (int i in oriArry)
            {
                Console.WriteLine(i);
            }

        }

        public static void QuickSort(int[] oriArry, int count, int head, int tail)
        {
            if (tail <= head)
                return;
            int temp = oriArry[head];
            int start = head;
            int end = tail;
            while (head < tail)
            {
                while (head < tail && oriArry[tail] >= temp)
                {
                    tail--;
                }
                if (head < tail)
                {
                    oriArry[head] = oriArry[tail];
                    oriArry[tail] = temp;
                    head++;
                }
                while (head < tail && oriArry[head] <= temp)
                {
                    head++;
                }
                if (head < tail)
                {
                    oriArry[tail] = oriArry[head];
                    oriArry[head] = temp;
                    tail--;
                }
            }
            oriArry[head] = temp;
            QuickSort(oriArry, count, start, head - 1);
            QuickSort(oriArry, count, head + 1, end);
        }

2.插入排序

直接插入排序

     public static void InsertSort(int[] oriArry)
        {
            int temp;
            int offset;
            for (int i = 1; i < oriArry.Length; i++)
            {
                temp = oriArry[i];
                offset = i;

                while (offset - 1 >= 0 && oriArry[offset - 1] > temp)
                {
                    oriArry[offset] = oriArry[offset - 1];
                    offset--;
                }
                oriArry[offset] = temp;
            }

            foreach (int i in oriArry)
            {
                Console.WriteLine(i);
            }
        }

希尔排序

     public static void ShellSort(int[] oriArry)
        {
            for (int j = oriArry.Length / 2; j > 0; j /= 2)
            {
                for (int i = j; i < oriArry.Length; i++)
                {
                    int temp = oriArry[i];
                    int offset = i;

                    while (offset - j >= 0 && oriArry[offset - j] > temp)
                    {
                        oriArry[offset] = oriArry[offset - j];
                        offset = offset - j;
                    }
                    oriArry[offset] = temp;
                }
            }
            foreach (int i in oriArry)
            {
                Console.WriteLine(i);
            }

        }

3.选择排序

直接选择排序

  public static void SelectSort(int[] oriArry)
        {
            for (int i = 0; i < oriArry.Length - 1; i++)
            {
                int minId = i;
                for (int j = i; j < oriArry.Length; j++)
                {
                    if (oriArry[j] < oriArry[minId])
                        minId = j;
                }

                int temp = oriArry[i];
                oriArry[i] = oriArry[minId];
                oriArry[minId] = temp;
            }

            foreach (int i in oriArry)
            {
                Console.WriteLine(i);
            }
        }

堆排序

        public static void maxHeapDown(int[] a, int start, int end)
        {
            int c = start;            
            int l = 2 * c + 1;        
            int tmp = a[c];          

            for (; l <= end; c = l, l = 2 * l + 1)
            {
                //
                if (l < end && a[l] < a[l + 1])
                    l++;      
                if (tmp >= a[l])
                    break;       
                else
                {          
                    a[c] = a[l];
                    a[l] = tmp;
                }
            }
        }

        public static void heapSortAsc(int[] a, int n)
        {
            int i, tmp;

            for (i = n / 2 - 1; i >= 0; i--)
                maxHeapDown(a, i, n - 1);

            for (i = n - 1; i > 0; i--)
            {
                tmp = a[0];
                a[0] = a[i];
                a[i] = tmp;
                maxHeapDown(a, 0, i - 1);
            }
        }

排序算法的效率和稳定性