2亿个浮点数中求最大的100万之和

2亿个浮点数中求最大的100万之和

题目：有一个文件中保存了2亿个浮点数，每个浮点数都以'/n'分隔。求最大的100万个浮点数之和。

算法：

1. 首先建立一个容量为100万(nTop)的float数组，从文件读取浮点数填充。

2. 利用堆排序对该100万条记录排序(确保第一个元素为最小值)

3. 从文件中读取一个浮点数与第一个元素比较，如果大于第一个元素则替换该元素，并调整堆的结构。

4. 重复步骤3一直到数据读取完

5. 将数组中的元素全部相加，得到结果

源代码:

1. //CTopSum.h
2. #pragma once
3. #include <windows.h>
5. class CTopSum
6. {
7. public:
8.     CTopSum();
9.     ~CTopSum(void);
11. public:
12.     static void HeapAdjust(float* pnData, int nStart, int nLen);
13.     static void HeapSort(float* pnData, int nLen);
15. public:
16.     float GetTopSum(LPCTSTR lpszFile, int& nTop);
18. private:
19.     void Clear();
20.     static void HeapAdjustLit(float* pnData, int nStart, int nLen);
21. private:
22.     float*  m_pfData;
23. };
25. //CTopSum.cpp
26. #include "StdAfx.h"
27. #include "topsum.h"
28. #include <iostream>
30. using namespace std;
32. CTopSum::CTopSum()
33. {
34.     m_pfData = NULL;
35. }
37. CTopSum::~CTopSum(void)
38. {
39.     Clear();
40. }
42. void CTopSum::Clear()
43. {
44.     if (NULL != m_pfData)
45.     {
46.         delete[] m_pfData;
47.         m_pfData = NULL;
48.     }
49. }
51. //获取前top位的总和
52. float CTopSum::GetTopSum(LPCTSTR lpszFile, int& nTop)
53. {
54.     FILE*   fp      = NULL;
55.     float   fData   = 0.0f;
56.     float   fSum    = 0.0f;
57.     int     i       = 0;
59.     //判断输入参数
60.     if ( (NULL == lpszFile) || (nTop <= 0) )
61.     {
62.         cout << "error parameter" << endl;
63.         return 0.0f;
64.     }
65.     
66.     //清除操作
67.     Clear();
69.     //打开文件
70.     fp = ::fopen(lpszFile, "r");
72.     if (NULL == fp)
73.     {
74.         cout << "open file failed!" << endl;
75.         return 0.0f;
76.     }
78.     //分配空间
79.     m_pfData = new float[nTop];
81.     if (NULL == m_pfData)
82.     {
83.         cout << "new operator failed!" << endl;
84.         return 0.0f;
85.     }
87.     cout << "please wait..." << endl;
89.     //读取前nTop个数据
90.     for (i = 0; i < nTop; i++)
91.     {
92.         if (EOF != ::fscanf(fp, "%f/n", &fData))
93.         {
94.             m_pfData[i] = fData;
95.         }
96.         else
97.         {
98.             break;
99.         }
100.     }
102.     //最大的个数小于nTop,求前i个数据
103.     if (i < nTop)
104.     {
105.         nTop = i;       
106.     }
107.     else
108.     {       
109.         CTopSum::HeapSort(m_pfData, nTop);//排序
111.         while (EOF != ::fscanf(fp, "%f/n", &fData))
112.         {
113.             if (fData > m_pfData[0])
114.             {
115.                 //交换并调整堆
116.                 m_pfData[0] = fData;
117.                 CTopSum::HeapAdjustLit(m_pfData, 0, nTop);
118.             }
119.         }
120.     }
122.     fSum = 0;
123.     for (i = 0; i < nTop; i++)
124.     {
125.         fSum += m_pfData[i];
126.     }
128.     return fSum;
129. }
131. //调整大根堆
132. void CTopSum::HeapAdjust(float* pnData, int nStart, int nLen)
133. {
134.     int nMaxChild = 0;
135.     float fTemp = 0;
137.     while ( ( 2 * nStart + 1) < nLen)
138.     {
139.         nMaxChild = 2 * nStart + 1;
140.         if ( (2 * nStart + 2) < nLen)
141.         {
142.             //比较左子树和右子树,记录最大值的Index
143.             if (pnData[2 * nStart + 1] < pnData[2 * nStart + 2])
144.             {
145.                 nMaxChild = 2 * nStart + 2;
146.             }
147.         }
149.         //change data
150.         if (pnData[nStart] < pnData[nMaxChild])
151.         {
152.             //交换nStart与nMaxChild的数据
153.             fTemp = pnData[nStart];
154.             pnData[nStart] = pnData[nMaxChild];
155.             pnData[nMaxChild] = fTemp;
157.             //堆被破坏,需要重新调整
158.             nStart = nMaxChild;
159.         }
160.         else
161.         {
162.             //比较左右孩子均大则堆未破坏,不再需要调整
163.             break;
164.         }
165.     }
166. }
168. //堆排序
169. void CTopSum::HeapSort(float* pnData, int nLen)
170. {
171.     int i = 0;
172.     float nTemp = 0;
174.     //将pnData[0, Len-1]建成大根堆
175.     for (i = nLen / 2  - 1; i >= 0; i--)
176.     {
177.         CTopSum::HeapAdjust(pnData, i, nLen);
178.     }
180.     for (i = nLen - 1; i > 0; i--)
181.     {
182.         nTemp = pnData[0];
183.         pnData[0] = pnData[i];
184.         pnData[i] = nTemp;
186.         //将pnData[0...i]重写建成大根堆
187.         CTopSum::HeapAdjust(pnData, 0, i);
188.     }
189. }
191. void CTopSum::HeapAdjustLit(float* pnData, int nStart, int nLen)
192. {
193.     int nMinChild = 0;
194.     float fTemp = 0;
196.     while ( ( 2 * nStart + 1) < nLen)
197.     {
198.         nMinChild = 2 * nStart + 1;
199.         if ( (2 * nStart + 2) < nLen)
200.         {
201.             //比较左子树和右子树,记录最大值的Index
202.             if (pnData[2 * nStart + 2] < pnData[2 * nStart + 1])
203.             {
204.                 nMinChild = 2 * nStart + 2;
205.             }
206.         }
208.         //change data
209.         if (pnData[nStart] > pnData[nMinChild])
210.         {
211.             //交换nStart与nMaxChild的数据
212.             fTemp = pnData[nStart];
213.             pnData[nStart] = pnData[nMinChild];
214.             pnData[nMinChild] = fTemp;
216.             //堆被破坏,需要重新调整
217.             nStart = nMinChild;
218.         }
219.         else
220.         {
221.             //比较左右孩子均大则堆未破坏,不再需要调整
222.             break;
223.         }
224.     }
225. }
227. //main.cpp
228. #include "stdafx.h"
229. #include "topsum.h"
230. #include <iostream>
232. using namespace std;
234. int _tmain(int argc, _TCHAR* argv[])
235. {
236.     TCHAR   szFile[MAX_PATH] = {0};
237.     int     nNum = 0;
238.     CTopSum objTopSum;
240.     cout << "please input count file name:" << endl;
241.     cin >> szFile;
243.     cout << "please input top num:"<< endl;
244.     cin >> nNum;
246.     cout << "top " << nNum << " value = " << objTopSum.GetTopSum(szFile, nNum) << endl;
248.     ::system("pause");
250.     return 0;
251. }