数据结构学习一，排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序

一、冒泡排序

    /// <summary>
    /// 算法思想：依次比较相邻的两个数，将小数放在前面，大数放在后面。
    /// </summary>
    public class BubbleSort
    {
        public int tempInt = 0;
        public void Maopao(int[] items)
        {
            for(int i=0;i<items.Length;i++)
            {
                bool flag = false;//标记用，若无数据兑换，则证明排序成功退出
                for(int j=0;j<items.Length-1-i;j++)
                {
                    if(items[j]>items[j+1])
                    {
                        int temp = items[j];
                        items[j] = items[j + 1];
                        items[j + 1] = temp;
                        flag = true;
                        tempInt++;//交换
                    }
                }
                if(flag==false)
                {
                    break;
                }
            }
        }
       

    }

二 、直接插入排序

基本操作是将一个记录插入到已经排序好的有序表中，从而得到一个新的，记录数增加1的有序表。

           int[] arr = new int[] { 64, 5, 23, 2, 4, 16 };          
           for (int i = 1; i < arr.Length; i++)//从第二个数开始，判断后面的数是插它的左侧还是右侧
            {
                int temp = arr[i];
                int j = i-1;
                while (arr[j] > temp)
                {
                    arr[j+1] = arr[j];
                    j--;
                    if(j==-1)
                    {
                        break;
                    }
                    num3++;
                }
                arr[j+1] = temp;
            }
            Console.WriteLine("排序结果问哦： " + num3);
            foreach (int n in arr)
                Console.Write("{0}", n + " ");
            Console.WriteLine();

三、选择排序法

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
一共对比了15次

int[] arr = new int[] { 64, 5, 23, 2, 4, 16 };
            int min;
            for (int i=0; i<arr.Length - 1;i++)
            {
                min = i;
                for(int j=i+1;j<arr.Length;j++)
                {
                    if (arr[j] < arr[min])
                        min = j;
                }
                //选出序列中最小的一个数放到此次循环的起始位置
                int t = arr[min];
                arr[min] = arr[i];
                arr[i] = t;
            }
            Console.WriteLine("排序结果： ");
            foreach (int n in arr)
                Console.Write("{0}", n + " ");
            Console.WriteLine();

四、快速排序

该方法的基本思想是：
先从数列中取出一个数作为基准数，通过一趟排序将这个数列分割成独立的两个部分，其中一部分的所有数据都比另一部分要小，然后再用递归的方法对这两个部分进行排序，最终变成一个有序的数列。可以参考另外一篇博客《快速排序》
具体过程：
我选择第一个数作为基准数，首先最后一个数向左比较，找到第一个小于等于基准的数据停下来，把它放到左边第一个数；然后左边第一个数开始向后比较，找到第一个大于基准的数据停下来，把它交换到右边刚刚停下来的位置，这样循环往复最后左边和右边的比较到了同一个位置，把基准值替换当前的数据，这样就完成了数列的分割。最后用递归的方法对两个部分进行排序。

 static void QuickSort(int[] dataArray, int left, int right)
{
    if (left < right)
    {
        //基准数， 把比它小或者等于它的 放在它的左边，然后把比它大的放在它的右边
        int x = dataArray[left];
        int i = left;
        int j = right;

        while (i < j)//当i==j的时候，说明我们找到了一个中间位置，这个中间位置就是基准数应该所在的位置 
        {
            //从后往前比较
            //找到了一个比基准数 小于或者等于的数子，应该把它放在x的左边
            while (i < j)
            {
                if (dataArray[j] <= x)
                {
                    dataArray[i] = dataArray[j];
                    break;
                }
                else
                {
                    j--;//向左移动 到下一个数字，然后做比较
                }
            }
            //从前往后
            while (i < j)
            {
                if (dataArray[i] > x)
                {
                    dataArray[j] = dataArray[i];
                    break;
                }
                else
                {
                    i++;
                }
            }
        }
        //跳出循环 现在i==j i是中间位置
        dataArray[i] = x;
        QuickSort(dataArray, left, i - 1);// left -i- right
        QuickSort(dataArray, i + 1, right);
    }
}
        static void Main(string[] args)
        {
            int[] data = { 1, 5, 2, 9, 8, 6, 7, 12, 11, 15 };//第一个数不参与排序，第一个数必须比参与排序的最小值还要小
            QuickSort(data, 0, data.Length - 1);
            for (int i = 1; i <= data.Length - 1; i++)
            {
                Console.Write(data[i] + " ");
            }
            Console.WriteLine();
        }

留作以后补充：
希尔排序相当于直接插入排序的升级，他们同属于插入排序类；堆排序相当于简单选择排序的升级，他们同属于选择排序类；快速排序相当于冒泡排序的升级，同属于交换排序。

五、归并排序

 #region 归并排序
        public static void MergeSort(int[] a, int start, int end, int[] temp)
        {

            if (start < end)
            {
                int mid = (start + end) / 2;
                MergeSort(a, start, mid, temp);  //左边有序
                MergeSort(a, mid + 1, end, temp);  //右边有序
                MergerArray(a, start, mid, end, temp); //合并
            }

        }

        //合并2个数组
        public static void MergerArray(int[] a, int start, int mid, int end, int[] temp)
        {

            int i = start, j = end, m = mid + 1;
            int count = 0;
            while (i <= mid && m <= j)
            {
                if (a[i] < a[m])
                {
                    temp[count++] = a[i++];
                }
                else
                {
                    temp[count++] = a[m++];
                }
            }

            while (i <= mid)
            {
                temp[count++] = a[i++];
            }

            while (m <= j)
            {
                temp[count++] = a[m++];
            }

            for (int k = start, s = 0; k <= end; k++)
            {
                a[k] = temp[s++];
            }
        }
        #endregion