练习搜索算法时的一些代码，试一下代码高亮的效果，可结果去如此糟糕 ...
怎么是这副模样？ 跟模板不兼容 ？？
// Sorting.cpp : by iX.
//
#include ＜stdio.h＞
#include ＜string＞
#include ＜iomanip＞ //支持cout格式化输出
#include ＜iostream＞
static string ss;
class rnda //定义一个随机数组类
{
public:
int num; //数组元素个数
double *p; //指针p指向数组空间首地址
public:
rnda(int);
void print();
};
rnda::rnda(int n) //由指定值生成数组
{
int i,j;
num=n;
p=new double[num];
double r=1.0;
for(i=0;i＜num ;i++) //产生num个0-1之间的随机数
{
r=2053.0*r+13849.0;
j=r/65536.0;
r=r-j*65536.0;
p[i]=r/65536.0;
}
for(i=0;i＜num;i++) //产生num个0-1000之间的随机数
p[i]=0+1000.0*p[i];
return;
}
void rnda::print() //打印出当前数组
{
int i;
for(i=0;i＜num;i++)
cout＜＜setw(10)＜＜p[i];
cout＜＜endl;
}
//*****************定义各类排序算法函数**********************
// A、双向扫描冒泡算法
void bubble(double a[],int n)
{
int up,dn,i,j; //定义i,j两个临时变量
double t; //t用于数值交换的临时变量
up=0; dn=n-1; //up作为数组扫描的上界标识，dn下界标识
while(up＜dn)
{j=dn-1;dn=0;
for(i=up;i＜=j;i++)
//从前(up)往后(dn)扫描，将较大值往后排
if(a[i]＞a[i+1])
//最后一次交换后的i值作为下界(dn)标识
{t=a[i];a[i]=a[i+1];a[i+1]=t;dn=i;}
j=up+1;up=0;
for(i=dn;i＞=j;i—)
//从后(dn)往前(up)扫描，将较大值往后排
if(a[i-1]＞a[i])
//最后一次交换后的i值作为上界(up)标识
{t=a[i-1];a[i-1]=a[i];a[i]=t;up=i;}
}
ss="冒泡算法";
return;
}
// B、快速排序算法（递归）
static int split(double p[],int n) //用于快速排序法的表的分割函数
{
int i,j,k,l;
double t;
i=0;j=n-1;
k=(i+j)/2;
if ((p[i]＞=p[k])&&(p[k]＞=p[j])) l=k; //在表的前、中、后三个元素中选取中项作为分割点
else if((p[i]＞=p[j])&&(p[j]＞=p[k])) l=j;
else l=i;
t=p[l]; //...
p[l]=p[i]; //将此时的第一个元素p[i]的值移到中项p[l]
while(i!=j)
{
while((i＜j )&&(p[j]＞=t)) //从后向前检查，发现不大于t的p[j]就把它丢到前面的p[i]
j--;
if(i＜/j＞＜j )
{
p[i]=p[j];i++; //...
while((i＜j)&&(p[i]＞=t)) //从前向后检查，发现不小于t的p[i]就把它丢给后面的p[j]
i++;
if(i＜/j＞＜j )
{p[j]=p[i];j--;} //...
}
}
p[i]=t; //在i,j指向同一个位置的时候，再把分割值赋给p[i]
return(i); //返回分割线位置
}
//排序函数
void quick(double b[],int n)
{
int m,i;
double *s;
if(n＞10)
{
i=split(b,n); //对表进行分割，同时得到分割线位置
quick(b,i); //对分割后的前部分子表进行快速排序
s=b+(i+1); m=n-(i+1);
quick(s,m); //对后面子表进行快速排序
ss="快速排序算法";
}
else
bubble(b,n); //子表长度若小于10，则调用冒泡法排序
return;
}
// C、简单插入排序算法
void insort(double c[],int n)
{
int i,k;
double t;
for(i=1;i＜n ;i++)
{
t=c[i];
for (k=i-1;k＞=0;k--) //将t的值依次往前插入
if (c[k]＞t)
c[k+1]=c[k];
else break; //跳出，避免无畏的比较
c[k+1]=t;
}
ss="简单插入排序算法";
return;
}
// D、希尔排序算法
void shell_sort(double d[],int n)
{
int i,h,k;
double t;
h=n/2; //在步进h恒等于1时，等价于插入排序法
while (h＞0)
{
for(i=h;i＜/n＞＜n -1;i++)
{
t=d[i];
k=i-h;
while((k＞=0)&&(d[k]＞t))
{d[k+h]=d[k];k-=h;}
d[k+h]=t;
}
h=h/2; //减小步进，进行下一轮的排序
}
ss="希尔排序算法";
return;
}
// E、堆排序算法（适用于大规模的线性表排序）
static int sift(double p[],int i,int n) //用于堆排序法的表的筛选函数
{
int j;
double t;
t=p[i];j=2*(i+1)-1;
while (j＜ =n)
{
if((j＜n)&&(p[j]＜p[j+1])) j++;
if (t＜p[j])
{p[i]=p[j];i=j;j=2*(i+1)-1;}
else j=n+1;
}
p[i]=t;
return(0);
}
void heap(double e[],int n)
{
int i,mm;
double t;
mm=n/2;
for(i=mm-1;i＞=0;i--)
sift(e,i,n-1);
for(i=n-1;i＞=1;i--)
{
t=e[0];e[0]=e[i];e[i]=t;
sift(e,0,i-1);
}
ss="堆排序算法";
return;
}
// 定义一个用于调用特定排序函数对数组进行排序的函数
void sorting(int s,double p[],int n)
{
void (*f)(double[],int); //(*f)(double,int) ——指向函数的指针
switch (s)
{
case 1: f=bubble;
break;
case 2: f=quick;
break;
case 3: f=insort;
break;
case 4: f=shell_sort;
break;
case 5: f=heap;
break;
}
(*f)(p,n); // 调用对应函数排序
return;
}
//***************** Main函数 **********************
int main()
{
int n,f=0;
cout＜ ＜"定义随机数组数据成员个数（1~1000间的随机数组）"＜＜endl;
cin＞＞n;
rnda r(n); //产生一个有n个成员的随机数组
cout＜ ＜"随机数组："＜＜endl;
r.print();
while(f<1||f＞5)
{
cout＜ ＜"选择排序算法："＜＜endl;
cout＜＜"... 1、双向扫描冒泡算法"＜＜endl;
cout＜＜"... 2、快速排序算法"＜＜endl;
cout＜＜"... 3、简单插入排序算法"＜＜endl;
cout＜＜"... 4、希尔排序算法"＜＜endl;
cout＜＜"... 5、堆排序算法"＜＜endl＜＜endl;
cout＜＜"选择：";
cin＞＞f;
}
sorting(f,r.p,r.num);
cout＜ ＜endl＜＜"按["＜＜ss＜＜"]排列后数组："＜＜endl;
r.print();
return 0;
}
Comments
Post a Comment