高亮插件测试

练习搜索算法时的一些代码,试一下代码高亮的效果,可结果去如此糟糕 ...
怎么是这副模样? 跟模板不兼容 ??


// 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;
}

No comments:

Post a Comment