数据结构与算法分析 c++ 排序

                                                                                  排序

   外部排序

不能在主存中完成而必须在磁盘或磁带上完成的排序为外部排序     

  内部排序

       内部排序是数据记录在内存中进行排序。

      几种常用的内部排序：冒泡排序，简单选择排序，直接插入排序，希尔排序，快速排序，归并排序，堆排序，基数排序。

      下面将从算法思想, 时间空间复杂度和算法例程来归纳一下这八中排序：

冒泡排序

1. 算法思想：

一种交换排序，两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

2. 算法复杂度及稳定性：

               平均时间复杂度：O(n^2)

               空间复杂度：O(1)

               稳定性：稳定性算法

3. 算法例程

/********************冒泡排序算法******************************/
void BubbleSort(int array[],int length)
{
       int i,j;
       for(i=0;i<length-1;i++)
       {
              for(j=length-2;j>=i;j--)//从后朝前比较，将较小的放置前面
              {
                     if(array[j]>array[j+1])
                            swap(array,j,j+1);
              }
       }
}

简单选择排序

1. 算法思想：

一种交换排序，两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

2. 算法复杂度及稳定性：

               平均时间复杂度：O(n^2)

               空间复杂度：O(1)

               稳定性：稳定性算法

3. 算法例程

/********************简单选择排序******************************/
void SelectSort(int array[],int length)
{
       inti,j,min;
       for(i=0;i<length-1;i++)
       {
              min=i;               //记录length-i最小元素
              for(j=i+1;j<length;j++)
              {
                     if(array[j]<array[min])
                            min=j;
              }
              if(i!=min)
                     swap(array,i,min);
       }
}

直接插入排序

1. 算法思想：

假设前 个记录已经有序，将第 个记录插入到已经已经排好序的有序表中，从而得到一个有 个记录的新的有序表。 

2. 算法复杂度及稳定性：

               平均时间复杂度：O(n^2)

               空间复杂度：O(1)

               稳定性：稳定性算法

3. 算法例程

     /* 插入排序 */
template <typename Comparable>
void insertionSort(vector<Comparable> &a)
{
	for (int p = 1; p < a.size(); ++p)
	{
		Comparable tmp = std::move(a[p]);
		int j=0;
		for (j = p; j > 0 && tmp < a[j - 1]; --j)
			a[j] = std::move(a[j - 1]);
		a[j] = std::move(tmp);

	}
}

希尔排序

1. 算法思想：

实质上就是直接插入排序的改进，先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）

分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全

体元素进行一次直接插入排序。

2. 算法复杂度及稳定性：

               平均时间复杂度：O(n^2)

               空间复杂度：O(1)

               稳定性：不稳定性算法

3. 算法例程

/********************希尔排序******************************/
void ShellSort(int array[],int length)
{
       inti,j,temp,gap;
       for(gap=length/2;gap>0;gap=gap/2)//增量序列
       {
              for(i=gap;i<length;i++)
              {
                     if(array[i]<array[i-gap])//将array[i]插入到增量子序列中
                     {
                            temp=array[i];
                            for(j=i;j>0&&temp<array[j-gap];j=j-gap)
                            {
                                   array[j]=array[j-gap];
                            }
                            array[j]=temp;
                     }
              }
       }
}

快速排序

归并排序

堆排序

基数排序。