几种排序方法

几种排序方法

一、实验目的

1.了解内部排序的定义和基本方法

2.理解排序的基本思想和基本概念

3.掌握插入排序、冒泡排序、快速排序、直接选择排序、堆排序的基本思想、步骤、算法及时空效率分析

二、实验实验环境

    Windows下,编译器为Code::Blocks

三、实验内容

分别对每一个排序表多次运行插入排序、冒泡排序、快速排序、直接选择排序、堆排序，计算其平均运行时间。

四、实验步骤

分别对每一个排序表多次运行插入排序、冒泡排序、快速排序、直接选择排序、堆排序，计算其平均运行时间

  1-创建顺序表        2-进行插入排序         3-进行冒泡排序

  4-进行快速排序      5-进行直接选择排序      6-进行堆排序

7-输出排序后的数据

void CreateSqList(SqList<type> &sl)//创建顺序表

void BInsertSort(SqList<type> &L)//对顺序表L作折半插入排序

void BubbleSort(SqList<type> & L)//冒泡排序

int Partition(SqList<type>& L,int low,inthigh)//快速排序

int SelectMinKey(SqList<type>& L,int n)//简单选择排序的功能模块

 void SelectSort(SqList<type>& L)//对顺序表L作简单选择排序

void HeapAdjust(SqList<type>& L,int s,int m)//堆排序的子功能模块

void HeapSort(SqList<type>& L) //对顺序表L进行堆排序

五、实验小结及问题分析

1.插入排序的基本思想：在一个已排好序的记录子集的基础上，每一步将下 一个待排序的记录有序地插入到已排好序的记录子集中，直到将所有待排记录全部插入为止。

    折半插入排序比直接插入排序明显地减少了关键字间的“比较”次数，但记录“移动”的次数不变。因此，折半插入排序的事件复杂度仍为O(n2)

2.起泡排序：将第一个记录的关键字与第二个记录的关键字进行比较，若为 逆序R[1]>R[2]，则交换；然后比较第二个记录与第三个记录；依次类推

    冒泡排序时间复杂度,最好情况（正序）,比较次数：n-1移动次数：0,最坏情况（逆序）比较次数: 移动次数：,时间复杂为T(n)=O(n²)

3.快速排序：通过一趟排序，将待排序记录分割成独立的两部分，其中一部 分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，以达到整个序列有序

    快速排序快速排序主体算法时间运算量约O(log2n), 划分子区函数运算量约O(n), 所以总的时间复杂度为O(nlog2n),它显然优于冒泡排序O(n2)。可是算法的优势并不是绝对的, 试分析, 当原文件关键字有序时,快速排序时间复杂度是O(n2),这种情况下快速排序不快。

4.简单选择排序：基本思想：在待排序的数据中选出最大（小）的元素放在其最终的位置。

    直接选择排序时间复杂度,记录移动次数最好情况：0,最坏情况：3(n-1),比较次数：,时间复杂度为T(n)=O(n²)

5.堆排序：若在输出堆顶的最小值（最大值）后，使得剩余n-1个元素的序列重又建成一个堆，则得到n个元素的次小值（次大值）……如此反复，便能得到一个有序序列，这个过程称之为堆排序。

    堆排序，堆排序的时间主要耗费在建初始堆和调整建新堆时进行的反复“筛选”上。 堆排序在最坏情况下，其时间复杂度也为O(nlog2n)， 这是堆排序的最大优点。

具体实现代码.cpp文件

#include<iostream>
using namespace std;
#include"sort2.h"

int main()
{
    SqList<int> sl;
    int flag;
    cout<<"* 主  菜  单  *"<<endl;
    cout<<"  0 退出程序"<<endl;
	cout<<"  1.插入排序"<<endl;
	cout<<"  2.冒泡排序"<<endl;
	cout<<"  3.快速排序"<<endl;
	cout<<"  4.直接选择排序"<<endl;
	cout<<"  5.堆排序"<<endl;
    cout<<"请选择主菜单：";
    cin>>flag;
    while(flag!=0)
    {
        switch(flag)
        {
            case 1:
                CreateSqList(sl);
                BInsertSort(sl);
                cout<<"排序结果如下："<<endl;
                OutPut(sl);
                delete sl.key;
                break;
            case 2:
                CreateSqList(sl);
                BubbleSort(sl);
                cout<<"排序结果如下："<<endl;
                OutPut(sl);
                delete sl.key;
                break;
            case 3:
                CreateSqList(sl);
                SelectSort(sl);
                cout<<"排序结果如下："<<endl;
                OutPut(sl);
                delete sl.key;
                break;
            case 4:
                CreateSqList(sl);
                SelectSort(sl);
                cout<<"排序结果如下："<<endl;
                OutPut(sl);
                delete sl.key;
                break;
            case 5:
                CreateSqList(sl);
                HeapSort(sl);
                cout<<"排序结果如下："<<endl;
                OutPut(sl);
                delete sl.key;
                break;
        }
        cout<<"请选择主菜单：";
        cin>>flag;
    }
}

具体实现代码.h

#include"assert.h"
template<class type>
struct SqList{
	type * key;
	int length;
};

template<class type>
void CreateSqList(SqList<type> &sl)//创建顺序表
{
	int n;
	cout<<"建立顺序表"<<endl<<"请输入顺序表的长度"<<endl;
	cin>>n;
	sl.length=n;
	sl.key=new int[sl.length+1];
	assert(sl.key);
	cout<<"请输入数据："<<endl;
	for(int i=1;i<=sl.length;i++)
	{
		cin>>sl.key[i];
	}
}

template<class type>//输出顺序表内的数据
void OutPut(SqList<type> &L)
{
	for(int j=1;j<=L.length;++j)
		cout<<L.key[j]<<"\t";
	cout<<endl;
}

template<class type>//对顺序表L作折半插入排序
void BInsertSort(SqList<type> &L)
{
	int high,low,m;
	for(int i=2;i<=L.length;i++)
	{
		L.key[0]=L.key[i];
		low=1;
		high=i-1;
		while(low<=high)
		{
			m=(low+high)/2;
			if(L.key[0]<=L.key[m])
				high=m-1;
			else
				low=m+1;
		}
		for(int j=i-1;j>=high+1;--j)
			L.key[j+1]=L.key[j];
			L.key[high+1]=L.key[0];
	}
}

template<class type>//冒泡排序
void BubbleSort(SqList<type> & L)
{
	for(int i=1;i<L.length;i++)
	{
		type t;
		for(int j=1;j<=L.length-i;j++)
			if(L.key[j]>L.key[j+1])
			{
				t=L.key[j];
				L.key[j]=L.key[j+1];
				L.key[j+1]=t;
			}
	}
}

template<class type>//快速排序
int Partition(SqList<type>& L,int low,int high)
{
	type pivotkey;
	L.key[0]=L.key[low];
	pivotkey=L.key[low];
	while(low<high)
	{
		while(low<high&&L.key[high]>=pivotkey) --high;
		L.key[low]=L.key[high];
		while(low<high&&L.key[low]<=pivotkey) ++low;
		L.key[high]=L.key[low];
	}
	L.key[low]=L.key[0];
	return low;
}

template<class type>//简单选择排序的功能模块
int SelectMinKey(SqList<type>& L,int n)
{
	int min=n;
	type minkey;
	minkey=L.key[n];
	for(int i=n+1;i<=L.length;i++)
		if(L.key[i]<minkey)
		{
			minkey=L.key[i];
			min=i;
		}
		return min;
}
template<class type>
void SelectSort(SqList<type>& L)//对顺序表L作简单选择排序
{
	int j;
	type t;
	for(int i=1;i<=L.length;i++)
	{
		j=SelectMinKey(L,i);
		if(i!=j)
		{
			t=L.key[i];
			L.key[i]=L.key[j];
			L.key[j]=t;
		}
	}
}

template<class type>//堆排序的子功能模块
void HeapAdjust(SqList<type>& L,int s,int m)
{
	type rc=L.key[s];
	for(int j=2*s;j<=m;j*=2)
	{
		if(j<m&&L.key[j]<=L.key[j+1])
			j++;
		if(rc>L.key[j]) break;
		L.key[s]=L.key[j];
		s=j;
	}
	L.key[s]=rc;
}
template<class type>//对顺序表L进行堆排序
void HeapSort(SqList<type>& L)
{
	type value;
	int j;
	for(int i=L.length/2;i>0;i--)
		HeapAdjust(L,i,L.length);
	for(j=L.length;j>1;--j)
	{
		value=L.key[1];
		L.key[1]=L.key[j];
		L.key[j]=value;
		HeapAdjust(L,1,j-1);
	}

}

运行结果为