题注：《面试宝典》有相关习题，但思路相对不清晰，排版有错误，作者对此参考相关书籍和自己观点进行了重写，供大家参考。

九、数据结构面试之十——排序1（直接插入、希尔、冒泡、直接选择排序）

1.直接插入排序

【算法思想】：每次将一个待排序的元素，插入到前面已经排序的子序列中，直到全部元素插入完毕为止。

【算法实现】：

//最简实现排序[交换实现].

template <class T>
void directInsertSort(T arr[],int N)
{
       inti;
       intj;
       for( i = 1; i < N; i++)
       {
              for(j= i-1; j >= 0 && arr[j+1] < arr[j];j--)
              {
                     swap(arr[j+1],arr[j]);
              }//endfor
       }//endfor
}

//直接插入排序[移动版本]

template <class T>
void directInsertSort(T arr[], int N)
{
       inti;
       intj;
       for( i = 1; i < N; i++)
       {
              inttemp = arr[i];
              for(j = i-1; j >= 0 && temp < arr[j]; j--)
              {
                     arr[j+1]= arr[j];  //后移动
              }
              arr[j+1]= temp;        //找到插入的位置.
       }
}


2.希尔排序

【算法思想】：将待排序的序列按照步长划分子序列，对子序列进行直接插入排序，然后递减步长直至为1（最小步长），这样整个序列就会基本有序，然后进行最后一次直接插入排序即可。

【算法实现】：

template<class T>
void ShellSort(T arr[], int N)
{
       inti;
       intj;
       intstep;
       for( step = N/2; step > 0; step/=2)
       {
              for(i= step; i < N; i++) //注意此处递增的步长为1，依次比较!
              {
                     for(j= i-step; j >=0 && arr[j+step] < arr[j]; j-=step)
                     {
                            swap(arr[j+step],arr[j]);
                     }//endfor j
              }//endfor i
       }//endfor step
}



希尔排序，可以看做是直接插入排序的改进算法，在直接插入排序的基础上多了外层循环，依次递减步长，最终完成排序。

 

3. 冒泡排序

【算法思想】：1）将待排序的序列元素之间两两进行比较，如果第一个元素大于第二个元素，则进行交换；2）这样经过一趟排序之后，确保值最大的元素在最底部；3）排序完一次后N-1，重复1），2）知道N==0为止。

【算法实现】：

//经典冒泡

template<typename T>
void BubuleSort(T a[], int N)
{
       inti,j;
       for(i= 0; i < N; i++)
       {
              for(j= 0; j < N-i-1; j++)
              {
                     if(a[j]> a[j+1])
                     {
                            swap(a[j],a[j+1]);
                     }//endif j
              }//endfor j
       }//endfor i
}



//改进+是否交换标识


template<typename T>
void BubuleSort(T a[], int N)
{
       inti,j;
       boolbExchange = true;         //初始设定为true
       for(i= 0; i < N && bExchange; i++)
       {
              bExchange= false;        //进入循环则设定为false
              for(j= 0; j < N-i-1; j++)
              {
                     if(a[j]> a[j+1])
                     {
                            swap(a[j],a[j+1]);
                            bExchange = true;//存在交换则变为true.
                     }//endif j
              }//endfor j
       }//endfor i
}


 

4. 选择排序

【算法思想】：同直接插入排序，将元素分为有序区和无序区。所不同的是，直接插入排序是将无序区域中第一个元素插入到有序区域以形成更大的有序区；而选择排序是从无序区域中选择最小的元素放入有序区的最后。

【算法实现】：

template <class T>
void SelectSort(T arr[], int N)
{
       intminPos;
       for(int i = 0; i < N; i++)
       {
              minPos= i;
              for(intj=i+1; j<N; j++)
              {
                     if(arr[j]< arr[minPos])
                     {
                            minPos= j;
                     }//endif
              }//endfor
              if(minPos!= i)
              {
                     swap(arr[minPos],arr[i]);//交换
              }
       }
}