数据结构：插入排序/冒泡排序/快速排序/归并排序/堆排序 C#语言实现

编写程序实现下述五种算法，并用以下无序序列加以验证：

49，38，65，97，76，13，27，49

1．简单插入排序
2．冒泡排序
3．快速排序
4．归并排序
5．堆排序

public class Test2   
    {   
        public void InitialList(ref SqList L)      
        {      
            //初始化顺序表L   
            L.count = 0;   
            L.r = new int[8];   
            int length = 0;   
            L.r[length++] = 49;   
            L.r[length++] = 38;      
            L.r[length++] = 65;      
            L.r[length++] = 97;      
            L.r[length++] = 76;      
            L.r[length++] = 13;      
            L.r[length++] = 27;      
            L.r[length++] = 49;      
        }   
        public void PrintList(SqList L)   
        {   
            //打印顺序表      
            int i;   
            for (i = 0; i < L.r.Length; i++)   
            {   
               Console.Write(L.r[i]+" ");   
               if (i == L.r.Length-1)   
                   Console.WriteLine();   
            }   
            Console.WriteLine("运算次数" + L.count.ToString());   
        }   
        public void InsertSort(ref SqList L)      
        {      
            //直接插入排序    
            int i, j, temp;   
            for ( i = 1; i < L.r.Length; i++)   
            {   
                if (L.r[i] < L.r[i - 1])   
                {   
                     j = i - 1;   
                     temp = L.r[i];   
                    do  
                    {   
                        L.r[j + 1] = L.r[j];   
                        L.count++;   
                    } while (--j >= 0 && temp < L.r[j]);   
                    L.r[j + 1] = temp;   
                }   
                L.count++;   
            }   
        }     
        public void BubbleSort(ref SqList L)      
        {      
            //冒泡排序      
            int i, j;      
            int temp;      
            for (i = 0;i < L.r.Length;i++)      
            {      
                for (j = i + 1;j < L.r.Length;j++)      
                {      
                    if (L.r[i] > L.r[j])      
                    {      
                        temp = L.r[i];      
                        L.r[i] = L.r[j];      
                        L.r[j] = temp;      
                    }   
                    L.count++;   
                }   
                L.count++;   
            }      
        }    
           
        public void QuickSort(ref SqList L, int left, int right)   
        {   
            //快速排序    
            int i, j;   
            int middle, temp;   
            i = left;   
            j = right;   
            middle = L.r[left];   
            while (true)   
            {   
                while ((++i) < right - 1 && L.r[i] < middle) ;   
                while ((--j) > left && L.r[j] > middle) ;   
                if (i >= j)   
                    break;   
                temp = L.r[i];   
                L.r[i] = L.r[j];   
                L.r[j] = temp;   
                L.count++;   
            }   
            L.r[left] = L.r[j];   
            L.r[j] = middle;   
            if (left < j)   
                QuickSort(ref L, left, j);   
            if (right > i)   
                QuickSort(ref L, i, right);   
        }       
  
        private void Merge (int[] SR, int[] TR, int i, int m, int n,ref int count)      
        {      
            int j, k;      
            for (j = m + 1, k = i; i <= m && j <= n; ++k)      
            {      
                if (SR[i] < SR[j]) TR[k] = SR[i++];      
                else TR[k] = SR[j++];   
                count++;   
            }      
            if (i <= m)      
                while (k <= n && i <= m) TR[k++] = SR[i++];      
            if (j <= n)      
                while (k <= n && j <= n) TR[k++] = SR[j++];      
        }      
        public void MSort(int[] SR, int[] TR1, int s, int t,ref int count)      
        {      
            //归并排序      
            int m;   
            int[] TR2 = new int[TR1.Length];   
            if (s == t) TR1[t] = SR[s];      
            else     
            {      
                m = (s + t) / 2;      
                MSort(SR, TR2, s, m,ref count);      
                MSort(SR, TR2, m + 1, t,ref count);      
                Merge(TR2, TR1, s, m, t,ref count);      
            }   
            count++;   
        }   
        void Adjust(int[] a, int i, int n,ref int count)   
        {   
            int j = 0;   
            int temp = 0;   
            temp = a[i];   
            j = 2 * i + 1;   
            while (j <= n - 1)   
            {   
                if (j < n - 1 && a[j] < a[j + 1]) j++;   
                if (temp >= a[j])  break;   
                a[(j - 1) / 2] = a[j];   
                j = 2 * j + 1;   
                count++;   
            }   
            a[(j - 1) / 2] = temp;   
        }   
        public void HeapSort(int[] a,ref int count)   
        {   
            //堆排序     
            int n = a.Length;   
            int temp = 0;   
            for (int i = n / 2; i > 0; i--)   
            {   
                Adjust(a, i - 1, n,ref count);   
                count++;   
            }   
            for (int i = n - 2; i >= 0; i--)   
            {   
                temp = a[i + 1];   
                a[i + 1] = a[0];   
                a[0] = temp;   
                Adjust(a, 0, i + 1,ref count);   
                count++;   
            }   
        }    
    }   
    public struct SqList    
    {      
        public int []r;      
        public int count;   
    }    
//Main   
class Program   
    {   
        static void Main(string[] args)   
        {   
            SqList L = new SqList();   
            Test2 t2 = new Test2();   
            Console.WriteLine("各种排序算法/n/n原始数据为");   
                 
            t2.InitialList(ref L);   
            t2.PrintList(L);   
            Console.WriteLine("/n直接插入排序：");   
                         
            t2.InsertSort(ref L);   
            t2.PrintList(L);   
                  
            Console.WriteLine("/n冒泡排序：");   
            t2.InitialList(ref L);   
            t2.BubbleSort(ref L);   
            t2.PrintList(L);   
  
            Console.WriteLine("/n快速排序：");   
            t2.InitialList(ref L);   
            t2.QuickSort(ref L, 0, L.r.Length);   
               
            t2.PrintList(L);   
  
            Console.WriteLine("/n归并排序：");      
            t2.InitialList(ref L);   
            t2.MSort(L.r, L.r, 0, L.r.Length-1,ref L.count);   
            t2.PrintList(L);   
  
            Console.WriteLine("/n堆排序：");   
            t2.InitialList(ref L);   
            t2.HeapSort(L.r,ref L.count);   
            t2.PrintList(L);   
        }   
    }