static void Main(string[] args)
{
    //1、获取文档输入
    string[] docs = getInputDocs("input.txt");
    if (docs.Length < 1)
    {
        Console.WriteLine("没有文档输入");
        Console.Read();
        return;
    }

    //2、初始化TFIDF测量器，用来生产每个文档的TFIDF权重
    TFIDFMeasure tf = new TFIDFMeasure(docs, new Tokeniser());

    int K = 3; //聚成3个聚类

    //3、生成k-means的输入数据，是一个联合数组，第一维表示文档个数，
    //第二维表示所有文档分出来的所有词
    double[][] data = new double[docs.Length][];
    int docCount = docs.Length; //文档个数
    int dimension = tf.NumTerms;//所有词的数目
    for (int i = 0; i < docCount; i++)
    {
        for (int j = 0; j < dimension; j++)
        {
            data[i] = tf.GetTermVector2(i); //获取第i个文档的TFIDF权重向量
        }
    }

    //4、初始化k-means算法，第一个参数表示输入数据，第二个参数表示要聚成几个类
    WawaKMeans kmeans = new WawaKMeans(data, K);
    //5、开始迭代
    kmeans.Start();

    //6、获取聚类结果并输出
    WawaCluster[] clusters = kmeans.Clusters;
    foreach (WawaCluster cluster in clusters)
    {
        List<int> members = cluster.CurrentMembership;
        Console.WriteLine("-----------------");
        foreach (int i in members)
        {
            Console.WriteLine(docs[i]);
        }

    }
    Console.Read();
}

/**//// <summary>
/// 以空白字符进行简单分词，并忽略大小写，
/// 实际情况中可以用其它中文分词算法
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public IList<string> Partition(string input)
{
 Regex r=new Regex("([ //t{}():;. /n])");  
 input=input.ToLower() ;

 String [] tokens=r.Split(input);          

 List<string> filter=new  List<string>() ;

 for (int i=0; i < tokens.Length ; i++)
 {
  MatchCollection mc=r.Matches(tokens[i]);
  if (mc.Count <= 0 && tokens[i].Trim().Length > 0       
   && !StopWordsHandler.IsStopword (tokens[i]) )        
   filter.Add(tokens[i]) ;
        }
 
 return filter.ToArray();
}

public class WawaKMeans
{
    /**//// <summary>
    /// 数据的数量
    /// </summary>
    readonly int _coordCount;
    /**//// <summary>
    /// 原始数据
    /// </summary>
    readonly double[][] _coordinates;
    /**//// <summary>
    /// 聚类的数量
    /// </summary>
    readonly int _k;
    /**//// <summary>
    /// 聚类
    /// </summary>
    private readonly WawaCluster[] _clusters;

    internal WawaCluster[] Clusters
    {
        get { return _clusters; }
    } 

    /**//// <summary>
    /// 定义一个变量用于记录和跟踪每个资料点属于哪个群聚类
    /// _clusterAssignments[j]=i;// 表示第 j 个资料点对象属于第 i 个群聚类
    /// </summary>
    readonly int[] _clusterAssignments;
    /**//// <summary>
    /// 定义一个变量用于记录和跟踪每个资料点离聚类最近
    /// </summary>
    private readonly int[] _nearestCluster;
    /**//// <summary>
    /// 定义一个变量，来表示资料点到中心点的距离,
    /// 其中—_distanceCache[i][j]表示第i个资料点到第j个群聚对象中心点的距离；
    /// </summary>
    private readonly double[,] _distanceCache;
    /**//// <summary>
    /// 用来初始化的随机种子
    /// </summary>
    private static readonly Random _rnd = new Random(1);

    public WawaKMeans(double[][] data, int K)
    {
        _coordinates = data;
        _coordCount = data.Length;
        _k = K;
        _clusters = new WawaCluster[K];
        _clusterAssignments = new int[_coordCount];
        _nearestCluster = new int[_coordCount];
        _distanceCache = new double[_coordCount,data.Length];
        InitRandom();
    }

    public void Start()
    {
        int iter = 0;
        while (true)
        {
            Console.WriteLine("Iteration " + (iter++) + "");
            //1、重新计算每个聚类的均值
            for (int i = 0; i < _k; i++)
            {
                _clusters[i].UpdateMean(_coordinates);
            }

            //2、计算每个数据和每个聚类中心的距离
            for (int i = 0; i < _coordCount; i++)
            {
                for (int j = 0; j < _k; j++)
                {
                    double dist = getDistance(_coordinates[i], _clusters[j].Mean);
                    _distanceCache[i,j] = dist;
                }
            }

            //3、计算每个数据离哪个聚类最近
            for (int i = 0; i < _coordCount; i++)
            {
                _nearestCluster[i] = nearestCluster(i);
            }

            //4、比较每个数据最近的聚类是否就是它所属的聚类
            //如果全相等表示所有的点已经是最佳距离了，直接返回；
            int k = 0;
            for (int i = 0; i < _coordCount; i++)
            {
                if (_nearestCluster[i] == _clusterAssignments[i])
                    k++;

            }
            if (k == _coordCount)
                break;

            //5、否则需要重新调整资料点和群聚类的关系，调整完毕后再重新开始循环；
            //需要修改每个聚类的成员和表示某个数据属于哪个聚类的变量
            for (int j = 0; j < _k; j++)
            {
                _clusters[j].CurrentMembership.Clear();
            }
            for (int i = 0; i < _coordCount; i++)
            {
                _clusters[_nearestCluster[i]].CurrentMembership.Add(i);
                _clusterAssignments[i] = _nearestCluster[i];
            }
            
        }

    }

    /**//// <summary>
    /// 计算某个数据离哪个聚类最近
    /// </summary>
    /// <param name="ndx"></param>
    /// <returns></returns>
    int nearestCluster(int ndx)
    {
        int nearest = -1;
        double min = Double.MaxValue;
        for (int c = 0; c < _k; c++)
        {
            double d = _distanceCache[ndx,c];
            if (d < min)
            {
                min = d;
                nearest = c;
            }
      
        }
        if(nearest==-1)
        {
            ;
        }
        return nearest;
    }
    /**//// <summary>
    /// 计算某数据离某聚类中心的距离
    /// </summary>
    /// <param name="coord"></param>
    /// <param name="center"></param>
    /// <returns></returns>
    static double getDistance(double[] coord, double[] center)
    {
        //int len = coord.Length;
        //double sumSquared = 0.0;
        //for (int i = 0; i < len; i++)
        //{
        //    double v = coord[i] - center[i];
        //    sumSquared += v * v; //平方差
        //}
        //return Math.Sqrt(sumSquared);

        //也可以用余弦夹角来计算某数据离某聚类中心的距离
        return 1- TermVector.ComputeCosineSimilarity(coord, center);

    } 
    /**//// <summary>
    /// 随机初始化k个聚类
    /// </summary>
    private void InitRandom()
    {
        for (int i = 0; i < _k; i++)
        {
            int temp = _rnd.Next(_coordCount);
            _clusterAssignments[temp] = i; //记录第temp个资料属于第i个聚类
            _clusters[i] = new WawaCluster(temp,_coordinates[temp]);
        }
    }
}

internal class WawaCluster
{
    public WawaCluster(int dataindex,double[] data)
    {
        CurrentMembership.Add(dataindex);
        Mean = data;
    }

    /**//// <summary>
    /// 该聚类的数据成员索引
    /// </summary>
    internal List<int> CurrentMembership = new List<int>();
    /**//// <summary>
    /// 该聚类的中心
    /// </summary>
    internal double[] Mean;
    /**//// <summary>
    /// 该方法计算聚类对象的均值 
    /// </summary>
    /// <param name="coordinates"></param>
    public void UpdateMean(double[][] coordinates)
    {
        // 根据 mCurrentMembership 取得原始资料点对象 coord ，该对象是 coordinates 的一个子集；
        //然后取出该子集的均值；取均值的算法很简单，可以把 coordinates 想象成一个 m*n 的距阵 ,
        //每个均值就是每个纵向列的取和平均值 , //该值保存在 mCenter 中

        for (int i = 0; i < CurrentMembership.Count; i++)
        {
            double[] coord = coordinates[CurrentMembership[i]];
            for (int j = 0; j < coord.Length; j++)
            {
                Mean[j] += coord[j]; // 得到每个纵向列的和；
            }
            for (int k = 0; k < Mean.Length; k++)
            {
                Mean[k] /= coord.Length; // 对每个纵向列取平均值
            }
        }
    }
}