数学建模农产品定价

{
cout<<R[k]<<setw(8);
}
cout<<endl;
}
while((R[i]<=temp)&&(j>i))
{
count1++;
i=i+1;
}
if(i<j)
{
count2++;
temp1=R[j];
R[j]=R[i];
R[i]=temp1;
j=j-1;
cout<<"第"<<s<<"趟结果为:";
for(int j=n-1;j>=i;j--)
{
count1++;
if(R[j]<R[j-1])
{
int temp=R[j];
R[j]=R[j-1];
R[j-1]=temp;
count2++;
flag=1;
}
flag=1;
if(flag==0) break;
}
cout<<"第"<<i<<"趟排序结果为:";
for(int k=0;k<n;k++)
{
cout<<R[k]<<setw(8);
}
cout<<endl;
}
cout<<"比较次数为:"<<count1<<endl;
cout<<"交换次数为:"<<count2<<endl;
}
3.冒泡排序的效率分析
从冒泡排序的算法可以看出，若待排序的元素正序，则只需要进行一趟排序，比较次数为（n-1）次，移动次数为0；若待排序的元素为逆序，则需要进行n-1趟排序，比较次数为（n*n-n）/2，移动次数为3*(n*n-n)/2，因此冒泡排序算法的时间复杂度为O(n*n)。由于其中的元素移动较多，所以属于内排序中速度较慢的一种。
选取好实现算法后用类实现，有三个文件Sort1.h、Sort2.cpp、Sort3.cpp。所设计的类为Sort，成员函数有insertsort、Bubblesort、quicksort、selectsor、merge、mergepass、mergesort、print，然后在文件Sort2.cpp中实现这些成员函数，在Sort3.cpp中调用这些函数。
3.详细设计
1.直接插入排序的算法思想
直接插入排序的算法思想是：把n个待排序的元素看成一个有序表和一个无序表，开始
时有序表中只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
冒泡排序流程图
1.快速排序的算法思想
快速排序的基本思想是：任取待排序序列的某个元素作为基准（一般取第一个元素，通过一趟排序将待排序元素分为左右两个子序列，左子序列元素的排序码均小于或等于基准排序元素局排序码，右子序列的排序码则大于基准排序元素的排序码，然后分别对两个子序列继续进行排序，直至整个序列有序。快速排序是对冒泡排序的一种改进方法，算法中元素的比较和交换是从两端向中间进行的，排序码较大的元素一次就能交换到后面的单元，排序码较小的记录一次就能交换到前面的单元，记录每次移动的距离较远，因而总的比较次数和移动次数较少）。
冒泡排序的基本思想是：对排序序列从后向前（从下表较大的元素开始）依次比较相邻的元素的排序码，若发现逆序则交换，使排序码较小的元素逐渐从后部移向前部（从下标较大的单元移向下标较小的单元），就像水底下的气泡一样逐渐向上冒。
因为在排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过比较，就说明序列有序，因此要在排序的过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。
s++;
for(int k=0;k<N;k++)
{
cout<<R[k]<<setw(8);
}
cout<<endl;
}
}
R[i]=temp;
if(left<i-1) quicksort(R,left,i-1);
if(i+1<right) quicksort(R,i+1,right);
if(i==0)
{
2.选择排序的算法实现
void Sort::selectsort(int R[],int n) //选择排序
{
int i,jห้องสมุดไป่ตู้m,count1=0,count2=0,s=1;
int t;
for(i=0;i<n-1;i++)
{
m=i;
for(j=i+1;j<n;j++)
if(R[j]<R[m])
{
count1++;
快速排序所占用的辅助空间为栈的深度，故最好的空间复杂度为O(log2n)，最坏的空间复杂度为O(n)。
F T
快速排序流程图
1.选择排序的算法思想
直接选择排序的基本思想是：第一次从R[0]~R[n-1]中选取最小的值，与R[0]交换，第二次从R[2]~R[n-1]中选取最小值，与R[1]交换，第三次从R[2]~R[n-1]中选择最小值，与R[2]交换，………，第i次从R[i-1]~R[n-1]中选择最小值，与R[i-1]交换，………，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
//对两个子区间R[s]~R[m]和R[m+1]~R[t]进行合并，结果存入A中
{
int i,j,k;
i=s; j=m+1; k=s;
int count1=0,count2=0;
while((i<=m)&&(j<=t))
{
count1++;
if(R[i]<=R[j])
{
count2++;
A[k]=R[i];i++;k++;
1.冒泡排序的算法实现
void Sort::Bubblesort(int R[],int n)
{
int flag=1; //当flag为0,停止排序
int count1=0,count2=0;
for(int i=1;i<n;i++) //i表示趟数，最多为n-1趟
{
flag=0; //开始时元素未交换
Cmin=n-1 Mmin=2*(n-1)
Cmax=1+2+3+……….+n-1=(n*n-n)/2 Mmax=3+4+5+……………+n+1=(n*n+3*n-4)/2
Cave=(n*n+n-2)/4 Mave=(n*n+7*n-8)/4
因此，直接插入排序的时间复杂度为O(n*n)。
1.冒泡排序的算法思想
//对R数组做一趟归并，结果存入A数组中，N为元素个数，c为区间长度
{
int i,j;
i=0;
while(i+2*c-1<=n-1)
{
count1++; //count1用于快速排序中计算元素比较的次数
j=j-1;
}
if(j>i)
{
temp1=R[j];
R[j]=R[i];
R[i]=temp1;
i=i+1;
count2++; //count2用于快速排序中计算元素交换的次数
cout<<"第"<<s<<"趟结果为:";
s++;
for(int k=0;k<N;k++)
2.直接插入排序的算法实现
void Sort::insertsort(int R[],int n)
{
int count1=0,count2=0;
for(int i=1;i<n;i++)
{
int temp=R[i];
int j=i-1;
while((j>=0)&&(temp<R[j]))
{
R[j+1]=R[j];
数据结构课程设计报告
题目：各种排序
专业：网络工程
班级：10211303
学号：102113035
姓名：韩波
指导老师：姜林
2012年6月30日
1.需求分析说明
所要求的任务：用程序实现插入法排序、起泡法、选择法、快速法、合并法排序；
输入的数据形式为任何一个正整数，大小不限。输出的形式：数字大小逐个递增的数列。
m=j;
}
if(m!=i)
{
t=R[i];
R[i]=R[m];
R[m]=t;
count2++;
}
cout<<"第"<<s<<"趟排序结果为:";
s++;
for(int k=0;k<n;k++)
{
cout<<R[k]<<setw(8);
}
cout<<endl;
}
cout<<"比较次数为:"<<count1<<endl;
cout<<"交换次数为:"<<count2<<endl;
}
1.直接选择排序的效率分析
在直接选择排序中，共需要进行n-1次选择和交换，每次选择需要进行n-i次（1<=i<=n-1），
而每次交换最多需要3次移动，因此，总的比较次数C=(n*n-n)/2，总的移动次数M=3*(n-1)。由此可见，直接选择排序的时间复杂度为O(n*n)数量积，所以当记录占用的字节数较多时，通常比直接插入排序的执行速度要快一些。
1.二路归并排序的算法思想
二路归并排序的基本思想是：将两个有序子区间（有序表）合并成一个有序子区间，一
次合并完成后，有序子区间的数目减少一半，而区间的长度增加一倍，当区间长度从1增加到n(元素个数)时，整个区间变为一个，则区间中的有序序列即为我们所需要的排序结果。
2.二路归并排序的算法实现
void Sort::merge(int R[],int A[],int s,int m,int t)
若快速排序出现最坏的情形（每次能划分成两个子区间，但其中一个是空的），则这时得到的二叉树是一颗单分支树，的道德非空子区间包含两个n-i个元素（i代表二叉树的层数，1<=i<=n），每层划分需要的比较次数n-i+2次，所以总的比较次数为（n*n+3*n-4）/2。因此，快速排序的最坏时间复杂度为O(n*n)。
2.快速排序的算法实现
void Sort::quicksort(intR[],int left,int right)
{
int i=left,j=right;
int count1=0,count2=0,s=1;
int temp=R[i],temp1;
while(i<j)
{
while((R[j]>temp)&&(j>i))
要求给出多组不同元素个数的输入数据，并用列表打印出每种排序下的各趟排序结果。每个排序法结束时应打印出其元素比较的次数和交换的次数。此程序需将结果用列表打印，一定要将其打印结果排列好。为了给我们在生活中的各种排序工作带来方便，现在实现五种排序算法对整型数据进行递增排序，并输出数据。
2.总体设计
该程序需要五种排序算法，插入排序选用直接插入排序，冒泡排序，选择排序选用直接选择排序，快速排序，归并排序选择二路归并排序。
}
else
{
A[k]=R[j];j++;k++;
}
while(i<=m)
{
A[k]=R[i];i++;k++;
}
while(j<=t)
{
A[k]=R[j];j++;k++;
}
}
cout<<"比较次数为:"<<count1<<endl;
cout<<"交换次数为:"<<count2<<endl;
}
void Sort::mergepass(int R[],int A[],int n,int c)
cout<<"比较次数为:"<<count1<<endl;
cout<<"交换次数为:"<<count2<<endl;
}
}
3.快速排序的效率分析
若快速排序出现在最好的情形（左、右子区间的长度相等），则结点数n与二叉树深度
h应有满足log2h<h<log2n+1，所以总的比较次数不会超过（n+1）log2n。因此，快速排序的最好时间复杂度为O(n log2n)。而且在理论上已经证明，快速排序的平均时间复杂度也为O(nlog2n)。
count1++;
j--;
}
R[j+1]=temp;
count2++;
cout<<"第"<<i<<"趟排序结果为:";
for(int k=0;k<n;k++)
{
cout<<R[k]<<setw(8);
}
cout<<endl;
}
cout<<"比较次数为:"<<count2<<endl;
cout<<"插入次数为:"<<count1<<endl;
}
3.直接插入排序算法的效率分析
首先从空间来看，它只需要一个元素的辅助空间，用于元素的位置交换。从时间上分析，
首先外层循环要进行n-1次插入，每次插入最少比较以此（正序），移动两次；最多比较i次，移动i+2次（逆序）（i=1,2,………,n-1）。若分别用Cmin、Cmax和Cave表示元素的总比较次数的最小值、最大值和平均值，用Mmin、Mmax和Mave表示元素的总移动次数的最小值、最大值和平均值，则上述直接插入算法对应的这些量为：