HNU内排序实验

时间过得真快啊,又到了写数据结构实验的时候。这次是内排序。

1.shell排序

【问题描述】

    输入若干整数,使用shell排序后输出。

【输入形式】

    输入的第一行一个整数 n ( 0 < n ≤ 107),表示待排序的数的个数。

    接下来的一行,包含 n 个整数,表示待排序的数据。

【输出形式】

    输出为一行 n 个数,表示已排序后的数。

【样例输入】

5
5 4 3 2 1

【样例输出】

1 2 3 4 5

#  include  <iostream>
#  include  <algorithm>
using  namespace  std;

/*
shell排序是将目标序列分成多个子序列,然后对每个子序列进行插入排序。(因为插入牌排序对小数量序列的平均复杂度很低)
*/

void  inssort(int  *A,  int  n,  int  incr)
{//可以看到这里完成的是插入排序,跳跃间隔为incr,复杂度为n方
        for(int  i  =  incr;  i  <  n;  i  +=  incr)
                for(int  j  =  i;  (j  >=  incr)  &&  (A[j]  <  A[j  -  incr]);  j  -=  incr)
                        swap(A[j],  A[j  -  incr]);
}

void  shellsort(int  *A,  int  n)
{
        for(int i=n/2;i>2;i/=2) //for each incr incr递增从2到n
		for(int j=0;j<i;j++) //sort sublists 每一个小于递增初始值的数列项
			inssort(&A[j],n-j,i);//传入A[j]开始的子列,和incr
			inssort(A,n,1);//最后再传入最后一次incr为1的排序,单独传当然是因为子列不符合该规律啦
}


int  main()
{
        int  n;
        scanf("%d",  &n);
        int  *a;
        a  =  new  int[n];
        for(int  i  =  0;  i  <  n;  i++)
                cin  >>  a[i];

        shellsort(a,  n);

        for(int  i  =  0;  i  <  n;  i++)
                cout  <<  a[i]  <<  "  ";
        cout  <<  endl;
        return  0;
}

这一版本shellsort有点问题,在CG高并发的时候会run time error,应该是复杂度太高了(n立方)

2.归并排序mergesort

【问题描述】

    输入若干整数,使用归并排序后输出。

【输入形式】

    输入的第一行一个整数 n ( 0 < n ≤ 107),表示待排序的数的个数。

    接下来的一行,包含 n 个整数,表示待排序的数据。

【输出形式】

    输出为一行 n 个数,表示已排序后的数。

【样例输入】

5
5 4 3 2 1

【样例输出】

1 2 3 4 5

#  include  <iostream>
#  include  <algorithm>
using  namespace  std;


void  mergesort(int  *A,  int  *temp,  int  left,  int  right)
//shaffe教材给出的mergesort非常优美,值得记下来
{
if(left==right) return;
/*************************递归终止条件********************************/
int mid=(left+right)/2;//
/*************************取二分终点*********************************/
mergesort(A,temp,left,mid);
mergesort(A,temp,mid+1,right);
/**************向左向右递归,后面的代码认为左右已归并排序完成***************************/
for(int i=left;i<=right;i++) //copy
temp[i]=A[i];
/***********************把完成归并的代码复制到辅助空间里****************************/
int i1=left;int i2=mid+1;
for(int curr=left;curr<=right;curr++) {
    if(i1=mid+1)//left exhausted 左子串用完补右子串
        A[curr]=temp[i2++];
    else if(i2>right)//right exhausted 右子串用完补左子串
        A[curr]=temp[i2++];
    else if(temp[i1]<temp[i2]) //按照正常情况排序
       A[curr]=temp[i1++];
    else   A[curr]=temp[i2++];
}
}

int  main()
{
        int  n;
        scanf("%d",  &n);
        int  *a,  *temp;
        a  =  new  int[n];
        temp  =  new  int[n];
        for(int  i  =  0;  i  <  n;  i++)
                cin  >>  a[i];

        mergesort(a,  temp,  0,  n  -  1);          

        for(int  i  =  0;  i  <  n;  i++)
                cout  <<  a[i]  <<  "  ";
        cout  <<  endl;
        return  0;
}

我太菜了,其实CG上没做出来,考试的时候才做出来的。我在CG上做错的是,左右用完再补的地方不理解,以及递归终止条件没写对。
递归终止条件是左等于右,这从归并排序原理可以看到,将每个子串分到一个元素就停止。

归并排序补充一个非递归实现版本
摘自优快云用户 W1024201

void Merge(int arr[], int len, int gap)//gap:代表合并的两个组中单独的组个数是多少(几几合并的几)
{
	//第一步,先整出来辅助空间brr
	int* brr = (int*)malloc(len * sizeof(int));
	assert(brr != NULL);
	int i = 0; //i是辅助空间brr的下标   代表下一个值插入位置
 
	int low1 = 0;//左手的左边界
	int high1 = low1 + gap - 1;//左手的右边界
	int low2 = high1 + 1;//右手的左边界
	int high2 = low2 + gap - 1 < len ? low2 + gap - 1 : len - 1;//右手的右边界
 
	while (low2 <= high2)//确保左手和右手都抓到值(左右手都不空),只要右手还有值,左手肯定抓满值了
	{
        //代表着,融合比较过程中,左右手还不空
        //有一个空了,就不用比较了,直接向brr挪动另一个手中的数据即可
		while (low1 <= high1 && low2 <= high2)
		{
			if (arr[low1] <= arr[low2])//如果左手的第一个值 <= 右手的第一个值
			{
				brr[i++] = arr[low1++];//将左手的第一个值放到brr中
			}
			else//如果左手的第一个值 > 右手的第一个值
			{
				brr[i++] = arr[low2++];//将右手的第一个值放到brr中
			}
		}
 
		//当内层while循环退出,代表着肯定有一个手空了
		//这里可以不用判断到底哪个手空了,简单粗暴一点(两个数组都调用一下,将其剩余数据向brr挪动)
		while (low1 <= high1)//将左手剩余数据向brr中挪动
		{
			brr[i++] = arr[low1++];
		}
		while (low2 <= high2)//将右手剩余数据向brr中挪动
		{
			brr[i++] = arr[low2++];
		}
 
		//左手右手数据处理完毕,平移,让左手右手再抓两个组
		low1 = high2 + 1;
		high1 = low1 + gap - 1;
		low2 = high1 + 1;
		high2 = low2 + gap - 1 < len ? low2 + gap - 1 : len - 1;
	}
 
	//此时,代表着处理到最后一组了:这时候退出有两种情况:1.左右手都没有抓到值 2.左手不空,右手空 
	//会不会存在第三种情况:左手空,右手不空?  这种情况不存在
	//那么怎么处理上面两种可以出现的情况:第一种皆大欢喜,不用管了
	//                                    第二种,需要处理一下
 
	//处理2:左手的值放到brr里,右手肯定为空 不用管
	while (low1 < len)//将左手剩余数据向brr中挪动  //这里是low1<len
	{
		brr[i++] = arr[low1++];
	}
 
	//最后一步,brr里放满了值, 这时只需要将brr的值同步到arr里即可
	for (int k = 0; k < len; k++)
	{
		arr[k] = brr[k];
	}
 
	free(brr);//释放辅助空间brr
	brr = NULL;
 
}
void MergeSort(int* arr, int len)
{
    assert(arr != NULL);
	//i代表几几合并的几   当i小于len时,才有必要进行一次融合
	//当i大于等于len时,没有必要进行一次融合,因为这时所有的值都在同一个组内
	for (int i = 1; i < len; i *= 2) //logn
	{
		Merge(arr, len, i);
	}
}

摘录的原因是,考了递归实现和非递归实现排序两趟的结果
需要注意,递归实现和非递归实现两趟的结果并没有什么区别,我们老师认为第一趟排序结果是两两排序,第二趟是四四排序

3.快速排序qsort

【问题描述】

    输入若干整数,使用快速排序后输出。

【输入形式】

    输入的第一行一个整数 n ( 0 < n ≤ 107),表示待排序的数的个数。

    接下来的一行,包含 n 个整数,表示待排序的数据。

【输出形式】

    输出为一行 n 个数,表示已排序后的数。

【样例输入】

5
5 4 3 2 1

【样例输出】

1 2 3 4 5

#  include  <iostream>
#  include  <algorithm>
using  namespace  std;

inline  int  findpivot(int  *A,  int  i,  int  j)
{
        return  (i  +  j)  /  2;
}
inline  int  Partition(int  *A,  int  left,  int  right,  int&  pivot)
{
        do
        {
                while(A[++left]  <  pivot);
                while((left  <  right)  &&  (pivot  <  A[--right]));
                swap(A[left],  A[right]);
        }
        while(left  <  right);
        return  left;
}
void  qsort(int  *A,  int  left,  int  right)
{
          if (left >= right)  return;
  /**********************递归终止条件************************/
    int pivotidx=findpivot(A,left,right);//找界标
    swap(A[pivotidx],A[right]);//界标放在最边上
    int k=Partition(A,left-1,right,A[right]);//传左右界限参数和界标,放入划分函数
    swap(A[k],A[right]);//把界标放在界标位置(界标在par函数里一直在最右边,没动过)
    /***************************处理划分操作和界标位置*****************************/
    qsort(A,left,k-1);
    qsort(A,k+1,right);
/*********************以界标为界限,向左向右递归********************************/
}
int  main()
{
        int  n;
        scanf("%d",  &n);
        int  *a;
        a  =  new  int[n];

        for(int  i  =  0;  i  <  n;  i++)
                cin  >>  a[i];

        qsort(a,  0,  n  -  1);

        for(int  i  =  0;  i  <  n;  i++)
                cout  <<  a[i]  <<  "  ";
        cout  <<  endl;
        return  0;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值