2021-6-20数据结构实验3预习

最新推荐文章于 2022-04-10 09:39:32 发布
最新推荐文章于 2022-04-10 09:39:32 发布
阅读量362 收藏 5
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45644751/article/details/118087250
版权

线性表，二叉排序树低频词过滤系统

一，内容要求：

  1. 对于一篇给定的英文文章，分别利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。具体要求如下：2. 读取英文文章文件（Infile.txt），识别其中的单词。3. 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。4. 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。5. 其余单词及其出现频率按照从高到低的次序输出到文件中（Outfile.txt），同时输出用两种方法完成该工作所用的时间。计算查找表的ASL值，分析比较两种方法的效率。

二，部分主要代码：
线性表：
1，读取英文文章文件（Infile.txt），识别其中的单词：

SeqList<Cha> t;
f.open("Infile.txt", ios::in);
 if (!f) {
  cout << "不存在文件Infile.txt" << endl;
 }
 else {
  cout << "存在文件Infile.txt" << endl;
  while (f.peek()!= EOF) {
   f >>tem.name;
   t.Insert(1, tem);
  }
 }
 f.close();

2，利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。

SeqList<Cha> s;//定义顺序表对象；
SeqList<Cha> t;//中转
for (int i = 0; i < t.GetLength(); ++i) {
      tem = t.Get(i + 1);
      s.Insert1(1, tem);//把tem插入位置一
     }
 PrintList(s);

3，删除出现频率低于五次的单词，并显示该单词和其出现频率。

for (int i = 0; i < s.GetLength(); ++i) {//先遍历
      cout << s.GetLength() << endl;
      tem = s.Get(i + 1);
      if (tem.fq < 5) {
       cout << "被删:" << endl;
       PrintSd(s.Get(i + 1));
       s.Delete(i + 1);
       i--;//!!!!!!删了这位置数据，后面所有数据会前移动，如果让i++，会跳过新移到这位置的数据；
      }
     }

4，其余单词及其出现频率按照从高到低的次序输出到文件中（Outfile.txt），同时输出用两种方法完成该工作所用的时间。

clock_t start, finish;
     start = clock();
     s.QuickSort(0, s.GetLength() - 1);
     ofstream g("Outfile.txt");
     if (!g) {
      cout << "不能打开文件Outfile.txt" << endl;
      exit(1);
     }
     int i = 1;
     int len = s.GetLength();
     if (len >= 2) {
      while (i <= len - 1) {
       tem = s.Get(i);
       g << tem.name << " ";//单词之间的间隔；
       ++i;
      }
      tem = s.Get(i);
      g << tem.name;
     }
     else {
      if (len == 1) {
       tem = s.Get(1);
       g << tem.name;      }
      else {
       cout << "无记录" << endl;
      }
     }
     g.close();
     cout << "保存完毕" << endl;
     finish = clock();
     cout << finish - start << "/" << CLOCKS_PER_SEC << " (s) " << endl;

5，计算查找表的ASL值。

template < class T >
void SeqList<T>::Asl() {
 double tem;
 tem = (length + 1) / 2;
 cout << "若查找成功,ASL=" <<tem<< endl;
 tem = length;
 cout << "若查找不成功,ASL=" << tem << endl;
}

二叉排序树：
1，读取英文文章文件（Infile.txt），识别其中的单词：

SeqList<Cha> t;
f.open("Infile.txt", ios::in);
 if (!f) {
  cout << "不存在文件Infile.txt" << endl;
 }
 else {
  cout << "存在文件Infile.txt" << endl;
  while (f.peek()!= EOF) {
   f >>tem.name;
   t.Insert(1, tem);
  }
 }
 f.close();

2，利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。

 BSTree<Cha> bst1(t);//中转
 bst = bst1;
 bst.Cout();


template < class T >
BSTNode* BSTree<T>::Insert(BSTNode* root, BSTNode* s) {//二叉排序树递归插入函数
 if (root ==NULL) return s;//递归停止条件
 else {
  if (s->cha.fq < root->cha.fq) {//寻找合适的位置
   root->lchild = Insert(root->lchild, s);  }
  else {
   root->rchild = Insert(root->rchild, s);
  }
 }
 return root;
}template < class T >
BSTree<T>::BSTree(SeqList<T> sq) {//二叉排序树带参构造函数
 root = NULL;
 for (int i = 0; i < sq.GetLength(); ++i) {//遍历线性表
  BSTNode* s = new BSTNode;//s为插入的结点
  s->cha = sq.Get(i + 1);
  s->lchild = NULL;
  s->rchild = NULL;
  root = Insert(root, s);
 }
}

3，统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。

template < class T >
void BSTree<T>::Release(BSTNode* root) {
 if (root == NULL) {
  return;
 }
 Release(root->lchild);
 Release(root->rchild);
 delete root;
}

template < class T >void BSTree<T>::Cout(){
 cout << "单词名       频率" << endl;
 cout << "----------------------------" << endl;
 Inorder(Getroot());
 cout << "----------------------------" << endl;}


template < class T >
void BSTree<T>::Inorder(BSTNode* root) {
 if (root == NULL) {
  return;
 }
 Inorder(root->lchild);
 cout << root->cha.name << setw(9) << root->cha.fq << endl;
 Inorder(root->rchild);
}

4，其余单词及其出现频率按照从高到低的次序输出到文件中（Outfile.txt），同时输出用两种方法完成该工作所用的时间。

clock_t start, finish;
 start = clock();
     
 bst.outfile2(bst.Getroot());

 cout << "保存完毕" << endl;
 finish = clock();
 cout << finish - start << "/" << CLOCKS_PER_SEC << " (s) " << endl;

5，计算查找表的ASL值

template < class T >
void BSTree<T>::Asl() {
	BSTNode* t = this->Getroot();
	if (t == NULL)return;

	queue<BSTNode*> a;//暂时存需拓展的树根结点
	queue<BSTNode*> parent;//暂时存已经拓展的结点
	BSTNode* p;
	int n = 0; //所有元素个数
	int m = 0; //所有补上的叶结点数
	int i = 1;//树的层数
	int  w[10] = { 0 };//每层元素个数
	int r[10] = { 0 };//每层补上的叶结点数
	int fu[10] = { 0 };//每层父节点（已经拓展的结点）数量，辅助清parent队列
	int flag = 1;


	a.push(t);
	while (!a.empty())
	{
		p = a.front();
		a.pop();//删第一个

		if (p->rchild == NULL || p->lchild == NULL) {
			r[i]++;//每层补上的叶结点数
			m++;
		}

		w[i]++;   //每层元素个数
		n++;      //结点个数
		if (a.empty())
		{
			if (flag == 1) {//只用一次的换行，给第一层用
				i++;
				flag++;
			}
			//if (p->lchild == NULL && p->rchild == NULL)break;//跳出while循环；
		}

		if (p->lchild != NULL || p->rchild != NULL)
		{
			if (p->lchild != NULL)a.push(p->lchild);
			if (p->rchild != NULL)a.push(p->rchild);
			parent.push(p);
			if (fu[1] == 0)
				fu[1] = 1;//根节点
			else
				fu[i]++; //父节点数量
		}
		//一层结束，父节点队列出队，清parent
		//左节点不为空，右节点为空,  且p等于左节点
		if ((parent.front()->lchild != NULL) && p == parent.front()->lchild)
		{
			for (int j = 0; j < fu[i]; j++)
				parent.pop();
			i++;//一层结束
		}
		//右节点不为空，左节点为空,  且p等于右节点
		else if ((parent.front()->rchild != NULL) && p == parent.front()->rchild)
		{
			for (int j = 0; j < fu[i]; j++)
				parent.pop();
			i++;//一层结束
		}
	}


	int s = 0, z = 0;
	for (int j = 0; j <= i; j++)//共i+1层
	{
		s += j * w[j];//所有（层元素个数*层数）的总数
		z += j * r[j];// 所有（层补上的叶结点数* 层数）的总数

	}
	cout << "查找成功时的平均检索长度(ASL)=" << endl;
	cout << s << '/' << n << endl;
	cout << "查找失败时的平均检索长度(ASL)=" << endl;
	cout << z << '/' << m << endl;

}

三，效果截图
在这里插入图片描述

Infile.txt:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述排好的outfile.txt

在这里插入图片描述

二叉排序树同理
在这里插入图片描述
四，总结：
完整代码由一个单词结构体Cha，一个顺序表，一个二叉树结点结构体BSTNode，一个二叉排序树类BSTree组成和主函数。
主函数中注意switch的case的break不要漏，不然无法返回上一级菜单；顺序表的删除注意不要漏掉遍历的元素，因为每删除一个，后面的元素都会变一次位置。用文件流读入数据时注意最后不要留空行，不然最后一个元素会被读取两次，解决：重新搞一个txt文件读取。

完整代码：

#include<iostream>
#include<string>
#include<fstream>
#include<iomanip>
#include<ctime>
#include<queue>
#include<vector>
#define MaxSize 100
using namespace std;


typedef struct {
	string name; //单词名
	double fq;     //对应频率
}Cha;
vector<Cha> v(0);//存放要输出到文件的数据；

typedef struct BiNode {
	Cha cha;
	struct BiNode* lchild, * rchild;
} BSTNode;


template < class T >
class SeqList
{
public:
	SeqList() { length = 0; }       //无参构造函数
	SeqList(T a[], int n);       //有参构造函数
	~SeqList();             //析构函数为空
	int Search(string x);//名字查找
	void Insert(int i, T x);  //在顺序表中第i个位置插入值为x的元素（i为逻辑号）
	void Insert1(int i, T x);
	void Delete(int i);//删除顺序表的第i个元素（i为逻辑号）
	void QuickSort(int low, int high);//降序排列
	void Asl();//ASL
	int GetLength() { return length; }  //求顺序表的长度
	T Get(int i);  //取顺序表的第i个元素（i为逻辑号）

private:
	T data[MaxSize];      //存放数据的数组
	int length;            //顺序表的长度
};

template < class T >
SeqList<T>::SeqList(T a[], int n) { //有参构造函数
	if (n > MaxSize) cout << "参数错误" << endl;
	for (int i = 0; i < n; ++i) {
		data[i] = a[i];
	}
	length = n;//初始化
}

template < class T >
int SeqList<T>::Search(string x) {
	for (int i = 0; i < length; ++i) {
		if (data[i].name == x) {
			data[i].fq++;
			return 1;
		}
	}
	return 0;
}

template < class T >
void SeqList<T>::Insert(int i, T x) {//i为逻辑号
	cout << x.name << endl;
	if (Search(x.name)) {
		return;
	}
	else {
		if (length >= MaxSize) cout << "上溢" << endl;
		if (i > length + 1) cout << "位置错误" << endl;
		for (int j = length; j >= i; --j) {  //遍历调整元素位置； 
			data[j] = data[j - 1];
		}
		data[i - 1].fq = 1;
		data[i - 1].name = x.name;//同时改变length
		++length;
	}
}

template < class T >
void SeqList<T>::Insert1(int i, T x) {
	if (length >= MaxSize) cout << "上溢" << endl;
	if (i<1 || i>length + 1) cout << "位置错误" << endl;
	for (int j = length; j >= i; --j) {  //遍历调整元素位置； 
		data[j] = data[j - 1];
	}
	data[i - 1] = x;//同时改变length
	++length;
}


template < class T >
void SeqList<T>::Delete(int i) {
	if (length == 0) cout << "下溢" << endl;
	if (i<1 || i>length) cout << "位置错误" << endl;
	T x = data[i - 1];
	for (int j = i; j < length; ++j) {
		data[j - 1] = data[j]; //删除的元素后的元素全部前移动一位，以达到删除的目的； 
	}
	--length;//同时改变length
	return;
}


template < class T >
void PrintList(SeqList<T> d) { //全部输出； 

	cout << "       单词数： " << d.GetLength() << endl;

	if (d.GetLength() > 0) {//有则输出
		cout << "单词名       频率" << endl;
		cout << "----------------------------" << endl;
		for (int i = 1; i <= d.GetLength(); ++i) {
			Cha s = d.Get(i);
			cout << s.name << setw(9) << s.fq << endl;
		}
		cout << "----------------------------" << endl;
	}
	else {//无
		cout << "无记录" << endl;
	}
}


template < class T >
void PrintSd(T s) {  //输出指定位置元素； 
	cout << "单词名       频率" << endl;
	cout << "----------------------------" << endl;
	cout << s.name << setw(9) << s.fq << endl;
	cout << "----------------------------" << endl;
}



template < class T >
void SeqList<T>::QuickSort(int low, int high) {
	if (low < high)  //递归终止条件
	{

		int i = low, j = high;

		T x = data[low];

		while (i < j) {

			while (i < j && data[j].fq <= x.fq) j--;  //先从右边开始

			if (i < j) data[i++] = data[j];

			while (i < j && data[i].fq >= x.fq) i++;

			if (i < j) data[j--] = data[i];

		}
		data[i] = x;  //i已经排列好

		QuickSort(low, i - 1);//递归  
		QuickSort(i + 1, high);
	}
}

template < class T >
void SeqList<T>::Asl() {
	double tem;
	tem = (length + 1) / 2;
	cout << "若查找成功,ASL=" << tem << endl;
	tem = length;
	cout << "若查找不成功,ASL=" << tem << endl;
}

template < class T >
T SeqList<T>::Get(int i) { //取顺序表的第i个元素
	if (i > 0 && i <= length) //保证i不会引起数组overflow; 
		return data[i - 1];

}

template < class T >
SeqList<T>::~SeqList() {

}






template < class T >
class BSTree {
public:
	BSTree() { root = NULL; };
	BSTree(SeqList<T> sq);//二叉排序树带参构造函数
	~BSTree() {}
	void Release(BSTNode* root);//释放root为根的树
	BSTNode* Getroot() { return root; }
	BSTNode* Insert(BSTNode* root, BSTNode* s);//二叉排序树递归插入函数
	void Inorder(BSTNode* root);//中序遍历
	void Cout();//输出
	void Asl();//求Asl()
	void outfile2(BSTNode* root);//输出到文件并输出执行时间
private:
	BSTNode* root;

};

template < class T >
BSTNode* BSTree<T>::Insert(BSTNode* root, BSTNode* s) {//二叉排序树递归插入函数
	s->lchild = NULL;
	s->rchild = NULL;
	if (root == NULL) return s;//递归停止条件
	else {
		if (s->cha.fq < root->cha.fq) {//寻找合适的位置
			root->lchild = Insert(root->lchild, s);
		}
		else {
			root->rchild = Insert(root->rchild, s);
		}
	}
	return root;
}


template < class T >
BSTree<T>::BSTree(SeqList<T> sq) {//二叉排序树带参构造函数
	root = NULL;
	for (int i = 0; i < sq.GetLength(); ++i) {//遍历线性表
		BSTNode* s = new BSTNode;//s为插入的结点
		s->cha = sq.Get(i + 1);
		s->lchild = NULL;
		s->rchild = NULL;
		root = Insert(root, s);
	}
}


template < class T >
void BSTree<T>::Release(BSTNode* root) {//释放root为根的树
	if (root == NULL) {
		return;
	}
	Release(root->lchild);
	Release(root->rchild);
	delete root;
	root == NULL;
}
template < class T >
void BSTree<T>::Inorder(BSTNode* root) {//中序遍历
	if (root == NULL) {
		return;
	}
	Inorder(root->lchild);
	v.push_back(root->cha);
	cout << root->cha.name << setw(9) << root->cha.fq << endl;
	Inorder(root->rchild);
}

template < class T >
void BSTree<T>::outfile2(BSTNode* root) {//输出到文件并输出执行时间
	if (root == NULL)return;
	ofstream g("Outfile.txt");


	if (!g) {
		cout << "不能打开文件Outfile.txt" << endl;
		exit(1);
	}
	v.clear();
	this->Inorder(root);
	reverse(v.begin(), v.end());
	for (int i = 0; i < v.size(); ++i) {
		g << v[i].name << " ";//单词之间的间隔；

	}


	g.close();
	cout << "保存完毕" << endl;
}

template < class T >

void BSTree<T>::Cout() {
	cout << "单词名       频率" << endl;
	cout << "----------------------------" << endl;
	Inorder(Getroot());
	cout << "----------------------------" << endl;

}

template < class T >
void BSTree<T>::Asl() {
	BSTNode* t = this->Getroot();
	if (t == NULL)return;

	queue<BSTNode*> a;//暂时存需拓展的树根结点
	queue<BSTNode*> parent;//暂时存已经拓展的结点
	BSTNode* p;
	int n = 0; //所有元素个数
	int m = 0; //所有补上的叶结点数
	int i = 1;//树的层数
	int  w[10] = { 0 };//每层元素个数
	int r[10] = { 0 };//每层补上的叶结点数
	int fu[10] = { 0 };//每层父节点（已经拓展的结点）数量，辅助清parent队列
	int flag = 1;


	a.push(t);
	while (!a.empty())
	{
		p = a.front();
		a.pop();//删第一个

		if (p->rchild == NULL || p->lchild == NULL) {
			r[i]++;//每层补上的叶结点数
			m++;
		}

		w[i]++;   //每层元素个数
		n++;      //结点个数
		if (a.empty())
		{
			if (flag == 1) {//只用一次的换行，给第一层用
				i++;
				flag++;
			}
			//if (p->lchild == NULL && p->rchild == NULL)break;//跳出while循环；
		}

		if (p->lchild != NULL || p->rchild != NULL)
		{
			if (p->lchild != NULL)a.push(p->lchild);
			if (p->rchild != NULL)a.push(p->rchild);
			parent.push(p);
			if (fu[1] == 0)
				fu[1] = 1;//根节点
			else
				fu[i]++; //父节点数量
		}
		//一层结束，父节点队列出队，清parent
		//左节点不为空，右节点为空,  且p等于左节点
		if ((parent.front()->lchild != NULL) && p == parent.front()->lchild)
		{
			for (int j = 0; j < fu[i]; j++)
				parent.pop();
			i++;//一层结束
		}
		//右节点不为空，左节点为空,  且p等于右节点
		else if ((parent.front()->rchild != NULL) && p == parent.front()->rchild)
		{
			for (int j = 0; j < fu[i]; j++)
				parent.pop();
			i++;//一层结束
		}
	}


	int s = 0, z = 0;
	for (int j = 0; j <= i; j++)//共i+1层
	{
		s += j * w[j];//所有（层元素个数*层数）的总数
		z += j * r[j];// 所有（层补上的叶结点数* 层数）的总数

	}
	cout << "查找成功时的平均检索长度(ASL)=" << endl;
	cout << s << '/' << n << endl;
	cout << "查找失败时的平均检索长度(ASL)=" << endl;
	cout << z << '/' << m << endl;

}



int main() {
	ifstream f;//调用外部文件用；
	int w;//键盘输入的数据位置；
	int op, sw; //switch选case的凭依； 
	Cha tem; // 辅助SeqList<Sd> s的函数Insert()使用； 
	SeqList<Cha> s;//定义顺序表对象；
	SeqList<Cha> t;//中转
	BSTree<Cha> bst;
	string na;//辅助输入名字；
	int whil = 1;
	int whi = 1; //菜单进入和跳出的条件；
	int wh = 1;//菜单case1循环输入；

	f.open("Infile.txt", ios::in);
	if (!f) {
		cout << "不存在文件Infile.txt" << endl;
	}
	else {
		cout << "存在文件Infile.txt" << endl;
		while (f.peek() != EOF) {
			f >> tem.name;
			t.Insert(1, tem);
		}
	}
	f.close();

	while (whil) {
		whi = 1;//重置；
		cout << "     主菜单      " << endl;
		cout << "     1.顺序表" << endl;
		cout << "     2.二叉排列树" << endl;
		cout << "     3.退出" << endl;
		cout << "     输入（1~3）         " << endl;
		cin >> sw;
		switch (sw) {
		case 1:
			while (whi) {
				cout << "     主菜单      " << endl;
				cout << "     1.识别并统计单词" << endl;
				cout << "     2.删除显示低频单词" << endl;
				cout << "     3.输出所有单词" << endl;
				cout << "     4.计算输出ASL" << endl;
				cout << "     5.输出输出到文件的执行时间" << endl;
				cout << "     6.返回" << endl;
				cout << "     输入（1~6）         " << endl;
				cin >> op;
				switch (op) {
				case 1:
					for (int i = 0; i < t.GetLength(); ++i) {
						tem = t.Get(i + 1);
						s.Insert1(1, tem);//把tem插入位置一
					}
					PrintList(s);
					break;
				case 2:
					for (int i = 0; i < s.GetLength(); ++i) {//先遍历
						cout << s.GetLength() << endl;
						tem = s.Get(i + 1);
						if (tem.fq < 5) {
							cout << "被删:" << endl;
							PrintSd(s.Get(i + 1));
							s.Delete(i + 1);
							i--;//!!!!!!删了这位置数据，后面所有数据会前移动，如果让i++，会跳过新移到这位置的数据；
						}
					}

					break;
				case 3:
					PrintList(s);
					break;
				case 4:
					s.Asl();
					break;
				case 5: {
					clock_t start, finish;
					start = clock();
					s.QuickSort(0, s.GetLength() - 1);
					ofstream g("Outfile.txt");
					if (!g) {
						cout << "不能打开文件Outfile.txt" << endl;
						exit(1);
					}
					int i = 1;
					int len = s.GetLength();
					if (len >= 2) {
						while (i <= len - 1) {
							tem = s.Get(i);
							g << tem.name << " ";//单词之间的间隔；
							++i;
						}
						tem = s.Get(i);
						g << tem.name;
					}
					else {
						if (len == 1) {
							tem = s.Get(1);
							g << tem.name;

						}
						else {
							cout << "无记录" << endl;
						}
					}
					g.close();
					cout << "保存完毕" << endl;
					finish = clock();
					cout << finish - start << "/" << CLOCKS_PER_SEC << " (s) " << endl;
					break;
				}
				case 6:
					whi = 0;
					break;
				default:continue;
				}
			}
			break;
		case 2:
			while (whi) {
				cout << "     主菜单      " << endl;
				cout << "     1.识别并统计单词" << endl;
				cout << "     2.删除显示低频单词" << endl;
				cout << "     3.输出所有单词" << endl;
				cout << "     4.计算输出ASL" << endl;
				cout << "     5.输出输出到文件的执行时间" << endl;
				cout << "     6.返回" << endl;
				cout << "     输入（1~6）         " << endl;
				cin >> op;
				switch (op) {
				case 1: {
					BSTree<Cha> bst1(t);//中转
					bst = bst1;
					bst.Cout();
					break;
				}
				case 2: {
					s = t;
					for (int i = 0; i < s.GetLength(); ++i) {//先遍历
						cout << s.GetLength() << endl;
						tem = s.Get(i + 1);
						if (tem.fq < 5) {
							cout << "被删:" << endl;
							PrintSd(s.Get(i + 1));
							s.Delete(i + 1);
							i--;//!!!!!!删了这位置数据，后面所有数据会前移动，如果让i++，会跳过新移到这位置的数据；
						}
					}
					BSTree<Cha> bst1(s);
					bst = bst1;
					break;
				}

				case 3:
					bst.Cout();
					break;
				case 4:
					bst.Asl();
					break;
				case 5: {
					clock_t start, finish;
					start = clock();
					bst.outfile2(bst.Getroot());
					finish = clock();
					cout << finish - start << "/" << CLOCKS_PER_SEC << " (s) " << endl;
					break;
				}
				case 6:
					whi = 0;
					break;
				default:continue;
				}
			}
			break;//!!!!!!不可无，不然无法返回上一级目录；
		case 3:
			whil = 0;
			break;
		default: continue;

		}

	}
	bst.Release(bst.Getroot());//人为析构，自己析构的话case 1构建了，然后又析构了，别的case用不了；
	return 0;
}
潇影
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于线性表和二叉排序树的低频词过滤系统
weixin_53061641的博客
06-19 633
基于线性表和二叉排序树的低频词过滤系统 （一）实验内容 对于一篇给定的英文文章，分别利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。具体要求如下： 读取英文文章文件（Infile.txt），识别其中的单词。 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词，则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。 其余单词
本科数据结构实验指导与预习报告书.pdf
05-19
数据结构实验指导与预习报告书 数据结构实验指导书与预习报告是本科生数据结构实验指导书的重要组成部分。该报告书涵盖了数据结构的基本概念、顺序表和链表的实现、通讯录管理系统的设计和实现等方面的内容。 实验...
数据结构，低频词过滤
09-07
基于线性表和二叉排序树的低频词过滤系统 对于一篇给定的英文文章，分别利用线性表和二叉排序树来实现单词频率的统计，实现低频词的过滤，并比较两种方法的效率。 (1) 读取英文文章文件（InFile.txt），识别其中的单词。 (2) 分别利用线性表和二叉排序树构建单词的存储结构。当识别出一个单词后，若线性表或者二叉排序树中没有该单词， 则在适当的位置上添加该单词；若该单词已经被识别，则增加其出现的频率。 (3) 统计结束后，删除出现频率低于五次的单词，并显示该单词和其出现频率。 (4) 其余单词及其出现频率按照从高到低的次序输出到文件中（OutFile.txt），同时输出用两种方法完成该工作所用的时间。
数据结构课程设计2021-2
MikotoChar的博客
06-19 389
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
预习：图书信息管理系统的设计与实现
Yansoul_的博客
06-18 1398
（一）实验内容 设计并实现一个图书信息管理系统。根据实验要求设计该系统的菜单和交互逻辑，并编码实现增删改查的各项功能。该系统至少包含以下功能： 根据指定图书个数，逐个输入图书信息； 逐个显示图书表中所有图书的相关信息； 能根据指定的待入库的新图书的位置和信息，将新图书插入到图书表中指定的位置； 根据指定的待出库的旧图书的位置，将该图书从图书表中删除； 能统计表中图书个数； 实现图书信息表的图书去重； 实现最爱书籍查询，根据书名进行折半查找，要求使用非递归算法实现，成功返回此书籍的书号和价格.
行业文档-设计装置-用于结构实验教学的综合教学系统.zip
08-24
《用于结构实验教学的综合教学系统》 在教育领域，特别是工程类专业，结构实验教学是培养学生实践能力和理论知识相结合的重要环节。这个综合教学系统针对这一需求，旨在提供一个高效、直观的学习平台，帮助学生深入...
《数据结构》课程实验教学大纲.docx
最新发布
12-14
《数据结构》课程实验教学大纲旨在通过实际操作和理论学习相结合的方式，帮助学生深入理解和掌握数据结构的基本概念、原理和应用。课程以C++编程语言为工具，通过一系列实验项目，提升学生的编程技能和问题解决能力...
2021-2022收藏的精品资料2021-2022年个人工作计划大全3000字.doc
09-16
6. **教师专业发展**：教师需要持续提升自身的教育技术和教学理念，通过培训、研讨会等方式，更新知识结构，提高教学技能，适应教育信息化的需求。 7. **学习资源的多样性**：现代教学中，不仅限于传统的课本，还...
二叉排序树 c 版本
05-25
学习数据结构的基本程序，如有不到之处，敬请指正批评！
二叉排序树生成，并输出父节点
04-08
二叉排序树，也称为二叉查找树。可以是一颗空树，也可以是一颗具有如下特性的非空二叉树： 1. 若左子树非空，则左子树上所有节点关键字值均不大于根节点的关键字值； 2. 若右子树非空，则右子树上所有节点关键字值均不小于根节点的关键字值； 3. 左、右子树本身也是一颗二叉排序树。 　　现在给你N个关键字值各不相同的节点，要求你按顺序插入一个初始为空树的二叉排序树中，每次插入后成功后，求相应的父亲节点的关键字值，如果没有父亲节点，则输出-1
数据结构课程设计——数组链表——单词统计
01-15
数据结构课程设计文档，使用的是数组链表的数据结构，编写的是一个统计文本某些单词个数和位置的程序。
数据结构实验报告-串.docx
07-12
数据结构实验报告的主题聚焦于串（字符串）的操作，包括存储表示、基本操作和模式匹配算法。串是数据结构中一种重要的抽象数据类型，由零个或多个字符组成，可以是字母、数字或其他符号的组合。 实验的目标是让学生...
二叉排序树实现英文文章单词统计
HCE111的博客
06-21 2433
二叉排序树实现英文文章单词统计 【输入形式】 打开当目录下文件C:\Users\Administrator\Desktop\essay.txt，从中读取英文单词进行词频统计。输入单词查询个数和单词。 【输出形式】 输入一个单词按一下enter键，输出单词统计个数，输出一个单词及其出现次数，单词和其出现次数间由一个空格分隔，出现次数后无空格，直接为回车。 存储结构设计 typedef struct ...
词频统计和检索系统
littletomorrow的博客
12-10 4639
题二：基于不同策略的英文单词的词频统计和检索系统 一篇英文文章存储在一个文本文件中，分别基于线性表、二叉排序树和哈希表不同的存储结构，实现单词词频的统计和单词的检索功能。同时计算不同检索策略下的ASL，通过比较ASL的大小，对不同检索策略的时间性能做出相应的比较分析(在课程设计报告中给出)。 具体内容如下： 一篇包括标点符号的英文文章存储在文本文件InFile.txt中，假设文件中单词的个数最多不超过5000个。从该文件中读取英文单词，过滤掉所有的标点。 分别基于线性表、二叉排序树和哈希表不同的存储结构，实
数据结构 C++实现 基于不同策略的英文单词的词频统计和检索系统
qq_54388490的博客
04-10 3495
文章目录一、实验目的二、设计内容三、测试数据四、设计思路五、代码内容1、预处理2、读入文件3、顺序表类4、链表类5、线性表菜单6、二叉排序树类7、二叉排序树菜单8、开放地址哈希表类9、链地址哈希表类10、哈希表菜单11、主菜单六、总结 一、实验目的 1、掌握基于线性表、二叉排序树和散列表不同存储结构的查找算法。 2、掌握不同检索策略对应的平均查找长度（ASL）的计算方法，明确不同检索策略的时间性能的差别。 二、设计内容 一篇英文文章存储在一个文本文件中，然后分别基于线性表、二叉排序树和哈希表不同的存储结构，
数据结构实验全指南：从基础到高级
数据结构实验指导书全面涵盖了数据结构实验的设计和实施过程，旨在帮助学生深入理解和掌握各种关键的数据结构和算法。本书分为以下几个部分： 1. **实习步骤**： - **问题分析与任务定义**：这是实验设计的首要...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值