高亮插件测试

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

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