k-中心点法的聚类数据挖掘算法的C#实现

totoo130

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Text;
   
4. using System.Collections;
   
5. using System.Data.Odbc;
   
6. 
   
7. class ClusterGenerator : IDataWorker
   
8. {
   
9. 
   
10. 
    
11. 
    
12.     #region IDataWorker Members
    
13.     public void work()
    
14.     {
    
15.         throw new Exception("The method or operation is not implemented.");
    
16.     }
    
17.     #endregion
    
18. 
    
19.     private int k = 10;
    
20.     public int K
    
21.     {
    
22.         get { return k; }
    
23.         set { k = value; }
    
24.     }
    
25.     private ArrayList centerList = new ArrayList();
    
26. 
    
27.     private ArrayList pointClusterList = new ArrayList();
    
28. 
    
29.     private ArrayList cluster = new ArrayList();
    
30.     private bool isChanged = false;
    
31.     private int minCenter = 0;
    
32.     private double minPower = 0;
    
33.     private double tempPower = 1;
    
34.     private double sumPower = 0;
    
35.     private double randPower = 0;
    
36.     private int oRandom = 0;
    
37. 
    
38.     private void genCluster(ArrayList alldata)
    
39.     {
    
40.         centerList.Clear();
    
41.         //初始化clusterList
    
42.         Random random = new Random();
    
43.         for (int i = 0; i < k; i++)
    
44.         {
    
45.             centerList.Add(random.Next(alldata.Count));
    
46.             pointClusterList.Add(new ArrayList());
    
47.         }
    
48.         do
    
49.         {
    
50.             isChanged = false;
    
51.             /////////////////////////////指派每个剩余的对象给离它最近的中心点所代表的簇
    
52.             for (int i = 0; i < alldata.Count; i++)
    
53.             {
    
54.                 for (int j = 0; j < centerList.Count; j++)
    
55.                 {
    
56.                     tempPower = PowerUtil.countPower(alldata[i], alldata[(int)centerList[j]]);
    
57.                     if (tempPower < minPower)
    
58.                     {
    
59.                         minCenter = j;
    
60.                         minPower = tempPower;
    
61.                     }
    
62.                 }
    
63.                 cluster = (ArrayList)(pointClusterList[minCenter]);
    
64.                 cluster.Add(i);
    
65. 
    
66.             }
    
67.             ///////////////////////////////////////////////////
    
68.             ////////////////////针对每个簇提出一个随机的非中心点对象
    
69.             //for (int i = 0; i < pointClusterList; i++) {
    
70.             //    cluster = (ArrayList)pointClusterList[i];
    
71.             //    oRandom = random.Next(alldata.Count);
    
72.             //    for (int j = 0; j < cluster; j++) {
    
73. 
    
74.             //        sumPower += PowerUtil.countPower(alldata((int)(cluster[j])), alldata[(int)centerList[i]]);
    
75.             //        randPower += PowerUtil.countPower(alldata((int)(cluster[j])), alldata(oRandom));
    
76.             //    }
    
77.             //    if (randPower < sumPower)
    
78.             //    {
    
79.             //        centerList[i] = oRandom;
    
80.             //        isChanged = true;
    
81.             //    }
    
82. 
    
83.             //}
    
84.             /////////////////////////
    
85.             for (int i = 0; i < pointClusterList; i++)
    
86.             {
    
87. 
    
88.                 oRandom = random.Next(alldata.Count);
    
89.                 if (PowerUtil.countEM(alldata, centerList, pointClusterList, oRandom, i))
    
90.                 {
    
91.                     centerList[i] = oRandom;
    
92.                     isChanged = true;
    
93.                     break;//?
    
94.                 }
    
95. 
    
96.             }
    
97. 
    
98.             ///////////////////////////
    
99. 
    
100. 
     
101. 
     
102. 
     
103.             /////////////////////////////////
     
104. 
     
105.         } while (!isChanged);
     
106. 
     
107.     }
     
108. }
     
109. using System;
     
110. using System.Collections.Generic;
     
111. using System.Text;
     
112. using System.Collections;
     
113. 
     
114.     class PowerUtil
     
115.     {
     
116.         public static double countPower(ArrayList a,ArrayList b) {
     
117.             
     
118. 
     
119. 
     
120.             double powerA=1.0;
     
121.             double powerB=1.0;
     
122.             double power=0;
     
123.             int lengthA = a.Count;
     
124.             int lengthB = b.Count;
     
125. 
     
126. 
     
127.              for(int i=0;i<a.Count;i++){
     
128.                for(int j=0;j<b.Count;j++){
     
129.                    if (((string)a[i]).Equals((string)b[i]) && !((string)a[i]).Equals(""))
     
130.                    {
     
131.                        powerA = powerA - 1 / lengthA;
     
132.                    }
     
133.                    else {
     
134.                    if(((string)a[i]).Equals("")){
     
135.                        lengthA--;
     
136.                   
     
137.                    }
     
138.                    }
     
139.                
     
140.                }
     
141.             
     
142.             }
     
143.              for(int i=0;i<b.Count;i++){
     
144.                for(int j=0;j<a.Count;j++){
     
145.                    if (((string)b[i]).Equals((string)a[i]) && !((string)a[i]).Equals(""))
     
146.                    {
     
147.                        powerB = powerB - 1 / lengthB;
     
148.                    }
     
149.                    else {
     
150.                        if (((string)b[i]).Equals(""))
     
151.                        {
     
152.                            lengthB--;
     
153.                        }
     
154.                   
     
155.                   
     
156.                    }
     
157.                
     
158.                }
     
159.             
     
160.             }
     
161.             return (powerA + powerB) / 2;
     
162.         
     
163.         }
     
164.         public static bool countEM(ArrayList alldata, ArrayList centerList, ArrayList pointClusterList,int oRandom,int position)
     
165.         {
     
166.               
     
167.       int minCenter = 0;
     
168.       double minPower = 0;
     
169.       double tempPower = 1;
     
170.       double sumPower = 0;
     
171.       double randPower = 0;
     
172.         ArrayList cluster = new ArrayList();
     
173.    
     
174.             ArrayList newCenterList = centerList.Clone();
     
175.             newCenterList[position] = oRandom;
     
176.             ArrayList newPointClusterList = new ArrayList();
     
177.             for (int i = 0; i < pointClusterList.Count; i++)
     
178.             {
     
179.                 newPointClusterList.Add(new ArrayList());
     
180.             }
     
181.             for (int i = 0; i < alldata.Count; i++)
     
182.             {
     
183.                 for (int j = 0; j < centerList.Count; j++)
     
184.                 {
     
185.                     tempPower = PowerUtil.countPower(alldata[i], alldata[(int)newCenterList[j]]);
     
186.                     if (tempPower < minPower)
     
187.                     {
     
188.                         minCenter = j;
     
189.                         minPower = tempPower;
     
190.                     }
     
191.                 }
     
192.                 cluster = (ArrayList)(newPointClusterList[minCenter]);
     
193.                 cluster.Add(i);
     
194. 
     
195.             }
     
196. 
     
197. 
     
198.             //////////////////////////////
     
199.             //开始算EM
     
200.             for (int i = 0; i < pointClusterList; i++)
     
201.             {
     
202.                 cluster = (ArrayList)pointClusterList[i];
     
203.               
     
204.                 for (int j = 0; j < cluster; j++)
     
205.                 {
     
206. 
     
207.                     sumPower += PowerUtil.countPower(alldata((int)(cluster[j])), alldata[(int)centerList[i]]);
     
208.                   
     
209.                 }
     
210.             
     
211. 
     
212.             }
     
213.             for (int i = 0; i < pointClusterList; i++)
     
214.             {
     
215.                 cluster = (ArrayList)newPointClusterList[i];
     
216. 
     
217.                 for (int j = 0; j < cluster; j++)
     
218.                 {
     
219. 
     
220.                     randPower += PowerUtil.countPower(alldata((int)(cluster[j])), alldata[(int)newCenterList[i]]);
     
221. 
     
222.                 }
     
223. 
     
224. 
     
225.             }
     
226.             double s=randPower-sumPower;
     
227.             if (s < 0)
     
228.             {
     
229.                 return true;
     
230.             }
     
231.             else
     
232.             {
     
233.                 return false;
     
234.             }
     
235. 
     
236.         
     
237.         }
     
238.     }
     

复制代码