基于线性表和二叉排序树的低频词过滤系统

最新推荐文章于 2021-12-07 19:23:17 发布
最新推荐文章于 2021-12-07 19:23:17 发布
阅读量221 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52806136/article/details/118388266
版权

基于线性表和二叉排序树的低频词过滤系统

#include<bits/stdc++.h>
using namespace std;
const int MAX=1000;

struct BSNode{
	string name;
	int count;
	BSNode*lchild,*rchild;
	BSNode(){count=0;lchild=NULL;rchild=NULL;}
	BSNode(string a):name(a){count=1;lchild=NULL;rchild=NULL;}
	BSNode(BSNode* tmp){
		name=tmp->name;
		count=tmp->count;
		lchild=NULL;
		rchild=NULL;
	}
};
void insertNode(BSNode*& root,string a){
	if(root){
		int b=root->name.compare(a);
		if(b==0)root->count++;
		else if(b<0)insertNode(root->lchild,a);
		else insertNode(root->rchild,a);
	}
	else root=new BSNode(a);
}
void insertNode(BSNode*& root,BSNode* tmp){
	if(root){
		int b=root->name.compare(tmp->name);
		if(b==0)root->count++;
		else if(b<0)insertNode(root->lchild,tmp);
		else insertNode(root->rchild,tmp);
	}
	else root=new BSNode(tmp);
}
void delet(BSNode*& root){
	if(root){
		delet(root->lchild);
		delet(root->rchild);
		delete root;
	}
}
void printTree(BSNode* root){
	if(root){
		printTree(root->lchild);
		cout.width(15); cout << root->name;
		cout << "\t\t\t";
		cout.width(4); cout << root->count;
		cout << endl;
		printTree(root->rchild);
	}
}
void update2(BSNode*& root,BSNode*& newRoot){
	if(root){
		if(root->count<=3){
			cout.width(15); cout << root->name;
			cout << "\t\t\t";
			cout.width(4); cout << root->count;
			cout << endl;
		}else insertNode(newRoot,root);
		update2(root->rchild,newRoot);
		update2(root->lchild,newRoot);
	}
}
void outPutTree(BSNode*& root,ofstream& fout){
	if(root){
		outPutTree(root->lchild,fout);
		fout.width(15); fout << root->name;
		fout << "\t\t\t";
		fout.width(4); fout << root->count;
		fout << endl;
		outPutTree(root->rchild,fout);
	}
}

class BSTree{
private:
	BSNode*root;
public:
	BSTree(){root=NULL;}
	~BSTree(){
		delet(root);
	}
	BSNode*& Root(){return root;}
	void upda(BSNode*& rot){
		delet(root);
		root=rot;
	}
};

double continueToFinish2();
void showTime2(double);
void distCount2(BSTree&);
void delLow2(BSTree& T);
void showHigh2(BSTree&);
void showASL2(BSTree& T);
void BSTr()
{
	bool flag = true; int ch;
	double time; 
	BSTree T;
	cout << endl;
	while (flag)
	{
		cout << "*******************\n";
		cout << "* 二叉排序树选择菜单 *\n";
		cout << "*******************\n";
		cout << "1、连续执行至完毕\n2、显示执行时间\n3、单步执行：识别并统计单词\n4、单步执行：删除并显示出现频率低单词\n5、单步执行：输出其余单词及其频率\n6、单步执行：计算并输出ASL值\n7、返回主菜单\n   请选择：";
		cin >> ch;
		switch (ch)
		{
		case 1:time = continueToFinish2(); break;
		case 2:showTime2(time); break;
		case 3:distCount2(T); break;
		case 4:delLow2(T); break;
		case 5:showHigh2(T); break;
		case 6:showASL2(T); break;
		case 7:flag = false; break;
		default:cout << "输入错误，请重新输入！\n"; break;
		}
	}
	cout << "退回主程序\n";
	std::system("Pause");
}
double continueToFinish2()
{
	double start, end;
	start = (double)clock();
	BSTree T;
	distCount2(T);
	delLow2(T);
	showHigh2(T);
	showASL2(T);
	end = (double)clock();
	return end - start;
}
void showTime2(double time)
{
	cout << "共执行了" << time << "ms\n";
}
void distCount2(BSTree& T)
{
	ifstream fin("Infile.txt");
	char c;
	while (!fin.eof())
	{
		string str;
		while ((c = fin.get()) != EOF && ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == 39))
		{
			str.push_back(c);
		}
		if (str != "\0")insertNode(T.Root(),str);
	}
	fin.close();
	cout.width(15); cout << "单词";
	cout << "\t\t\t个数统计\n";
	printTree(T.Root());
}
void delLow2(BSTree& T)
{
	cout << "删除成功！\n";
	cout.width(15); cout << "删除的单词";
	cout << "\t\t\t个数统计\n";
	BSNode* newRoot=NULL;
	update2(T.Root(),newRoot);
	T.upda(newRoot);	
}
void showHigh2(BSTree& T)
{
	ofstream fout("Outfire.txt");
	fout.width(15); fout << "单词";
	fout << "\t\t\t个数统计\n";
	outPutTree(T.Root(),fout);
	fout.close();
}
void calculateASL(BSNode* root, int& s, int& n, int p)
{
	if (root)
	{
		n++; p++; s+=p;
		calculateASL(root->lchild, s, n, p);
		calculateASL(root->rchild, s, n, p);
	}
}
void showASL2(BSTree& T)
{
	int s = 0, n = 0, p = 0;
	calculateASL(T.Root(), s, n, p);
	cout << "ASL=" << s / n << endl;
}


//单词结点
struct word
{
	string name;
	int count;
	word() { count = 0; }
};
//线性表
class SeqList
{
public:
	SeqList() { length = 0; }
	void insert(string a){	
		for(int i=1;i<=length;i++){
			if(Word[i].name.compare(a)==0){
				Word[i].count++;return;
			}
		}
		Word[++length].name=a;
		Word[length].count=1;
	}
	void printList(){
		cout.width(15); cout << "单词";
		cout << "\t\t\t个数统计\n";
		for(int i=1;i<=length;i++){
			cout.width(15); cout << Word[i].name;
			cout << "\t\t\t";
			cout.width(4); cout << Word[i].count;
			cout << endl;
		}
		cout<<endl;
	}
	word* getWord() { return Word; }
	int getLength() { return length; }
	void update1(word* high,int count){
		for(int i=1;i<=count;i++){
			Word[i]=high[i];
		}
		length=count;
	}
	void outPutList(ofstream& fout){
		fout.width(15); fout << "单词";
		fout << "\t\t\t个数统计\n";
		for(int i=1;i<=length;i++){
			fout.width(15); fout << Word[i].name;
			fout << "\t\t\t";
			fout.width(4); fout << Word[i].count;
			fout<<endl;
		}
		fout << endl;	
	}
private:
	word Word[MAX];
	int length;
};
void distCount1(SeqList&);
void showTime1(double);
void delLow1(SeqList&);
void showHigh1(SeqList&);
void showASL1(SeqList&);
double continueToFinish1();
void List(){
	bool flag = true; int ch;
	double time; SeqList S;
	cout << endl;
	while (flag){
		cout << "*******************\n";
		cout << "*  线性表选择菜单  *\n";
		cout << "*******************\n";
		cout << "1、连续执行至完毕\n2、显示执行时间\n3、单步执行：识别并统计单词\n4、单步执行：删除并显示出现频率低单词\n5、单步执行：输出其余单词及其频率\n6、单步执行：计算并输出ASL值\n7、返回主菜单\n   请选择：";
		cin >> ch;
		switch (ch){
		case 1:time=continueToFinish1(); break;
		case 2:showTime1(time); break;
		case 3:distCount1(S); break;
		case 4:delLow1(S); break;
		case 5:showHigh1(S); break;
		case 6:showASL1(S); break;
		case 7:flag = false; break;
		default:cout << "输入错误，请重新输入！\n"; break;
		}
	}
	cout << "退回主程序\n";
	system("Pause");
}

double continueToFinish1(){
	double start, end;
	start = (double)clock();
	SeqList S;
	distCount1(S);
	delLow1(S);
	showHigh1(S);
	showASL1(S);
	end = (double)clock();
	return end - start;
}
void showTime1(double time){
	cout << "共执行了" << time << "ms\n";
}
void distCount1(SeqList& S){
	ifstream fin("Infile.txt");
	char c;
	while (!fin.eof()){
		string str;
		while ((c = fin.get()) != EOF && ((c>='0'&&c<='9')||(c>='A'&&c<='Z')||(c>='a'&&c<='z')||c==39))
			str.push_back(c);
		if (str != "\0")S.insert(str);
	}
	fin.close();
	S.printList();
}
void delLow1(SeqList& S){
	word high[1000];
	int count = 0;
	int i;
	cout << "删除成功！\n";
	cout.width(15); cout << "删除的单词";
	cout << "\t\t\t个数统计\n";
	for (i = 1; i <= S.getLength(); i++){
		word tmp=S.getWord()[i];
		if (tmp.count <= 3){
			cout.width(15); cout << tmp.name;
			cout << "\t\t\t";
			cout.width(4); cout << tmp.count;
			cout << endl;
		}
		else{
			high[++count] = tmp;
		}
	}
	S.update1(high, count);
}
void showHigh1(SeqList& S){
	ofstream fout("Outfire.txt");
	S.outPutList(fout);
	fout.close();
}
void showASL1(SeqList& S){
	cout << "ASL=" << (1 + S.getLength()) / 2;
	cout << endl;
}
int main(){
	bool flag = true; int ch;
	while (flag){
		system("cls");
		cout << "*******************\n";
		cout << "*      主菜单      *\n";
		cout << "*******************\n";
		cout << "1、线性表\n2、二叉排序树\n3、退出程序\n   请选择：";
		cin >> ch;
		switch (ch){
		case 1:List(); break;
		case 2:BSTr(); break;
		case 3:flag = false; break;
		default:cout << "输入错误，请重新输入！\n";
		}
	}
	cout << "退出程序！\n";
	system("Pause");
	return 0;
}
SaadiyaQAQ
关注
基于线性表和二叉排序树的低频词过滤系统（数据结构课设）
qq_45858840的博客
06-26 927
（一）实验内容 对于一篇给定的英文文章，分别利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。具体要求如下： 读取英文文章文件（Infile.txt），识别其中的单词。 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。 其余单词及其出现频率按照从高到低的次序输出到文件中（Out
数据结构课设——基于线性表和二叉排序树的低频词过滤系统
qq_45775244的博客
06-26 1059
基于线性表和二叉排序树的低频词过滤系统 目录基于线性表和二叉排序树的低频词过滤系统实验内容 实验内容 对于一篇给定的英文文章，分别利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。具体要求如下： 读取英文文章文件（Infile.txt），识别其中的单词。 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 统计结束后，删除出现频率低于五次的单词，并显示该
实验三：基于线性表和二叉排序树的低频词过滤系统（源码）
m0_59500708的博客
07-01 571
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> #include <time.h> typedef struct node1 { //单链表节点 char data[20]; int count; struct node1* next; }LNo...
基于二叉排序树的低频词过滤系统
qq_48297115的博客
06-26 621
一、实验内容 对于一篇给定的英文文章，利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。具体要求如下： 读取英文文章文件（Infile.txt），识别其中的单词。 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。 其余单词及其出现频率按照从高到低的次序输出到文件中（Outfil
基于线性表或二叉排序树的低频词过滤系统
qq_25381649的博客
12-07 1360
问题描述：对于一篇给定的英文文章，分别利用线性表或二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。 来这看的估计都是想搞数据结构课程设计吧，不知道有没有跟我同一个老师的，拿走后记得修改一下下 注意单步执行需要按顺序，不想这样的话可以自己修改函数 功能要求： 1. 读取英文文章文件（InFile.txt），识别其中的单词。 2. 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别
低频词过滤系统
Louie_min的博客
06-26 1776
基于线性表和二叉排序树的低频词过滤系统的设计与实现 此报告并不好。看看就可 `#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<time.h> #include<string.h> #include using namespace std; /定义的函数与全局变量/ int a;//用于选判断选择什么服务 void screem();//主屏幕 void screem2
基于线性表和二插排序树的低频词过滤系统
m0_57102339的博客
06-22 308
#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<time.h> #include<string.h> #include<iostream> using namespace std; //显示函数 int a;//用于选判断选择什么服务 void main_menu() //主菜单 { cout << "1、线性
基于二叉排序树的低频词过滤系统(源码）
qq_56277977的博客
07-01 366
//Linklist.h #pragma once #include<iostream> #include<string> using namespace std; struct Node { string word;//单词 int count;//出现次数 Node* next; }; class LinkList { public: LinkList(); ~LinkList(); void insert(string word);//添加单词 void r.
数据结构，低频词过滤
09-07
基于线性表和二叉排序树的低频词过滤系统 对于一篇给定的英文文章，分别利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。 (1) 读取英文文章文件（InFile.txt），识别其中的单词。 (2) 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词， 则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 (3) 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。 (4) 其余单词及其出现频率按照从高到低的次序输出到文件中（OutFile.txt），同时输出用两种方法完成该工作所用的时间。
基于二叉排序树的低频词过滤系统(实验准备）
qq_56277977的博客
06-26 323
实验内容 对于一篇给定的英文文章，利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。 实验要求 1.读取英文文章文件（Infile.txt），识别其中的单词。 2.分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。 3.其余单词及其出现频率按照从高到低的次序输出到文件中（Outfil
数据结构课设--基于二叉排序树的低频词过滤系统
qq_45740088的博客
06-22 934
数据结构课设--基于二叉排序树的低频词过滤系统一.实验内容二.实验提示三.实验代码 一.实验内容 对于一篇给定的英文文章，利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。具体要求如下： 读取英文文章文件（Infile.txt），识别其中的单词。 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 统计结束后，删除出现频率低于五次的单词，并
数据结构课程设计2021-2
MikotoChar的博客
06-19 416
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
2021-06-25
opencsdn1的博客
06-25 373
基于二叉树的低频词过滤系统 文章目录基于二叉树的低频词过滤系统一、 问题概述1.1 实验内容1.2 实验目的1.3 实验要求1.3.1 文档下载二、程序设计2.1 算法设计2.1.1 线性表数据结构2.1.2 元素入表2.1.3 交换元素2.1.4 排序2.1.5 输出频率2.1.6 识别统计2.1.7 删除2.1.8 输出高频词汇2.1.9 计算ASL2.1.10 菜单函数2.1.11主体函数2.1.2 计算时间2.1.2 执行三、源代码3.1 Node.h（头文件）3.2 LinkList.h （头文
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值