面试需要掌握的基本排序算法实现(已在VS2012上验证)

1、冒泡排序算法(改进版)

void BubleSort(vector<int> &arr, int max)
{
   //max=length-1
   bool flag=true;//flag用来作为标记
   for (int i=0; i<=max && flag; i++)
   {
      flag=false;
      for (int j=max; j>i; j--)
      {
         /*如果有数据交换，则flag=true；否则，说明序列已有序，没有必要进入下一轮循环比较*/
         if (arr[j-1]>arr[j])
         {
            swap(arr[j-1], arr[j]);
            flag=true;
         }
      }
   }
}

2、插入排序算法

void InsertSort(vector<int> &arr, int n)
{
     for (int i=1; i<n; i++)
     {
           int temp=arr[i];
           int j=i-1;
           /*默认0到i-1有序，从第i个数据开始插入，若arr[i-1]小于arr[i]，则跳出循环*/
           while (j>=0 && arr[j]>temp)
           {
                arr[j+1]=arr[j];
                j--;
           }
           arr[j+1]=temp;//交换值
     }
}

 

3、选择排序算法

void SelectSort(vector<int> &a, int n)
{
     for (int i=0; i<n; i++)
     {
           int min=i;//保存最小值下标
           for (int j=i+1; j<n; j++)
           {
                if (a[min]>a[j])
                {
                     min=j;
                }
           }
           /*若最小下标值发生变化，则交换*/
           if (i!=min)
           {
                swap(a, i, min);
           }
     }
}

4、希尔排序算法

void ShellSort(vector<int> &arr, int n)
{
     int increment=n/2;//初始化间隔
     while (increment>0)
     {
           for (int i=increment; i<n; i++)
           {
                int temp=arr[i];
                int j=i-increment;
                while (j>=0 && arr[j]>temp)
                {
                     arr[j+increment]=arr[j];
                     j-=increment;
                }
                arr[j+increment]=temp;//交换值
           }
           increment=increment/2;
     }
}

5、归并排序算法

/* left=0, right=size-1 */
void MergeSort(vector<int> &arr, int left, int right)
{
   if (left<right)
   {
      int mid=(left+right)/2;
      MergeSort(arr, left, mid);
      MergeSort(arr, mid+1, right);
      Merge(arr, left, mid, right);//合并两部分
   }
}

/*合并两个子序列，结果保存到vector向量*/
void Merge(vector<int> &arr, int left, int mid, int right)
{
   int i=left, j=mid+1;
   int k=0;
   int n=right-left+1;//元素个数
   vector<int> help(n);//辅助向量
   while (i<=mid && j<=right)
   {
      if (arr[i]<arr[j])
      {
         help[k++]=arr[i++];
      }
      else
      {
         help[k++]=arr[j++];
      }
   }
   while(i<=mid)
   {
       help[k++]=arr[i++];
   }
   while (j<=right)
   {
       help[k++]=arr[j++];
   }
   /*从辅助向量中拷贝到原向量*/
   for (int c=0; c<n; c++)
   {
      arr[left+c]= help[c];
   }
}

6、快速排序算法

/* low=0, high=size-1 */
void QuickSort(vector<int> &arr, int low, int high)
{
   if (low<high)
   {
      int pivot=Partition(arr, low, high);//计算枢轴值
      QuickSort(arr, low, pivot-1);//对低端记录递归排序
      QuickSort(arr, pivot+1, high);//对高端记录递归排序
   }
}

int Partition(vector<int> &arr, int low, int high)
{
   int pivotkey=arr[low];//初始化枢轴记录
   while (low<high)
   {
      /*将比枢轴记录小的记录交换到低端*/
      while (low<high && arr[high]>=pivotkey)
      {
         high--;
      }
      swap(arr, low, high);
      /*将比枢轴记录大的记录交换到高端*/
      while (low<high && arr[low]<=pivotkey)
      {
         low++;
      }
      swap(arr, low, high);
   }
   return low; //返回枢轴位置（此时low与high相等）
}