Dijkstra算法以及各种海量数据排序算法

一、Dijkstra最短路径算法

是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

实现一

//
//  Dijkstra
//  ACM
//  Find the number of minimal path
//
//  Created by Rachel on 18-2-12.
//  Copyright (c) 2014年 ZJU. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <functional>
#include <utility>
#include <memory.h>
using namespace std;
#define N 505
#define INF 100000000
#define min(a,b) a<b?a:b
#define max(a,b) a>b?a:b

int map[N][N];
int minres[N]; //min distance from source to point_i
bool visited[N];
int weight[N];

void init(int n)
{
    int i,j;
    for (i=0; i<n; i++) {
        for (j=0; j<n; j++) {
            map[i][j] = INF;
        }
        minres[i] = INF;
    }
    memset(visited, false, sizeof(visited));
}

void dijkstra(int source, int dest, int n)
{
    int i,j;
    for(i=0;i<n;i++)
        minres[i]=map[source][i];
    visited[source]=true;
    
    // (n-1) times, each time select one point into the start point set
    for (j=0; j<n-1; j++) {
        //select a point to add into the start point set
        int minn = INF, point=-1;
        for(i=0;i<n;i++)
            if (!visited[i]&&minres[i]<minn) {
                minn = minres[i];
                point = i;
            }
        visited[point] = true;
        
        //update the min distance of other points
        for (i=0; i<n; i++) {
            if (!visited[i]&&minres[i]>minres[point]+map[point][i]) {
                minres[i] = minres[point]+map[point][i];
            }
        }
    }
}

void dfs(int source, int dest,int n, int curpoint, int curdis, int cursum, int* num, int* sum)
{
    if (curpoint==dest && minres[dest]==curdis) {
        *num = *num+1;
        *sum = max(*sum, cursum);
        return;
    }
    if (curdis>minres[dest])
        return;
    for (int i=0; i<n; i++) {
        if(!visited[i]&&map[curpoint][i]!=INF)
        {
            visited[i] = true;
            dfs(source, dest, n, i, curdis+map[curpoint][i], cursum+weight[i], num, sum);
            visited[i] = false;
        }
    }
}

int main()
{
    int i,m,n,a,b,t,source,dest;
    while (cin>>n>>m) {
        cin>>source>>dest;
        for (i=0; i<n; i++) {
            cin>>weight[i]; //#peoples @ each point
        }
        init(n);
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&t);
            map[b][a] = map[a][b]= min(map[a][b],t);
        }
        dijkstra(source,dest,n);
        minres[source] = 0;
        int num = 0, sum = 0;
        memset(visited, false, sizeof(visited));
        visited[source] = true;
        dfs(source, dest, n, source, 0, weight[source], &num, &sum);
        cout<<num<<" "<<sum<<endl;
    }
}

 实现二

/*Dijkstra求单源最短路径 2010.8.26*/
 /*http://www.cnblogs.com/dolphin0520/archive/2011/08/26/2155202.html
 */
#include <iostream>
#include<stack>
#define M 100
#define N 100
using namespace std;

typedef struct node
{
    int matrix[N][M];      //邻接矩阵 
    int n;                 //顶点数 
    int e;                 //边数 
}MGraph; 

void DijkstraPath(MGraph g,int *dist,int *path,int v0)   //v0表示源顶点 
{
    int i,j,k;

    bool *visited=(bool *)malloc(sizeof(bool)*g.n);

    for(i=0;i<g.n;i++)     //初始化 
    {
        if(g.matrix[v0][i]>0&&i!=v0)
        {
            dist[i]=g.matrix[v0][i];
            path[i]=v0;     //path记录最短路径上从v0到i的前一个顶点 
        }
        else
        {
            dist[i]=INT_MAX;    //若i不与v0直接相邻，则权值置为无穷大 
            path[i]=-1;
        }
        visited[i]=false;
        path[v0]=v0;
        dist[v0]=0;
    }
    visited[v0]=true;
    for(i=1;i<g.n;i++)     //循环扩展n-1次 
    {
        int min=INT_MAX;
        int u;
        for(j=0;j<g.n;j++)    //寻找未被扩展的权值最小的顶点 
        {
            if(visited[j]==false&&dist[j]<min)
            {
                min=dist[j];
                u=j;        
            }
        } 
        visited[u]=true;
        for(k=0;k<g.n;k++)   //更新dist数组的值和路径的值 
        {
            if(visited[k]==false&&g.matrix[u][k]>0&&min+g.matrix[u][k]<dist[k])
            {
                dist[k]=min+g.matrix[u][k];
                path[k]=u; 
            }
        }        
    }    
}

void showPath(int *path,int v,int v0)   //打印最短路径上的各个顶点 
{
    stack<int> s;
    int u=v;
    while(v!=v0)
    {
        s.push(v);
        v=path[v];
    }
    s.push(v);
    while(!s.empty())
    {
        cout<<s.top()<<" ";
        s.pop();
    }
} 

int main(int argc, char *argv[])
{
    int n,e;     //表示输入的顶点数和边数 
    while(cin>>n>>e&&e!=0)
    {
        int i,j;
        int s,t,w;      //表示存在一条边s->t,权值为w
        MGraph g;
        int v0;
        int *dist=(int *)malloc(sizeof(int)*n);
        int *path=(int *)malloc(sizeof(int)*n);
        
        for(i=0;i<N;i++)
            for(j=0;j<M;j++)
                g.matrix[i][j]=0;
        g.n=n;
        g.e=e;
        for(i=0;i<e;i++)
        {
            cin>>s>>t>>w;
            g.matrix[s][t]=w;
        }
        cin>>v0;        //输入源顶点 
        DijkstraPath(g,dist,path,v0);
        for(i=0;i<n;i++)
        {
            if(i!=v0)
            {
                showPath(path,i,v0);
                cout<<dist[i]<<endl;
            }
        }
    }
    return 0;
}

 二、基于bitset排序

各种排序算法，生成随机文件程序。

    //purpose:  生成随机的不重复的测试数据  
    //copyright@ 2011.04.19 yansha  
    //1000w数据量，要保证生成不重复的数据量，一般的程序没有做到。  
    //但，本程序做到了。  
    //July、2010.05.30。  
    #include <iostream>  
    #include <time.h>  
    #include <assert.h>  
    using namespace std;  
      
    const int size = 10000000;  
    int num[size];  
      
    int main()  
    {  
        int n;  
        FILE *fp = fopen("data.txt", "w");  
        assert(fp);  
      
        for (n = 1; n <= size; n++)    
            //之前此处写成了n=0;n<size。导致下面有一段小程序的测试数据出现了0，特此订正。  
            num[n] = n;  
        srand((unsigned)time(NULL));  
        int i, j;  
      
        for (n = 0; n < size; n++)  
        {  
            i = (rand() * RAND_MAX + rand()) % 10000000;  
            j = (rand() * RAND_MAX + rand()) % 10000000;  
            swap(num[i], num[j]);  
        }  
      
        for (n = 0; n < size; n++)  
            fprintf(fp, "%d ", num[n]);  
        fclose(fp);  
        return 0;  
    }  
    

基于bitset实现方法

#include<iostream>
#include<bitset>
#include<assert.h>
#include<time.h>
using namespace std;

const int max_each_scan=5000000;

int main(){
	clock_t begin=clock();

	bitset<max_each_scan> bitmap;
	bitmap.reset();

	FILE* fp_unsort_file=fopen("data.txt","r");
	assert(fp_unsort_file);
	int num;

	while(fscanf(fp_unsort_file,"%d",&num)!=EOF){
		if(num<max_each_scan)
			bitmap.set(num,1);
	}

	FILE* fp_sort_file=fopen("sort.txt","w");
	assert(fp_sort_file);
	int i ;

	for(i=0;i<max_each_scan;i++){
		if(bitmap[i]==1)
			fprintf(fp_sort_file, "%d\n", i);
	}
	int result=fseek(fp_unsort_file,0,SEEK_SET);
	if(result)
		cout<<"failed"
	else{
		bitmap.reset();
		while(fscanf(fp_unsort_file,"%d",$num)!=EOF){
			if(num>max_each_scan&&num<10000000){
				num=num-max_ean_scan;
				bitmap.set(num,1);
			}
		}
		for(i=0;i<max_each_scan;i++){
			if(bitmap[i]==1){
				fprintf(fp_sort_file, "%d\n", max_each_scan+i);
			}
		}
	}

	clock_t end=clock();
	cout<<"排序用时："<<endl;  
	cout << (end - begin) / CLK_TCK << "s" << endl;  
    fclose(fp_sort_file);  
    fclose(fp_unsort_file);  
	return 0;  
}

 三、海量数据排序实例

    //copyright@ yansha  
    //July、updated，2011.05.28。  
    #include <iostream>  
    #include <string>  
    #include <algorithm>  
    #include <time.h>  
    using namespace std;  
      
    int sort_num = 10000000;  
    int memory_size = 250000;    
      
    //每次只对250k个小数据量进行排序  
    int read_data(FILE *fp, int *space)  
    {  
        int index = 0;  
        while (index < memory_size && fscanf(fp, "%d ", &space[index]) != EOF)  
            index++;  
        return index;  
    }  
      
    void write_data(FILE *fp, int *space, int num)  
    {  
        int index = 0;  
        while (index < num)  
        {  
            fprintf(fp, "%d ", space[index]);  
            index++;  
        }  
    }  
      
    // check the file pointer whether valid or not.  
    void check_fp(FILE *fp)  
    {  
        if (fp == NULL)  
        {  
            cout << "The file pointer is invalid!" << endl;  
            exit(1);  
        }  
    }  
      
    int compare(const void *first_num, const void *second_num)  
    {  
        return *(int *)first_num - *(int *)second_num;  
    }  
      
    string new_file_name(int n)  
    {  
        char file_name[20];  
        sprintf(file_name, "data%d.txt", n);  
        return file_name;  
    }  
      
    int memory_sort()  
    {  
        // open the target file.  
        FILE *fp_in_file = fopen("data.txt", "r");  
        check_fp(fp_in_file);  
        int counter = 0;  
        while (true)  
        {  
            // allocate space to store data read from file.  
            int *space = new int[memory_size];  
            int num = read_data(fp_in_file, space);  
            // the memory sort have finished if not numbers any more.  
            if (num == 0)  
                break;  
      
            // quick sort.  
            qsort(space, num, sizeof(int), compare);  
            // create a new auxiliary file name.  
            string file_name = new_file_name(++counter);  
            FILE *fp_aux_file = fopen(file_name.c_str(), "w");  
            check_fp(fp_aux_file);  
      
            // write the orderly numbers into auxiliary file.  
            write_data(fp_aux_file, space, num);  
            fclose(fp_aux_file);  
            delete []space;  
        }  
        fclose(fp_in_file);  
      
        // return the number of auxiliary files.  
        return counter;  
    }  
      
    void merge_sort(int file_num)  
    {  
        if (file_num <= 0)  
            return;  
        // create a new file to store result.  
        FILE *fp_out_file = fopen("result.txt", "w");  
        check_fp(fp_out_file);  
      
        // allocate a array to store the file pointer.  
        FILE **fp_array = new FILE *[file_num];  
        int i;  
        for (i = 0; i < file_num; i++)  
        {  
            string file_name = new_file_name(i + 1);  
            fp_array[i] = fopen(file_name.c_str(), "r");  
            check_fp(fp_array[i]);  
        }  
      
        int *first_data = new int[file_num];     
        //new出个大小为0.1亿/250k数组，由指针first_data指示数组首地址  
        bool *finish = new bool[file_num];  
        memset(finish, false, sizeof(bool) * file_num);  
      
        // read the first number of every auxiliary file.  
        for (i = 0; i < file_num; i++)  
            fscanf(fp_array[i], "%d ", &first_data[i]);  
        while (true)  
        {  
            int index = 0;  
            while (index < file_num && finish[index])  
                index++;  
      
            // the finish condition of the merge sort.  
            if (index >= file_num)  
                break;  
            //主要的修改在上面两行代码，就是merge sort结束条件。  
            //要保证所有文件都读完，必须使得finish[0]...finish[40]都为真  
            //July、yansha，555，2011.05.29。  
      
            int min_data = first_data[index];  
            // choose the relative minimum in the array of first_data.  
            for (i = index + 1; i < file_num; i++)  
            {  
                if (min_data > first_data[i] && !finish[i])     
                    //一旦发现比min_data更小的数据first_data[i]  
                {  
                    min_data = first_data[i];      
                    //则置min_data<-first_data[i]index = i;                     
                    //把下标i 赋给index。  
                }  
            }  
      
            // write the orderly result to file.  
            fprintf(fp_out_file, "%d ", min_data);  
            if (fscanf(fp_array[index], "%d ", &first_data[index]) == EOF)  
                finish[index] = true;  
        }  
      
        fclose(fp_out_file);  
        delete []finish;  
        delete []first_data;  
        for (i = 0; i < file_num; i++)  
            fclose(fp_array[i]);  
        delete [] fp_array;  
    }  
      
    int main()  
    {  
        clock_t start_memory_sort = clock();  
        int aux_file_num = memory_sort();  
        clock_t end_memory_sort = clock();  
        cout << "The time needs in memory sort: " << end_memory_sort - start_memory_sort << endl;  
        clock_t start_merge_sort = clock();  
        merge_sort(aux_file_num);  
        clock_t end_merge_sort = clock();  
        cout << "The time needs in merge sort: " << end_merge_sort - start_merge_sort << endl;  
        system("pause");  
        return 0;  
    }  

 
四、多路归并排序

//copyright@ 纯净的天空 && yansha  
 //5、July，updated，2010.05.28。 
//harryshayne，update again。2011.6.30 
#include <iostream>  
#include <ctime>  
#include <fstream>  
//#include "ExternSort.h"  
using namespace std;  
  
//使用多路归并进行外排序的类  
//ExternSort.h  
  
/* 
* 大数据量的排序 
* 多路归并排序 
* 以千万级整数从小到大排序为例 
* 一个比较简单的例子，没有建立内存缓冲区 
*/  
  
#ifndef EXTERN_SORT_H  
#define EXTERN_SORT_H  
  
#include <cassert>  
//#define k 5  
#define MIN -1//这里开始的时候出现了一个BUG，如果定义的MIN大于等于待排序的数，则会是算法出现错误
#define MAX 10000000//最大值，附加在归并文件结尾
typedef int* LoserTree;
typedef int* External;

class ExternSort  
{  
public:  
    void sort()  
    {  
        time_t start = time(NULL);  
          
        //将文件内容分块在内存中排序，并分别写入临时文件  
        k = memory_sort();  //
          
        //归并临时文件内容到输出文件  
        //merge_sort(file_count); 
        ls=new int[k];
        b=new int[k+1];
        
        K_Merge();
        delete []ls;
        delete []b;
          
        time_t end = time(NULL);  
        printf("total time:%f\n", (end - start) * 1000.0/ CLOCKS_PER_SEC);  
    }  
      
    //input_file:输入文件名  
    //out_file:输出文件名  
    //count: 每次在内存中排序的整数个数  
    ExternSort(const char *input_file, const char * out_file, int count)  
    {  
        m_count = count;  
        m_in_file = new char[strlen(input_file) + 1];  
        strcpy(m_in_file, input_file);  
        m_out_file = new char[strlen(out_file) + 1];  
        strcpy(m_out_file, out_file);  
    }  
    virtual ~ExternSort()  
    {  
        delete [] m_in_file;  
        delete [] m_out_file;  
    }  
      
private:  
    int m_count; //数组长度  
    char *m_in_file;   //输入文件的路径  
    char *m_out_file; //输出文件的路径  
   
    int k;//归并数，此数必须要内排序之后才能得到，所以下面的ls和b都只能定义为指针(注意和书上区别)

    LoserTree ls;//定义成为指针，之后动态生成数组
    External b;//定义成为指针，在成员函数中可以把它当成数组使用
    //int External[k];
protected:  
    int read_data(FILE* f, int a[], int n)  
    {  
        int i = 0;  
        while(i < n && (fscanf(f, "%d", &a[i]) != EOF)) i++;  
        printf("read:%d integer\n", i);  
        return i;  
    }  
    void write_data(FILE* f, int a[], int n)  
    {  
        for(int i = 0; i < n; ++i)  
            fprintf(f, "%d ", a[i]);  
        fprintf(f,"%d",MAX);//在最后写上一个最大值
    }  
    char* temp_filename(int index)  
    {  
        char *tempfile = new char[100];  
        sprintf(tempfile, "temp%d.txt", index);  
        return tempfile;  
    }  
    static int cmp_int(const void *a, const void *b)  
    {  
        return *(int*)a - *(int*)b;  
    }  
      
    int memory_sort()  
    {  
        FILE* fin = fopen(m_in_file, "rt");  
        int n = 0, file_count = 0;  
        int *array = new int[m_count];  
          
        //每读入m_count个整数就在内存中做一次排序，并写入临时文件  
        while(( n = read_data(fin, array, m_count)) > 0)  
        {  
            qsort(array, n, sizeof(int), cmp_int);     
            //这里，调用了库函数阿，在第四节的c实现里，不再调用qsort。  
            char *fileName = temp_filename(file_count++);  
            FILE *tempFile = fopen(fileName, "w");  
            free(fileName);  
            write_data(tempFile, array, n);  
            fclose(tempFile);  
        }  
          
        delete [] array;  
        fclose(fin);  
          
        return file_count;  
    }  

    void Adjust(int s)
    {//沿从叶子节点b[s]到根节点ls[0]的路径调整败者树
        int t=(s+k)/2;//ls[t]是b[s]的双亲节点

        while(t>0)
        {
            if(b[s]>b[ls[t]])//如果失败，则失败者位置s留下，s指向新的胜利者
            {
                int tmp=s;
                s=ls[t];
                ls[t]=tmp;
            }
            t=t/2;
        }
        ls[0]=s;//ls[0]存放调整后的最大值的位置
    }

    void CreateLoserTree()
    {
        b[k]=MIN;//额外的存储一个最小值
        for(int i=0;i<k;i++)ls[i]=k;//先初始化为指向最小值，这样后面的调整才是正确的
                                    //这样能保证非叶子节点都是子树中的“二把手”
        for(i=k-1;i>=0;i--)
            Adjust(i);//依次从b[k-1],b[k-2]...b[0]出发调整败者树
    }

    void K_Merge()
    {//利用败者数把k个输入归并段归并到输出段中
        //b中前k个变量存放k个输入段中当前记录的元素
        //归并临时文件  
        FILE *fout = fopen(m_out_file, "wt");  
        FILE* *farray = new FILE*[k];  
        int i;  
        for(i = 0; i < k; ++i)  //打开所有k路输入文件
        {  
            char* fileName = temp_filename(i);  
            farray[i] = fopen(fileName, "rt");  
            free(fileName);  
        }  
          
        for(i = 0; i < k; ++i)  //初始读取
        {  
            if(fscanf(farray[i], "%d", &b[i]) == EOF)//读每个文件的第一个数到data数组  
            {
                printf("there is no %d file to merge!"，k);
                return;
            }
        }  
    //    for(int i=0;i<k;i++)input(b[i]);

        CreateLoserTree();
        int q;
        while(b[ls[0]]!=MAX)//
        {
            q=ls[0];//q用来存储b中最小值的位置，同时也对应一路文件
            //output(q);
            fprintf(fout,"%d ",b[q]);
            //input(b[q],q);
            fscanf(farray[q],"%d",&b[q]);
            Adjust(q);
        }
        //output(ls[0]);
        fprintf(fout,"%d ",b[ls[0]]);
        //delete [] hasNext;  
        //delete [] data;  
          
        for(i = 0; i < k; ++i)  //清理工作
        {  
            fclose(farray[i]);  
        }  
        delete [] farray;  
        fclose(fout);  
    }
    /*
    void merge_sort(int file_count)  
    {  
        if(file_count <= 0) return;  
          
        //归并临时文件  
        FILE *fout = fopen(m_out_file, "wt");  
        FILE* *farray = new FILE*[file_count];  
        int i;  
        for(i = 0; i < file_count; ++i)  
        {  
            char* fileName = temp_filename(i);  
            farray[i] = fopen(fileName, "rt");  
            free(fileName);  
        }  
          
        int *data = new int[file_count];//存储每个文件当前的一个数字  
        bool *hasNext = new bool[file_count];//标记文件是否读完  
        memset(data, 0, sizeof(int) * file_count);  
        memset(hasNext, 1, sizeof(bool) * file_count);  
          
        for(i = 0; i < file_count; ++i)  //初始读取
        {  
            if(fscanf(farray[i], "%d", &data[i]) == EOF)//读每个文件的第一个数到data数组  
                hasNext[i] = false;  
        }  
          
        while(true)  //循环读取和输出，选择最小数的方法是简单遍历选择法
        {  
            //求data中可用的最小的数字，并记录对应文件的索引  
            int min = data[0];  
            int j = 0;  
              
            while (j < file_count && !hasNext[j])  //顺序跳过已读取完毕的文件
                j++;  
              
            if (j >= file_count)  //没有可取的数字，终止归并  
                break;  
              
              
            for(i = j +1; i < file_count; ++i)  //选择最小数，这里应该是i=j吧！但结果是一样的！
            {  
                if(hasNext[i] && min > data[i])  
                {  
                    min = data[i];  
                    j = i;  
                }  
            }  
              
            if(fscanf(farray[j], "%d", &data[j]) == EOF) //读取文件的下一个元素  
                hasNext[j] = false;  
            fprintf(fout, "%d ", min);  
              
        }  
          
        delete [] hasNext;  
        delete [] data;  
          
        for(i = 0; i < file_count; ++i)  
        {  
            fclose(farray[i]);  
        }  
        delete [] farray;  
        fclose(fout);  
    }  
    */
};  
  
#endif  
  
  
//测试主函数文件  
/* 
* 大文件排序 
* 数据不能一次性全部装入内存 
* 排序文件里有多个整数，整数之间用空格隔开 
*/  
  
const unsigned int count = 10000000; // 文件里数据的行数  
const unsigned int number_to_sort = 100000; //在内存中一次排序的数量  
const char *unsort_file = "unsort_data.txt"; //原始未排序的文件名  
const char *sort_file = "sort_data.txt"; //已排序的文件名  
void init_data(unsigned int num); //随机生成数据文件  
  
int main(int argc, char* *argv)  
{  
    srand(time(NULL));  
    init_data(count);  
    ExternSort extSort(unsort_file, sort_file, number_to_sort);  
    extSort.sort();  
    system("pause");  
    return 0;  
}  
  
void init_data(unsigned int num)  
{  
    FILE* f = fopen(unsort_file, "wt");  
    for(int i = 0; i < num; ++i)  
        fprintf(f, "%d ", rand());  
    fclose(f);  
}

 五、字符串回文结构判断

class Solution{
	//http://blog.csdn.net/v_july_v/article/details/6712171
public:
	    /**  
     *check weather s is a palindrome, n is the length of string s 
     *Copyright(C) fairywell 2011 
     */  
    bool IsPalindrome(const char *s, int n)  
    {  
       if (s == 0 || n < 1) return false; // invalid string  
       char *front, *back;  
       front = s; back = s + n - 1; // set front and back to the begin and endof the string  
       while (front < back) {  
           if (*front != *back) return false; // not a palindrome  
           ++front; --back;  
        }  
       return true; // check over, it's a palindrome  
      
    }  

        /**  
     *check weather s is a palindrome, n is the length of string s 
     *Copyright(C) fairywell 2011 
     */  
    bool IsPalindrome2(const char *s, int n)  
    {  
       if (s == 0 || n < 1) return false; // invalid string  
       char *first, *second;  
       int m = ((n>>1) - 1) >= 0 ? (n>>1) - 1 : 0; // m is themiddle point of s      
       first = s + m; second = s + n - 1 - m;  
       while (first >= s)  
               if (s[first--] !=s[second++]) return false; // not equal, so it's not apalindrome  
       return true; // check over, it's a palindrome  
    }  
        /**  
     *find the longest palindrome in a string, n is the length of string s 
     *Copyright(C) fairywell 2011 
     */  
    int LongestPalindrome(const char *s, int n)  
    {  
       int i, j, max;  
       if (s == 0 || n < 1) return 0;  
       max = 0;  

       for (i = 0; i < n; ++i) { // i is the middle point of the palindrome  
           for (j = 0; (i-j >= 0) && (i+j < n); ++j) // if the lengthof the palindrome is odd  
               if (s[i-j] != s[i+j]) break;  
       
           if (j*2+1 > max) max = j * 2 + 1;  
       
           for (j = 0; (i-j >= 0) && (i+j+1 < n); ++j) // for theeven case  
               if (s[i-j] != s[i+j+1]) break;  

           if (j*2+2 > max) max = j * 2 + 2;  
        }  
       return max;  
    }  

        int LongestPalindrome(const char *s, int n)  
    {  
        int max = 0;  
        int i,j;  
        for (  i = 0; i < n  ; i++ )  
        {//以i为中心开始计算回文子串  
            //计算奇数回问子串长度  
            for (  j = 0; (i-j) >= 0 && (i+j) < n; j++ )  
            {  
                if ( s[i-j] != s[i+j] )  
                {  
                    break;  
                }  
                else  
                {  
                    max = GETMAX(max, (2 * j  + 1));  
                }  
            }  
              
            //计算偶数回问子串长度  
            for ( j = 0; (i-j) >= 0 && i + j + 1< n; j++ )  
            {  
                if ( s[i-j] != s[i+j+1])  
                {  
                    break;  
                }  
                else  
                {  
                    max = GETMAX(max, ( 2 * j  + 2) );  
                }  
            }  
        }  
      
        return max;  
    }  
}