算法基础-排序

数据结构与算法基础

排序

• 将一组杂乱无章的数据按一定规律顺次排列起来

• 如果参加排序的数据结点包含多个数据域，那么排列往往是针对其中某个域而言的。

排序方法的分类

• 按数据存储介质：内部排序和外部排序

  • 内部排序：数据量不大，数据在内存，无需内外存交换数据

  • 外部排序：数据量较大，数据在外存

    外部排序时，要将数据分批调入内存来排序，中间结果还要及时放入外存，显然外部排序要复杂得多

• 按比较器个数：串行排序和并行排序

  • 串行排序：单处理机（同一时刻比较一对元素）
  • 并行排序：多处理机（同一时刻比较多对元素）

• 按主要操作：比较排序和基数排序

  • 比较排序：用比较的方法

    插入排序、交换排序、选择排序、归并排序

  • 基数排序：不比较元素的大小，仅仅根据数据本身的取值确定其有序位置。

• 按辅助空间：原地排序和非原地排序

  • 原地排序：辅助空间用量为O（1）的排序方法

    （所占的辅助存储空间与参加排序的数据量大小无关）

  • 非原地排序：辅助空间用量超过O（1）的排序方法

• 按稳定性：稳定排序和非稳定排序

  • 稳定排序：能够使任何数值相等的元素，排序以后相对次序不变
  • 非稳定性排序：不是稳定排序的方法。

• 按自然性：自然排序和非自然排序

  • 自然排序：输入数据越有序，排序的速度越快的排序方法
  • 非自然排序：不是自然排序的方法

存储结构：

#define MAXSIZE 20  //设记录不超过20个
typedef int KeyType; //设关键字为整型量（int型）

Typedef struct{//定义每个记录（数据元素）的结构
	KeyType key;//关键字
	InfoType otherinfo;//其他数据域
}RedType;//Record Type

Typedef struct{//定义顺序表的结构
    RedType r[MAXSIZE+1];//存储顺序表的向量
    //r[0]一般作哨兵或缓冲区
    int length;//顺序表的长度
}

插入排序

• 每步将一个待排序的对象，按其关键码的大小，插入到前面已经排好序的一组对象的适当位置上，知道对象全部插入为止。

基本操作

• 在有序序列中插入一个元素，保持序列有序，有序长度不断增加
• 起初，a[0]是长度为1的子序列。然后，逐一将a[1]至a[n-1]插入到有序子序列中。
• 插入a[i]前，数组a的**前半段（a[0]_{a[i-1]）是有序段**，后半段（a[i]}a[n-1]）是停留于输入次序的“无序段”。
• 插入a[i]使a[0]~a[i-1]有序，也就是要为a[i]找到有序位置j（0<=j<=i）,将a[i]插入在a[j]的位置上。

分类

• 直接插入排序

  使用顺序查找法查找插入位置

  • 复制插入元素
  • 记录后移，查找插入位置
  • 插入到正确位置

  使用哨兵法来实现直接插入排序

  • 复制为哨兵

    L.r[0] = L.r[i];

  • 记录后移，查找输入位置

    for(j=i-1;L.r[0].key<L.r[j].key;–j)

    ​ L.r[j+1] = L.r[j];

  • 插入到正确位置

    L.r[j+1] = L.r[0];

void InsertSort(SqList &L)
{
	int i,j;
	for(i = 2;i <= L.length;++i)
	{
		if(L.r[i].key < L.r[i-1].key)//若“<”,需要将L.r[i]插入有序子表
		{
			L.r[0] = L.r[i];//复制为哨兵
			for(j=i-1;L.r[0].key<L.r[j].key;--j)
			{
				L.r[j+1]=L.r[j];//记录后移
			}
			L.r[j+1] = L.r[0];//插入到正确位置
		}
			
	}
}

• 二分插入排序

  类似折半查找法

  void BinserSort(SqList &L)
  {
  	for(i=2;i<=L.length;++i)//依次插入第二~第n个元素
  	{
  		L.r[0] = L.r[i];//当前插入元素存到“哨兵”位置
  		low = 1;high = i-1;//采用二分查找法查找插入位置
          while(low<=high)
          {
              mid = (low + high)/2;
              if(L.r[0].key < L.r[mid].key)
              {
                  high = mid -1;
              }
              else
              {
                  low = mid+1;
              }
          }//循环技术，high+1则为插入位置
          for(j=i-1;j>=high+1;--j)
          {
              L.r[j+1] = L.r[j];//移动元素
          }
          L.r[high+1] = L.r[0];//插入到正确位置
  	}
  }
  

  • 折半插入排序的对象移动次数与直接插入排序相同，依赖于对象的初始排列
    • 减少了比较次数，但没有减少移动次数
    • 平均性能优于直接插入排序

• 希尔排序

  • 将整个待排序记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

  • 希尔排序算法的特点：

    • 缩小增量
    • 多遍插入排序

  • 先定义一个增量序列

  • 对每个Dk进行“Dk-间隔”插入排序（k=M，M-1,…1）

  • 希尔排序特点：

    • 一次移动，移动位置较大，跳跃式地接近排序后的最终位置
    • 最后一次只需要少量移动
    • 增量序列必须是递减的，最后一个必须是1
    • 只能改良序列应该是互质的

  • void ShellSort(Sqlist &L,int dlta[],int t)
    {
    	//按增量序列dlta[0..t-1]对顺序表L作希尔排序。
    	for(k=0;k<t;++k)
    	{
    		ShellInsert(L,dlta[k]);//一趟增量为dlta[k]d的插入排序
    	}
    }
    
    void ShellInsert(SqList &L,int dk)
    {//对顺序表L进行一趟增量为dk的Shell排序，dk为步长因子
        for(i=dk+1;i<=L.length;++i)
        {
            if(r[i].key < r[i-dk].key)
            {
                r[0] = r[i];
                for(j = i-dk;j>0&&(r[0].key<r[j].key);j = j-dk)
                {
                    r[j+dk] = r[j];
                }
                r[j+dk] = r[0];
            }
        }
    }
    

交换排序

• 两两比较，如果发生逆序则交换，直到所有记录都排好序为止。

• 冒泡排序

  void bubble_sort(SqList &L)//冒泡排序算法
  {
  	int m,i,j;
      RedType x;//交换时临时存储
      for(m = 1;m < n-1;m++)
      {
          for(j=1;j<=n-m;j++)
          {
              if(L.r[j].key>L.r[j+1].key)//发生逆转
              {
                  x = L.r[j];
                  L.r[j] = L.r[j+1];
                  L.r[j+1] = x;
              }
          }
      }
  }
  

• 快速排序

  • 基本思想
    • 任取一个元素（如：第一个）为中心（pivot：枢纽，中心点）
    • 所有比它小的元素一律前放，比它大的元素一律后放，形成两个子表
    • 对各自表重新选择中心元素并依此规则调整
    • 直到每个子表的元素只剩一个

void QSort(SqList &L,int low,int high)//对顺序表L快速排序
{
	if(low<high)//长度大于1
    {
        pivotloc = Partition(L,low,high);
        //将L.r[low..high]一分为二，pivotloc为枢轴元素排好序的位置
        QSort(L,low,pivotloc-1);//对低子表递归排序
        QSort(L,pivortloc+1,high);//对高子表递归排序
    }
}

int Partition(SqList &L,int low,int high)
{
    L.r[0] = L.r[low];
    pivotkey = L.r[low].key;
    while(low<high)
    {
        while(low<high&&L.r[high].key>=pivotkey)
        {
            --high;
        }
        L.r[low] = L.r[high];
        while(low<high&&.r[low].key<=pivotkey)
        {
            ++low;
        }
         L.r[high] = L.r[low];
    }
    L.r[low] = L.r[0];
    return low;
}

简单选择排序

• 在待排序的数据中选出最大（小）的元素放在其最终的位置

• 基本操作

  • 首先通过n-1次关键字比较，从n个记录中找出关键字最小的记录，将它与第一个记录交换
  • 再通过n-2次比较，从剩余的n-1个记录中找出关键字次小的记录，将它与第二个记录交换
  • 重复上述操作，共进行n-1趟排序后，排序结束

void SelectSort(SqList &K)
{
	for(i = 1;i<L.length;++i)
	{
		k=i;
		for(j=i+1;j<=L.length;j++)
		{
			if(L.r[j].key<L.r[k].key)
			{
				k = j;//记录最小值位置
			}
		}
		if(k!=i)
		{//交换
			tmp=L.r[i];
			L,r[i] = L.r[k];
			L.r[k] = tmp;
		}
	}
}

• 堆排序
  • ai<=a2i以及ai<=a2i+1,称该序列为小根堆
  • 从堆的定义可以看出，堆实质是满足如下性质的完全二叉树：二叉树中任一非子夜结点均小于（大于）它的孩子结点
  • 若再输出对丁的最小值（最大值）后，使得剩余n-1个元素的序列重又建成一个堆，则得到n个元素的次小值（次大值）…如此反复，便能得到一个有序序列，这个过程称之为堆排序。（堆顶的元素被取走了）
  • 小根堆：
    • 输出堆顶元素之后，以堆中最后一个元素替代之
    • 然后将根结点值与左、右子树的根结点值进行比较，并与其中小者进行交换；
    • 重复上述操作，直至叶子结点，将得到新的堆，称这个从堆顶至叶子的调整过程为“筛选”

void HeapSort(elem R[])
{
    //对R[1]到R[n]进行堆排序
    int i;
    for(i=n/2;i>=1;i--)
    {
        HeapAdjust(R,i,n);//建初始堆
    }
    for(i = n;i>1;i--)//进行n-1趟排序
    {
        Swap(R[1],R[i]);//根与最后一个元素交换
        HeapAdjust(R,i,i-1);//对R[1]到R[i-1]重新建堆
    }
}

归并排序

• 基本思想：将两个或两个个以上的有序子序列“归并”为一个有序序列

基数排序

• 基本思想：分配+收集

• 也叫桶排序或箱排序