数据分析对电脑内存要求

一.题目及内容

大数据分析问题

[问题描述]

某搜索公司一天的用户搜索词汇是海量的（百亿数据量），请设计一种求出每天最热top 100 词汇的可行办法。

[基本要求]

（1） 随机生成海量数据，存入文件；从文件读入数据来处理。
（2） 显示数据文件的每一次处理结果。

二.思路过程

（1）生成随机大数据，并且要求大数据存在交集数据，以此保证有热词存在。

（2）顺序读大文件，对于每一行，也就是每个词x，取hash（x）%n，
然后按照该值存到n个小文件中（即为1，2，3，4…..n），这样将MB级别，或者GB级别大文件分块成kb级别，
如果有的文件超过了1M大小，还可以按照类似的方法继续往下分，直到分解得到的小文件的大小都不超过1M;

（3）读入每一个小文件，利用hash_map统计每个文件中出现的词以及相应的频率，
创建动态数据结构node组，存储data（键值）和num（频率），利用最大堆排列，并取出出现频率最大的100个词，
这里注意不一定只有100词，需要统计100之后是否存在和100相同的值，并把100词和相应的频率以结构[key,num]存入文件中，这样又得到n个文件。

（4）把n个文件读入归并成1个文件all.txt, 创建动态数据结构node组，存储data（键值）和num（频率），
利用最大堆排列，取出出现频率最大的100个词，思路到此。

三. 程序流程图和带有注释的程序

1.生成大数据文件

这里我使用的python生成的数据，之所以用python是当时我想直接在服务器上生成，减少本地电脑的负担。最后生成的数据是15003190条数据，也就是1500万左右，空间81MB,虽然这个数字达不到百亿级别,但是理论上百亿数据是一样的思路。之所以用英文不用中文是由于最开始使用的是随机汉字，但是汉字交集很小，很难有热词。

流程：
循环（1.5k）== 设定随机来源- > 选取长度随机词合并 -> 存储文件
Python代码：# which used for inserting new data

1.	def create():  
2.	    filepath = 'data.txt'  
3.	    dataFrom = ['a','b','c','d','e','f','g','h','i','j']  # 随机来源
4.	    for i in range(10000000):  
5.	        if(i%10000 == 0):  
6.	            print(i)  
7.	  
8.	        data = ''  
9.	  
10.	        for j in range(random.randint(2,5)):  
11.	            data += random.choice(dataFrom)  # 产生2到5的长度数据
12.	  
13.	        with open(filepath , 'a' ) as f:  # 存储文件
14.	            f.write(data + '\n')  
15.	            f.close()

ps：事后写报告发现这里with open没必要每个循环都执行。。。可以修改为全局性！

2.顺序读大文件

这里用的是c++,对于每一行，也就是每个词x，取hash（x）%n，然后按照该值存到n个小文件中（即为1，2，3，4……n），这样将MB级别，或者GB级别大文件分块成kb级别，最后我得到的小文件最大的占用就是609kb。

流程:
设定分块大小num –> 读入大文件all.txt -->
循环（=真) ==对每一行哈希计算%num=分块位置- > 存储对应的分块区域

#include <iostream>  
    2.	#include <fstream>  
    3.	#include <string>  
    4.	#include <typeinfo>  
    5.	#include <iomanip>  
    6.	  
    7.	using namespace std;  
    8.	  
    9.	  
    10.	int spit(int num = 500) {  
    11.	  
    12.	    hash<string> str_hash; // 哈希函数  
    13.	  
    14.	    ifstream file;// 大数据来源  
    15.	    file.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\data.txt",
    ios::in);  
    16.	  
    17.	    if (!file.is_open())  
    18.	  
    19.	        return 0;  
    20.	  
    21.	  
    22.	    std::string strLine;  
    23.	  
    24.	    int i = 0;  
    25.	  
    26.	    ofstream *ofile = new ofstream[num+1]; // 预处理存储num个小文件，num可以自定义，这里设置500  
    27.	  
    28.	    for (i = 1; i <= num; i++) { // 目的是open只需要1次，而不是每一次写入都要open，浪费资源  
    29.	        string filename = to_string(i) + ".txt"; // 存储名  
    30.	        ofile[i].open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\ton\\" +
    filename);  
    31.	    }  
    32.	  
    33.	    i = 0;  
    34.	  
    35.	    while (getline(file, strLine))// 读入大数据文件每一行  
    36.	    {  
    37.	        i++;  
    38.	  
    39.	        if (strLine.empty()) // 是否为空  
    40.	            continue;  
    41.	  
    42.	        int ton = str_hash(strLine) % num; // 哈希计算分块位置  
    43.	         
    44.	        ofile[ton] << strLine << endl; // 写入一行  
    45.	  
    46.	        if (i % 10000 == 0) {  
    47.	            cout << i << endl; // 每写入10000行输出一次，进度说明  
    48.	        }  
    49.	       
    50.	    }  
    51.	  
    52.	    file.close();  
    53.	    for (i = 1; i <= num; i++) {  
    54.	        ofile[i].close();  
    55.	    }  
    56.	    delete[] ofile;  
    57.	}

3.读入每一个小文件

利用hash_map统计每个文件中出现的词以及相应的频率
创建动态数据结构node组，存储data（键值）和num（频率），利用最大堆排列，并取出出现频率最大的100个词，这里注意不一定只有100词，需要统计100之后是否存在和100相同的值，并把100词和相应的频率以结构[key,num]存入文件中，这样又得到n个文件。

这里是最核心的地方。

流程：
循环（500）==
读入小文件 - > 利用hash_map统计频率 ->
hash_map 遍历到node结构的tree组 ->
利用最大堆对tree结构排序 - >
输出前一百的数据到文件

1.	int get100() {  
2.	  
3.	    for (int q = 1; q <= 500; q++) {  
4.	        hash_map<string, int> hm; //建立hash_map 结构 以数据作为key，频率作为value  
5.	        hash_map<string, int> ::iterator it;  
6.	  
7.	        ifstream file; // 建立小文件对象  
8.	        ofstream ofile; // 建立小文件对象  
9.	  
10.	        string filename = to_string(q) + ".txt"; // 文件来向和去向设定  
11.	        file.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\ton\\" + filename, ios::in);  
12.	        ofile.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\100\\" + filename);  
13.	  
14.	        if (!file.is_open())  
15.	            break;  
16.	  
17.	        string strLine;  
18.	        int allNum = 0; // 统计当前小文件的行数，便于创建动态结构node组  
19.	        while (getline(file, strLine)) {  
20.	            if (strLine.empty())  
21.	                continue;  
22.	            hm[strLine] += 1; // hash_map 统计频率  
23.	            allNum++;  
24.	        }  
25.	        cout << "*****" << endl;  
26.	  
27.	        it = hm.begin();  
28.	  
29.	        node* tree = new node[allNum]; // 用来排序  
30.	        int startNum = 0;  
31.	  
32.	        while (it != hm.end()) // 遍历hash_map  
33.	        {  
34.	            tree[startNum].num = it->second; //存储数据  
35.	            tree[startNum].data = it->first;  
36.	            startNum++;  
37.	          //  cout << "pair it_map.key = " << it->first << " pair it_map.string = " << it->second << endl;  
38.	            ++it;  
39.	        }  
40.	  
41.	        Heap_sort(tree, allNum);// 最大堆排列，传入的是node结构  
42.	        cout << "***" << endl;  
43.	  
44.	        int i = 0;  
45.	        while (true) // 输出前一百的数据  
46.	        {  
47.	  
48.	            i++;  
49.	            cout << i << "   " << tree[i].num << "  " << tree[i].data << endl;  
50.	            ofile << tree[i].data <<","<< tree[i].num << endl;  
51.	  
52.	            if (i >= 100 && tree[i].num != tree[i + 1].num) // 保证100之后是否存在和100相同的数据  
53.	                break;  
54.	  
55.	  
56.	  
57.	        }  
58.	        delete[] tree; // 释放空间  
59.	        file.close();  
60.	        ofile.close();  
61.	  
62.	    }  
63.	  
64.	    return 0;  
65.	}

4.把n个文件读入归并成1个文件all.txt。

流程：
循环（500）== 写入同一个all.txt ->统计行数返回。

1.	 int getALl(int &num) {  
2.	  
3.	    ofstream ofile;  
4.	    ofile.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\all.txt"); //来源  
5.	  
6.	    for (int q = 1; q <= 500; q++) {  
7.	        ifstream file;  
8.	  
9.	           
10.	        string filename = to_string(q) + ".txt"; //去向  
11.	        file.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\100\\" + filename, ios::in);  
12.	  
13.	        if (!file.is_open())  
14.	            break;  
15.	  
16.	        string strLine;  
17.	  
18.	        while (getline(file, strLine)) {  
19.	            if (strLine.empty())  
20.	                continue;  
21.	            ofile << strLine << endl;  
22.	            num += 1;  
23.	  
24.	        }  
25.	  
26.	        file.close();  
27.	  
28.	    }  
29.	  
30.	    return 0;  
31.	}

5.创建动态数据结构node组，

存储data（键值）和num（频率），利用最大堆排列，取出出现频率最大的100个词，思路到此。
输出前一百的数据到文件

1.	int main() {  
2.	  
3.	    int dataLine;  
4.	    getALl(dataLine);  
5.	  
6.	    cout << dataLine;  
7.	      
8.	    ifstream file;  
9.	    file.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\all.txt", ios::in);  
10.	    ofstream ofile;  
11.	    ofile.open("C:\\Users\\lenovo\\Desktop\\大二上作业\\数据结构\\last.txt");  
12.	   
13.	    node* tree = new node[dataLine];// 动态结构node  
14.	    int startNum = 0;  
15.	  
16.	    string strLine;  
17.	  
18.	    while (getline(file, strLine)) {  
19.	        if (strLine.empty())  
20.	            continue;  
21.	        
22.	        vector<string> v = split(strLine , ","); //分割split;  
23.	        tree[startNum].num = to_int(v[1]);  
24.	        tree[startNum].data = v[0];  
25.	        startNum++;  
26.	  
27.	    }  
28.	  
29.	  
30.	    Heap_sort(tree, dataLine);  
31.	    cout << "***" << endl;  
32.	  
33.	    int i = 0;  
34.	    while (true)  
35.	    {  
36.	        i++;  
37.	        cout << i << "   " << tree[i].num << "  " << tree[i].data << endl;  
38.	        ofile << i << "   " << tree[i].num << "  " << tree[i].data << endl;  
39.	  
40.	        if (i >= 100 && tree[i].num != tree[i + 1].num) // 输出判断前一百  
41.	            break;  
42.	    }  
43.	    delete[] tree;  
44.	    file.close();  
45.	    ofile.close();  
46.	  
47.	  
48.	}

四.执行程序名，并打印程序运行时的初值和运算结果

1.生成大数据，在服务器用python生成

生成文件：

2.分块500文件

源文件85MB，分块内存占用4MB

3. 读入每一个小文件，利用hash_map统计每个文件中出现的词以及相应的频率，创建动态数据结构node组，存储data（键值）和num（频率），利用最大堆排列，并取出出现频率最大的100个词。

4.最后，前一百生成

五.实验结果分析，实验收获和体会

1.这道题大数据这一点其实体现的很关键，如果是10G的文件，要求1G内存读取，那么就对内存要求非常高了，而关键的思想就是分而治之，分块处理！！！

2.最开始我创建node组没有用delete处理导致内存占用飙升到1G左右，而delete后占用不到4MB，体现了代码对资源的把握要非常高，如何处理资源占用问题非常关键。

3.hash_map之所以使用它，也是由于它的查询非常快，时间复杂度非常低，并且它的思想也是分而治之，类似于桶分布原理。

六.实验的改进意见和建议。

这里的实验我采用的是分而治之思想，但是不一定要在本机运行，当数据达到一定程度，其实可以用分布式计算，把数据划分给不同的子机器，子机器处理后传达给中心机器，同步参数后继续划分给不同的子机器，依次循环即可实现对数据的统计。

并且这里因为数据量还是不大的问题，所以桶分布为500，如果数据更多可以划分更多的桶

再则，其实1500万处理，完成 整个过程也要大概290多秒的时间，本人设备 i5 均跑3.7Ghz，内存 20G，不同机器可能时间不同，主要时间还是花费在读取行数据上面。想过是否能采用多线程处理机制，或者说内存映射之类，后来想想题目根本点在于低内存处理大数据，如果多线程处理，就失去意义了，倒不如采用上面分布式处理！