基于散列表的程序相近度检测系统

最新推荐文章于 2021-01-15 21:11:04 发布
最新推荐文章于 2021-01-15 21:11:04 发布
阅读量2k 收藏 25
点赞数 5
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44077544/article/details/103657025
版权

题目要求：

  1. 分别读取两个C++程序文件（InFile1.cpp, InFile2.cpp），识别其中的关键字并统计频度，分别生成两个文件，保存关键字名称和对应频度（OutFile1.txt, OutFile2.txt）。
  2. 自行设计散列函数，分别利用开放地址法和链地址法构建C语言关键字的散列表。在扫描源程序的过程中，每遇到关键字就查找相应散列表，并累加相应关键字出现的频度。
  3. 根据统计的两个程序中关键字不同频度，可以得到两个向量。
  4. 利用开放地址法和链地址法两种方法实现，分别输出s和两种方法计算s所用的时间，分析比较两种方法的效率。

大二数据结构的课程设计，没有什么突出的地方。就只是实现了题目要求的功能，和两个选作内容。

缺点：

  • 1.没有图形化
  • 2.string类型没有自己定义
  • 3.没有实现C++的多文件组成，导致程序看起来很复杂，很丑。
  • 4.程序不够简洁，很多函数，应该是可以被写一次，让后多次调用的，但是却让我写了很多次。

图形化我试了试，但还没顾上继续学，就被C++的多文件组成，给拦住了。C++的多文件组成也没搞好，程序一被分开，就会报错了。结果两个功能都没搞好。string类型本来自己定义了应该My_string类，但是还没顾上实现，程序简洁也一样，又写了一个，但还没写完。

感悟

自己懂得太少了。为了作图形化，用了visual stdio 2019，才知道什么叫专业，什么叫项目。但还是不知道，为什么代码在不同得编译器上，运行结果还不一样。在codebook上可以运行得代码，在visual stdio 2019上，就运行不了 。

#include<iostream>
#include<fstream>
#include<iomanip>
#include<math.h>
#include<string>
#include<cstring>
#include<typeinfo>
#include<windows.h>
#include<ctime>
#define MOD1 25
using namespace std;
typedef string Type;
template<typename T>
class My_stack
{
private:
    T num;
    My_stack * S = NULL;
public:
    My_stack * next;
    void push(T x);
    void pop();
    bool empty();
};
class linear_table
{
private:
    linear_table * head;
public:
    string key;
    int num;
    linear_table * heads()
    {
        return head;
    }
    linear_table() {}
    linear_table * next;
    linear_table(const char * filename);
};
typedef struct node
{
    Type key;
    int num;
};
typedef struct nodes
{
    Type key;
    int num;
    nodes * next;
};
template<typename T>
bool My_stack<T>::empty()
{
    if(this->S == NULL)
        return 1;
    else
        return 0;
}
template<typename T>
void My_stack<T>::push(T x)
{
    My_stack * p = new My_stack;
    if(!p)
        return;
    p->num = x;
    p->next = S;
    S = p;
}
template<typename T>
void My_stack<T>::pop()
{
    if(this->S == NULL)
        return;
    this->S = this->S->next;
}
My_stack<int> q;
string name[MOD1] = {"void","int","char","float","default","return","throw",
                     "for","if","else","do","while","Auto","short","using","virtual","template",
                     "break","catch","friend","continue","union","volatile","goto","extern"
                    };
int found(Type words,string v)
{
    int l=0,r=words.size()-1,flog=0,k = 0;
//    printf("%d ",r);
    while(1)
    {
        if(q.empty())
        {
            int ans=0;
            while(l<r)
            {
                if(words[l]==words[l+1]&&words[l]=='/')
                {
                    flog=1;
                    break;
                }
                if(words[l]=='/'&&words[l+1]=='*')
                {
                    q.push(1);
                    ans=1;
                    l+=2;
                    break;
                }
                if(v[0]==words[l])
                {
                    int mark=0;
                    for(int i=0; i<v.size(); i++)
                    {
                        if(v[i]!=words[l+i])
                        {
                            mark=1;
                            break;
                        }
                    }
                    if(mark==0&&(l+v.size()==words.size()))
                        k++;
                    else if(words[l+v.size()]-'a'>=0&&words[l+v.size()]-'a'<=25) {}
                    else if(mark==0)
                        k++;
                }
                l++;
            }
            if(flog==1||ans==1)
                break;
        }
        if(flog==1)
            break;
        if(!q.empty())
        {
            while(l<r)
            {
                if(words[l]=='*'&&words[l+1]=='/')
                {
                    q.pop();
                    l+=2;
                    break;
                }
                l++;
            }
        }
        if(l>=r)
            break;
        if(flog==1)
            break;
    }
    return k;
}
int hash_table_num(Type key)
{
    int d = 0;
    for(int i = 0; i<key.length(); i++)
        d = d + key[i];
    return d % MOD1;
}
int hash_found(Type key,node * table)
{
    int t = hash_table_num(key);
    while(table[t].key != key)
    {
        t = (t+1) % MOD1;
        if(t == hash_table_num(key))
        {
            cout<<"found error!!!"<<endl;
            return -1;
        }
    }
    return t;
}
nodes * hash_founds(Type key,nodes * table)
{
    int t = hash_table_num(key);
    nodes * x = &table[t];
    if(table[t].key != key)
    {
        x = table[t].next;
        while(x->key != key)
        {
            x = x->next;
            if(x == NULL)
            {
                cout<<"found error!!!"<<endl;
                return NULL;
            }
        }
    }
    return x;
}
void hash_create(node * &table)
{
    table = new node[MOD1];
    for(int i = 0; i<MOD1; i++)
    {
        table[i].key = "#";
        table[i].num = 0;
    }
    for(int i = 0; i<MOD1 ; i++)
    {
        int t = hash_table_num(name[i]);
        while(table[t].key != "#")
        {
            t = (t+1) % MOD1;
            if(t == hash_table_num(name[i]))
            {
                cout<<"hash table have fill"<<endl;
                return;
            }
        }
        table[t].key = name[i];
    }
}
void hash_creates(nodes * &table)
{
    table = new nodes[MOD1];
    for(int i = 0; i<MOD1; i++)
    {
        table[i].key = "#";
        table[i].num = 0;
        table[i].next = NULL;
    }
    for(int i = 0; i<MOD1 ; i++)
    {
        int t = hash_table_num(name[i]);
        if(table[t].key != "#")         //采用尾插法，可以不改变原链表结构，为以后的多线程作准备
        {
            nodes * T = new nodes;
            T->next = NULL;
            T->num = 0;
            nodes * x = &table[t];
            while(x->next != NULL)
                x = x->next;
            x->next = T;
            T->key = name[i];
        }
        else
            table[t].key = name[i];
    }
}
template <typename T>
bool read_file(string filename,T * table)
{
    char filenames[100];
    memset(filenames,'\0',sizeof(filenames));
    for(int i = 0; i < filename.length(); i++)
        filenames[i] = filename[i];
    cout<<"filename : "<<filename<<endl<<endl;
    fstream file(filenames);
    Type words;
    if(!file)
    {
        cout<<"Error!Can't open file!"<<endl;
        return 0;
    }
    while(!q.empty())
        q.pop();
    while(getline(file,words))
    {
        for(int i = 0; i<MOD1; i++)
        {
            int k = found(words,name[i]);
            if(typeid(table) == typeid(node *) && k )
            {
                table[hash_found(name[i],(node *)table)].num += k;
            }
            else if(typeid(table) == typeid(nodes *) && k )
            {
                hash_founds(name[i],(nodes *)table)->num += k;
            }
        }
    }
    file.close();
    return 1;
}
node * IAS(int num)                                  //识别并统计关键字频率 identify_and_statistics
{
    node * table;
    string filename;
    hash_create(table);
    if(num == 1)
        filename = "mains.cpp";
    else if(num == 2)
        filename = "../课程设计3.0/mains.cpp";
    int max_len;
    if(read_file(filename,table))
    {
        for(int i = 0;i<4;i++)
            cout<<"---------------------------------------------";
        cout<<endl;
        for(int i = 0 ; i<MOD1 ; i++)
        {
            int x = table[i].num,y = 0;
            while(x)
            {
                x = x /10;
                y++;
            }
            max_len = (y > table[i].key.length()) ? y : table[i].key.length();
            cout<<"|"<<setw(max_len)<<setfill(' ')<<table[i].key<<"|";
        }
        cout<<endl;
        for(int i = 0;i<4;i++)
            cout<<"---------------------------------------------";
        cout<<endl;
        for(int i = 0 ; i<MOD1 ; i++)
        {
            int x = table[i].num,y = 0;
            while(x)
            {
                x = x /10;
                y++;
            }
            max_len = (y > table[i].key.length()) ? y : table[i].key.length();
            cout<<"|"<<setw(max_len)<<setfill(' ')<<table[i].num<<"|";
        }
        cout<<endl;
        for(int i = 0;i<4;i++)
            cout<<"---------------------------------------------";
        cout<<endl;
    }
    return table;
}
nodes * IAS_s(int num)
{
    nodes * table;
    string filename;
    hash_creates(table);
    if(num == 1)
        filename = "mains.cpp";
    else if(num == 2)
        filename = "../课程设计3.0/mains.cpp";
    if(read_file(filename,table))
    {
        for(int i = 0; i <MOD1; i++)
        {
            if(table[i].key != "#")
            {
                nodes * p = &table[i];
                while(p != NULL)
                {
                    cout<<"|"<<setw(5)<<setfill(' ')<<p->key<<"|"<<setw(5)<<setfill(' ')<<p->num<<"|";
                    p = p->next;
                }
                cout<<endl;
            }
        }
    }
    return table;
}
template <typename T>
float Relative_Position(T * table1, T * table2)
{
    if(table1 == NULL || table2 == NULL)
    {
        cout<<"Error ! Don't have enough data."<<endl;
        return -1;
    }
    float sum1 = 0,sum2 = 0,sum3 = 0;
    if(typeid(table1) == typeid(node *))
    {
        for(int i = 0; i < MOD1; i++)
        {
            int t = hash_found(name[i],(node *)table1);
            sum1 = sum1 + pow(table1[t].num - table2[t].num,2);
            sum2 = sum2 + pow(table1[t].num,2);
            sum3 = sum3 + pow(table2[t].num,2);
        }
        return sqrt(sum1)/(sqrt(sum2)+sqrt(sum3));      //../课程设计1.0/main.cpp
    }
    else if(typeid(table2) == typeid(nodes *))
    {
        for(int i = 0; i < MOD1; i++)
        {
            nodes * p1 = hash_founds(name[i],(nodes *)table1);
            nodes * p2 = hash_founds(name[i],(nodes *)table2);
            sum1 = sum1 + pow(p1->num - p2->num,2);
            sum2 = sum2 + pow(p1->num,2);
            sum3 = sum3 + pow(p2->num,2);
        }
        return sqrt(sum1)/(sqrt(sum2)+sqrt(sum3));        //../课程设计1.0/main.cpp
    }
}
linear_table::linear_table(const char * filename)
{
    head = new linear_table;
    head->next = NULL;
    string words;
    for(int i = 0; i < MOD1; i++)
    {
        linear_table * p = new linear_table;
        p->key = name[i];
        p->num =       0;
        p->next = head->next;
        head->next = p;
    }
    fstream file(filename);
    if(!file)
    {
        cout<<"Error!Can't open file!"<<endl;
        return;
    }
    while(!q.empty())
        q.pop();
    while(getline(file,words))
    {
        for(int i = 0; i<MOD1; i++)
        {
            int k = found(words,name[i]);
            //if(k != 0)                          删去后，会增加程序运行时间
            linear_table * p = head->next;
            while(p->key != name[i])
            {
                p = p->next;
                if(p == NULL)
                {
                    cout<<"Error! Can't found!"<<endl;
                    return;
                }
            }
            p->num += k;
        }
    }
    linear_table * p = head->next;
    int max_len;
    for(int i = 0;i<4;i++)
        cout<<"---------------------------------------------";
    cout<<endl;
    while(p != NULL)
    {
        int x = p->num,y = 0;
        while(x)
        {
            x = x / 10;
            y++;
        }
        int max_len = (y > p->key.length()) ? y: p->key.length();
        cout<<"|"<<setw(max_len)<<setfill(' ')<<p->key<<"|";
        p = p->next;
        if(p == NULL)
        {
            cout<<endl;
            p = head->next;
            for(int i = 0;i<4;i++)
                cout<<"---------------------------------------------";
            cout<<endl;
            while(p != NULL)
            {
                int x = p->num,y = 0;
                while(x)
                {
                    x = x / 10;
                    y++;
                }
                int max_len = (y > p->key.length()) ? y: p->key.length();
                cout<<"|"<<setw(max_len)<<setfill(' ')<<p->num<<"|";
                p = p->next;
            }

        }
    }
    cout<<endl;
    for(int i = 0;i<4;i++)
        cout<<"---------------------------------------------";
    cout<<endl;
    file.close();
}
void Run_Time(int num)
{
    if(num == 1)
    {
        double startTime = clock();
        node * table1 = IAS(1), * table2 = IAS(2);
        Relative_Position(table1,table2);
        double endTime = clock();
        cout << "The run time is: " <<(double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
    }
    else
    {
        double startTime = clock();
        nodes * table1 = IAS_s(1), * table2 = IAS_s(2);
        Relative_Position(table1,table2);
        double endTime = clock();
        cout << "The run time is: " <<(double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
    }
}
void low_function()
{
    double startTime = clock();
    linear_table table1("mains.cpp");
    linear_table table2("../课程设计3.0/mains.cpp");
    float sum1 = 0,sum2 = 0,sum3 = 0;
    for(int i =0; i<MOD1; i++)
    {
        linear_table * p1 = table1.heads()->next;
        linear_table * p2 = table2.heads()->next;
        while(p1->key != name[i])
            p1 = p1->next;
        while(p2->key != name[i])
            p2 = p2->next;
        sum1 = sum1 + pow(p1->num - p2->num,2);
        sum2 = sum2 + pow(p1->num,2);
        sum3 = sum3 + pow(p2->num,2);
    }
    sqrt(sum1)/(sqrt(sum2)+sqrt(sum3));      //../课程设计1.0/main.cpp
    double endTime = clock();
    cout << "The run time is: " <<(double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
    system("pause");
}
void child_menu(int num)
{
    node * table1 = NULL, * table2 = NULL;
    nodes * table3 = NULL, * table4 = NULL;
    while(1)
    {
        cout<<"（1）识别并统计关键字频率"<<endl;
        cout<<"（2）计算相对位置"<<endl;
        string x = num == 1 ? "（3）开放地址法执行时间" : "（3）链地址法执行时间";
        cout<<x<<endl;
        cout<<"（4）返回主界面"<<endl<<endl;
        cout<<"请选择您需要的服务"<<endl;
        string option;
        cin>>option;
        switch(option[0])
        {
        case '1':
            if(num == 1)
            {
                table1 = IAS(1);
                table2 = IAS(2);
            }
            else
            {
                table3 = IAS_s(1);
                table4 = IAS_s(2);
            }
            break;
        case '2':
            if(num == 1)
                cout<<"relative position is : "<<Relative_Position(table1,table2)<<endl;
            else if(num == 2)
                cout<<"relative position is : "<<Relative_Position(table3,table4)<<endl;
            break;
        case '3':
            Run_Time(num);
            break;
        case '4':
            return;
        }
        system("pause");
        system("cls");
    }
}
int main()
{
    system("COLOR 73");
    cout<<"\t\t\t\t#############################################################"<<endl<<endl<<endl;
    cout<<"\t\t\t\t\t\t"<<"基于散列表的程序相近度检测系统"<<endl<<endl<<endl<<endl;
    cout<<"\t\t\t\t#############################################################"<<endl<<endl;
    for(int i =0; i<40; i++)
    {
        cout<<"=*=";
        Sleep(80);
    }
    cout<<endl<<endl;
    while(1)
    {
        cout<<"（1）开放地址法"<<endl;
        cout<<"（2）链地址法"<<endl;
        cout<<"（3）线性表法"<<endl;
        cout<<"（4）退出系统"<<endl<<endl;
        cout<<"请选择您需要的服务"<<endl;
        string option;
        cin>>option;
        switch(option[0])
        {
        case '1':
            system("cls");
            child_menu(1);
            break;
        case '2':
            system("cls");
            child_menu(2);
            break;
        case '3':
            low_function();
            break;
        case '4':
            return 0;
        }
        system("cls");
    }
}
沐目_01
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
基于哈希表的程序相近度检测系统
weixin_48360514的博客
03-10 250
对于两个 C++程序，设计并实现两种不同的基于哈希表的检测算法，计算两个程序的相近。在控制台输入第一个要对比的程序文件名。在控制台输入第二个要对比的程序文件名。度，并分析比较两种算法的效率。最终得到两个文件的相似度。
基于哈希表的程序相近度检测系统（C++、CodeBlock）
最新发布
qq_43424214的博客
01-23 463
【代码】基于哈希表的程序相近度检测系统（C++、CodeBlock）
基于哈希表的代码相似度检测系统源代码
07-21
代码相似度检测系统源代码 代码相似度检测系统源代码 代码相似度检测系统源代码
数据结构课程设计（散列表计算程序相近度）.doc
07-12
对于两个C程序，设计并实现两种不同的基于散列表的检测算法，计算两个程序的相近度，并分析比较两种算法的效率。
基于Hash表的代码相似度度量
06-04
本人的数据结构实习作业“基于Hash表的代码相似度度量”，代码简洁明了，可读性强，并附带较多的注释，方便他人查看。一般通过查看注释便能了解程序的结构与功能，方便进行修改。以下是实习作业的具体要求： 对于两个C++程序，设计并实现两种不同的基于Hash表的检测算法（开地址法和链地址法），计算两个程序的相似度，并分析比较两种算法的效率。 分别读取两个C++程序文件（p1.cpp, p2.cpp），自行设计哈希函数，分别利用开放地址法和链地址法的冲突解决方案，构建C++语言关键字的Hash表。在扫描源程序的过程中，每遇到关键字就查找相应Hash表，并累加相应关键字出现的频度。 根据统计的两个程序中关键字不同频度，可以得到两个向量X1，X2。通过计算向量X1和X2的相对距离来判断两个源程序的相似性，相对距离s的计算方法是（ T表示向量的转置） |X1—X2| （（X1—X2）（X1—X2）T）1/2 s= ———————— = ——————————————— |X1|1/2•|X2|1/2 （X1•X1T）1/2（X2•X2T）1/2 利用开放地址法和链地址法两种不同的冲突解决方案构建，分别输出s和两种方法计算s所用的时间。 读取C++程序时，过滤注释，不考虑注释中的内容。（两种注释//和/*…*/） 采用二叉排序树来统计其中的关键字及其频度，按照上述公式计算s，同时给出计算s所用的时间。
通过哈希表来判断两个程序的相似性！
qq_38978328的博客
03-07 3337
对于两个C语言的源程序清单，用哈希表的方法分别统计两个程序中使用C语言关键字的情况，并最终按定量的计算结果，得出两份源程序清单的相似性。 以下程序参考网上部分代码，经过修改成功运行通过，分享给大家！ #include&lt;iostream&gt; #include&lt;string.h&gt; #include&lt;fstream&gt; #include&lt;math.h&gt; #in...
数据结构与算法学习总结--散列表
weixin_42638704的博客
10-09 192
文章目录散列表的由来散列表如何实现的O(1)时间复杂度散列函数的基本要求如何解决散列冲突装载因子有两个字符串数组，每个数组大约有10万条字符串，如何快速找出两个数组中相同的字符串？如何设计散列函数散列因子过大时，怎么办工业级散列表的要求如何实现工业级散列函数 散列表的由来 散列表其实是数组的一种扩展，由数组演化而来。散列表用的是数组支持按照下标随机访问数据，时间复杂度为O(1)的特性。 散列表如何实现的O(1)时间复杂度 通过散列函数把元素的键值映射为下标，然后将数据存储在数组中对应下标的位置。当按照
课设 基于散列表设计的电话查询系统
07-23
在本课程设计中，我们将探讨基于散列表设计的电话查询系统。散列表，也被称为哈希表，是一种高效的数据结构，常用于实现关联数组，它能够提供快速的查找、插入和删除操作。在这个电话查询系统中，Java语言被用来实现...
代码相似度检测
12-13
简单的代码相似度检测，使用Java编写。 算法步骤： S1：剔除程序中所有注释、空行、空格 S2：剔除程序中所有变量、函数名 S3：剩下的部分（实际上主要是有 C++关键词构成的字符串）作为代码特征串 S4：两个特征串之间，使用字符串适量距离（Levenshtein Distance）计算相似度。
代码相似度检测系统报告
07-21
代码相似度检测系统报告 代码相似度检测系统报告
课程设计——哈希表的设计
11-04
数据结构实验题目或课程设计——哈希表的设计。创建哈希表，输入名字并查找 伪随机探测再散列法处理冲突
利用Hash技术统计C源程序中关键字的频度
01-04
数据结构课程设计，用C语言写的 一、任务描述 扫描一个C源程序，用Hash表存储该程序中出现的关键字，并统计该程序中的关键字出现的度。用线性探测法解决Hash冲突。设Hash函数为：Hash(Key)=[(Key的首字母序号)*100+(Key的尾字母序号)] Mod 41。关键字39个，参考C语言教材。 二、数据结构设计 ①关键字表的存储结构；②Hash表中的结点结构。频度、冲突次数 三、功能设计 ①从一个大字符串中分解单词 ②识别是否是关键词；用哪种方法：有序表查找、二叉查找树？ ③Hash函数，解决冲突，统计冲突次数。key => 地址 ④插入Hash表，或调整Hash表项中的频度 ⑤输出Hash表，关键词总数，冲突次数
散列表 课程设计
06-12
散列表的设计与实现 相关的课程设计，内容很全面，有讲解也有程序，有需要的欢迎下载哦
程序（Keil版）_基于C51单片机的温度烟雾报警系统_烟雾检测_
10-01
【标题】：“程序（Keil版）_基于C51单片机的温度烟雾报警系统_烟雾检测_”指的是使用Keil C编写的、针对C51单片机的温度和烟雾检测报警系统。这个系统的核心是通过监测环境中的烟雾浓度和温度，实时在LCD液晶显示屏...
利用哈希表统计两源程序的相似性_维特征的哈希技巧总结
weixin_31451231的博客
01-15 393
“本文首先介绍嵌入技术，引出Hash Trick；其次分析就Hash冲突给出理论和实验证明，给出一个减少冲突的方案；接着就具体的场景给出减少特征Hash冲突或者在有限的参数空间内尽可能地表示高维特征的技巧；最后给出简单结论。”文章来源：https://zhuanlan.zhihu.com/p/161058660嵌入与Hash Trick在嵌入技术(Embedding)被广泛使用前，常用...
源程序的相似性分析 —— 基于Python实现哈希表
Alex
11-29 1545
一、问题描述 对于两个C++语言的源程序代码，用哈希表的方法分别统计两个程序中使用C++语言关键字的情况，并最终按定量的计算结果，得出两份程序的相似性。 二、需求分析 建立C++语言关键字的哈希表，统计在每个源程序中C++关键字出现的频度, 得到两个向量X1和X2，通过计算向量X1和X2的相对距离来判断两个源程序的相似性。 例如: 关键字 Void Int For Char if else while do break class 程序1关键字频度 4 3

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值