关于c++几种简单排序算法的比较次数和移动次数的问题

问题描述

关于c++几种简单排序算法的比较次数和移动次数的问题

排序结果没有问题,可是比较次数和移动次数的计数结果不对。求高人指点。

#include<iostream>
using namespace std;

class Sort
{

private:
    int *r;
    int n; // the number of elements of array
    int MoveNum;
    int CompNum;

public:

    void insert();
    void bubble();
    int getn();
    void quick(int,int);
    void select();
    void shell();
    void ini();
    int partion(int,int);
    void Qsort(int,int);
    ~ Sort();
};
Sort::~Sort()
{
    delete []r;
}

void Sort::ini()
{
    int m;
    cout<<"输入带排序数字的个数为 ";
    cin>> m;
    r=new int[m+1];
    cout<<"输入待排序的"<<m<<"个数:"<<endl;
    for (int i=1;i<=m;i++)
    {
        cin>>r[i];
    }
    n=m;
}

void Sort::insert()
{
     MoveNum=0; CompNum=0;
    for(int i=2;i<=n;i++)
        if(r[i]<r[i-1])
        {
            r[0]=r[i];
            for(int j=i-1;r[j]>r[0];j--)
            {   r[j+1]=r[j];
            MoveNum++;
            }
            r[j+1]=r[0];
        }
        CompNum=MoveNum;

        cout<<"插入排序后的结果是";
        for( i=1;i<=n;i++)
            cout<<r[i]<<" ";

        cout<<endl  <<"移动次数为"<<MoveNum<<endl
            <<"比较次数为"<<CompNum<<endl<<endl<<endl;

}
void  Sort::shell()
{
     MoveNum=0; CompNum=0;
     for(int d=n/2;d>=1;d=d/2)
     {
          for(int k=d+1;k<=n;k++)
          {
             CompNum++;
             if(r[k]<r[k-d])
             {
                r[0]=r[k];
                int j=k-d;
                for(;j>0&&r[0]<r[j];j=j-d)
                {
                   r[j+d]=r[j];
                   MoveNum++;
                }
                r[j+d]=r[0];
             }
          }
     }
     cout<<"希尔排序后的结果是";
        for(int i=1;i<=n;i++)
            cout<<r[i]<<" ";

        cout<<endl  <<"移动次数为"<<MoveNum<<endl
            <<"比较次数为"<<CompNum<<endl<<endl<<endl;
}

void Sort::bubble()
{
    int count=0;
     MoveNum=0;
     CompNum=0;
    int pos=n;
    while(pos!=0)
    {
        int bound=pos;
        pos=0;
        for(int i=1;i<bound;i++)
        {
            CompNum++;

            if(r[i]>r[i+1])
            {
                r[0]=r[i];
                r[i]=r[i+1];
                r[i+1]=r[0];
                pos=i;count++;

            }
        }
    }

    MoveNum=count*3;
    cout<<"冒泡排序后的结果是";
    for( int i=1;i<=n;i++)
        cout<<r[i]<<" ";

    cout<<endl<<"移动次数为"<<MoveNum<<endl
        <<"比较次数为"<<CompNum<<endl<<endl<<endl;

}                     

void Sort::quick(int i,int j)
{
    if(i<j)
    {
        int loc=partion(i,j);
        quick(i,loc-1);
        quick(loc+1,j);
    }

}
void Sort::Qsort(int i,int j)
{
     MoveNum=0; CompNum=0;
    quick(i,j);
        cout<<"快速排序后的结果是";
    for( i=1;i<=n;i++)
        cout<<r[i]<<" ";
    cout<<endl  <<"移动次数为"<<MoveNum<<endl
        <<"比较次数为"<<CompNum<<endl<<endl<<endl;
}

int Sort::partion(int first,int end)
{
    int i=first;

    int j=end;
    int pivot=r[i];
    while(i<j)
    {

        MoveNum++;
        while((i<j)&&r[j]>=pivot)
        {
            j--;  CompNum++;
        }
        r[i]=r[j]; MoveNum++;
        while((i<j)&&r[i]<=pivot)
        {
            i++; CompNum++;
        }
        r[j]=r[i]; MoveNum++;
    }

    r[i]=pivot;
    return i;
}

void Sort::select()
{
    int count=0;
    int MoveNum=0;int CompNum=0;
    for(int i=1;i<n;i++)
    {
        int index=i;
        for(int j=i+1;j<=n;j++)
        {
            if(r[j]<r[index])
                index=j;
            CompNum++;
        }

            if(index!=i)
            {
                r[0]=r[i];
                r[i]=r[index];
                r[index]=r[0];
                count++;

            }

    }
        MoveNum=count*3;
    cout<<"选择排序后的结果是";
    for(i=1;i<=n;i++)
        cout<<r[i]<<" ";

    cout<<endl  <<"移动次数为"<<MoveNum<<endl
        <<"比较次数为"<<CompNum<<endl<<endl<<endl;
}

int Sort::getn()
{
    return n;
}

void main()
{
    Sort sort;
    sort.ini();
    sort.insert();
    sort.bubble();
    int j=sort.getn();
    sort.Qsort(1,j);
    sort.select();
    sort.shell();

}

解决方案

文学韭·11111111111111111111111111

时间: 2024-12-30 06:28:26

关于c++几种简单排序算法的比较次数和移动次数的问题的相关文章

视觉直观感受 7 种常用排序算法

10月14日发布<统计世界的十大算法>后,很多朋友在后台询问,哪里有"视觉直观感受 7 种常用排序算法",今天分享给大家,感谢todayx.org. 1. 快速排序 介绍: 快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要Ο(n log n)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来,

PHP 实现四种基本排序算法

PHP 实现四种基本排序算法 许多人都说算法是程序的核心,算法的好坏决定了程序的质量.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于基本的排序算法还是应该掌握的,它是程序开发的必备工具.这里介绍冒泡排序,插入排序,选择排序,快速排序四种基本算法,分析一下算法的思路. (题图来自:robinhoodsplayground.com) 前提:分别用冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中的值按照从小到大的顺序进行排序.  $arr(1,43,54,62,21,66,3

php四种基础排序算法的运行时间比较

/**  * php四种基础排序算法的运行时间比较  * @authors Jesse (jesse152@163.com)  * @date    2016-08-11 07:12:14  */ //冒泡排序法 function bubbleSort($array){     $temp = 0;     for($i = 0;$i < count($array) -1;$i++){         for($j = 0;$j < count($array) - 1 -$i;$j++){  

几种经典排序算法的JS实现方法_基础知识

一.冒泡排序 function BubbleSort(array) { var length = array.length; for (var i = length - 1; i > 0; i--) { //用于缩小范围 for (var j = 0; j < i; j++) { //在范围内进行冒泡,在此范围内最大的一个将冒到最后面 if (array[j] > array[j+1]) { var temp = array[j]; array[j] = array[j+1]; arra

PHP实现四种基础排序算法的运行时间比较(推荐)

许多人都说算法是程序的核心,算法的好坏决定了程序的质量.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于基本的排序算法还是应该掌握的,它是程序开发的必备工具.下面通过本文给大家介绍PHP实现四种基础排序算法的运行时间比较,一起看下吧. 废话不多说了,直接给大家贴代码了. 具体代码如下所示: /** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排

JavaScript版几种常见排序算法分享

说明 ·  每个浏览器测试得出的数据会不一样.比如我用chrome 测试 一般快速排序都会最快,IE 则根据数组长度有可能希尔最快. ·  不要用太大数据去测试冒泡排序(浏览器崩溃了我不管) 个人理解 ·  冒泡排序:最简单,也最慢,貌似长度小于7最优 ·  插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势 ·  快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合 ·  希尔排序:在非chrome下数组长度小于1000,希尔排序比快速更快 ·  系统

【轻松学排序算法】眼睛直观感受几种常用排序算法(转)

  1 快速排序 介绍: 快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要Ο(n log n)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来,且在大部分真实世界的数据,可以决定设计的选择,减少所需时间的二次方项之可能性. 步骤: 从数列中挑出一个元素,称为 "基准"(pivot), 重新排序数列,所有

基于python的七种经典排序算法(推荐)_python

一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定的. 内排序和外排序 内排序:排序过程中,待排序的所有记录全部放在内存中 外排序:排序过程中,使用到了外部存储. 通常讨论的都是内排序. 影响内排序算法性能的三个因素: 时间复杂度:即时间性能,高效

Java实现几种常见排序算法代码_java

稳定度(稳定性)一个排序算法是稳定的,就是当有两个相等记录的关键字R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 排序算法分类 常见的有插入(插入排序/希尔排序).交换(冒泡排序/快速排序).选择(选择排序).合并(归并排序)等. 一.插入排序 插入排序(Insertion Sort),它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),