总结数据结构中重要的排序算法

一、插入类排序

       1、直接插入排序：适合数据较小且数据较有序的数字序列。
              算法思想：将一个数组先划分成已排序好的部分和未排序好的部分，从未排序好的部分中获取一个关键数作为待排序数，在
                                  已排好序的序列中找到合适位置插入这个数据。需要一个中间变量tmp存放每次获取的关键数。
            程序代码如下：
             void insertSort(int arr[], int len)

             {

                  int i, j;

                  for (i = 2; i < len; ++i)

                {

                    arr[0] = arr[i];

                    for (j = i - 1; arr[j] > arr[0]; --j)

                   {

                       arr[j + 1] = arr[j];

                   }             

                  arr[j + 1] = arr[0];

                }

            }
        2、希尔排序：又称缩小增量排序法
             
算法思想：给一个增量组合，通常给{5，3，1}，即下面代码中的dka[]；根据增量组合将待排序的关键字序列分成相应的若干
                                  较小子序列，对子序列进行直接插入排序，使整个待排序列排好序。
              程序代码如下：
                void shell(int arr[], int arr_len,int dk)

                 {

                       int i, j;

                       int tmp;

                      for (i = dk; i < arr_len; ++i)

                    {

                         tmp = arr[i];

                         for (j = i - dk; j >= 0 && arr[j] > tmp; j = j - dk)

                       {

                           arr[j + dk] = arr[j];

                       }

                      arr[j + dk] = tmp;

                   }

               }

              void shellSort(int arr[], int arr_len, int dka[], int dka_len)

           {

                for (int i = 0; i < dka_len; ++i)

             {

                 shell(arr,arr_len,dka[i]);

             }

          }

二、选择排序

     1、简单选择排序
           算法思想：第一趟简单选择排序时，从第一个记录开始，通过n-1次关键字的比较，从n个记录中选出关键字最小的记录，并和
                               第一个记录进行交换；
                               第二趟简单选择排序时，从第二个记录开始，通过n-2次关键字的比较，从n-1个记录中选出关键字最小的记录，并
                              和第二个记录进行交换；
                                 ......
                              第i趟简单排序时，从第i个记录开始，通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个
                            
记录进行交换；
                             如此反复，经过n-1趟简单选择排序，将把n-1个记录排到位，剩下一个最小记录直接在最后。
         程序代码如下：
             void SelectSort(int arr[], int len)

           {

               int i, j;

               int min;

               int tmp;//O(n^2) O(1)

              for (int i = 0; i < len-1; ++i)

            {

                 min = i;

                 for (j = i + 1; j < len; ++j)

               {

                     if (arr[j] < arr[min])

                    {

                         min = j;

                    }

               }

               tmp = arr[min];

              arr[min] = arr[i];

              arr[i] = tmp;

            }

         }
   2、堆排序
         算法思想：采用完全二叉树的顺序结构的特征进行分析。将待排序数组看成是一颗完全二叉树的顺序表示，每个结点表示一个
                             记录，第一个记录作为二叉树的根，之后的各记录依次逐层从左到右顺序排列，任意结点i的左孩子是2i，右孩子是
                             2i+1，对这颗完全二叉树进行调整建堆，以下程序调整为大根堆。
          程序代码如下：
                  void HeapAdjust(int arr[], int i, int len)

                 {

                          int j;

                         //j <= len   有左子树 

                         for (j = 2 * i; j <= len; j = 2 * j)

                        {

                             //j  左子树   j = len; //有左 没右  j = len

                            //左右都有

                           //就j < len

                          //j = len   有左 没右

                         // j < len  左右都有 

                           if (j < len && arr[j] < arr[j + 1])

                          {

                                j++;

                           }

                            if (arr[j] < arr[i])break;

                            arr[0] = arr[i];

                            arr[i] = arr[j];

                            arr[j] = arr[0];

                            i = j;

                        }

                    }

                 void HeapSort(int arr[], int len)

                {

                     int tmp;

                     for (int i = len / 2; i > 0; --i)

                    {

                        //i  当前要调整的堆的父节点下标  len 有效长度

                        HeapAdjust(arr,i,len);

                     }

                     for (int j = len; j > 0; --j)

                    {

                         tmp = arr[1];

                         arr[1] = arr[j];

                         arr[j] = tmp;

                        HeapAdjust(arr, 1, j-1);

                    }

                 }

三、交换类排序
   1、冒泡排序
         算法思想：通过对相邻的数据元素的进行交换，逐步将待排序列变成有序序列。
         程序代码如下：
                 void BubbleSort(int arr[], int len)
               { 

                   int tmp;

                   bool mark = false;

                  for (int i = 0; i < len-1; i++)

                {

                     mark = false;

                     for (int j = 0; j < len - 1 - i; ++j)

                   {

                         if (arr[j]>arr[j + 1])

                       {

                          tmp = arr[j];

                          arr[j] = arr[j + 1];

                          arr[j + 1] = tmp;

                          mark = true;

                       }

                  }

                  printf("i = %d\n", i);

                  if (!mark)

                {

                      break;

                }

              }

            }    
   2、快速排序
         算法思想：采用分治法的思想，选一个基准，晓得数据放到基准数字的左边，大的数据放到右边。
         程序代码如下：
                int partition(int *arr,int low,int high)
              {
                    int tmp=arr[low];
                   while(low<high)
                  {
                         while(low<high&&arr[high]>tmp)
                        {
                              high--;
                        }
                        arr[low]=arr[high];
                        while(low<high&&arr[low]<tmp)
                       {
                             low++;
                       }
                       arr[high]=arr[low];
                  }
                  arr[low]=tmp;
                  return low;
              }
             void QSort(int *arr,int low,int high)
            {
                   if(low<high)
                  {
                       int boundkey=partition(arr,low,high);
                       QSort(arr,low,boundkey-1);
                       QSort(arr,boundkey+1,high);
                   }
            }
             void QuickSort(int *arr,int len)
            {
                 QSort(arr,0,len-1);
            }
四、归并排序
        算法思想：归并排序基本思想基于合并，将两个或两个以上有序表合并成一个新的有序表。首先将初始序列的n个记录看成n个有
                            序的子序列，每个子序列长度为1，然后两两归并，得到n/2个长度为2的有序子序列；在此基础上，再对长度为2的有
                            序子序列进行两两归并，得到若干长度为4的有序子序列。如此重复，直到得到一个长度为n的有序子序列为止。
        程序代码如下：
               void Merge(int arr[], int tmp[], int startIndex, int midIndex, int endIndex)

              {

                   int i = startIndex;

                   int j = midIndex + 1;

                   int k = startIndex;
                   while (i != midIndex + 1 && j != endIndex + 1)

                  {

                      if (arr[i] > arr[j])

                     {

                         tmp[k++] = arr[j++];

                      }

                      else

                     {

                         tmp[k++] = arr[i++];

                      }

                   }

                  while (i != midIndex + 1)

                 {

                     tmp[k++] = arr[i++];

                  }

                  while (j != endIndex + 1)

                 {

                    tmp[k++] = arr[j++];

                  }
                  for (int i = startIndex; i <= endIndex; ++i)

                 {

                      arr[i] = tmp[i];

                  }

             }

            void MergeSort(int arr[], int tmp[], int startIndex, int endIndex)

           {

                if (startIndex < endIndex)

               {

                    int midIndex = (startIndex + endIndex) / 2;

                    MergeSort(arr, tmp, startIndex, midIndex);

                    MergeSort(arr, tmp, midIndex + 1, endIndex);

                    Merge(arr, tmp, startIndex, midIndex, endIndex);

               }

           }