数据结构考前背代码：模拟卷，哈夫曼

/*#include<iostream>
using namespace std;
typedef struct biao
{
	string data;
	biao* next;
}biao;
void creat(biao* head, string x)
{
	biao* point = new biao;
	point->data = x;
	point->next = nullptr;
	if (head->next == nullptr)
	{
		head->next = point;
	}
	else
	{
		biao* point1 = head->next;
		while (point1->next)
		{
			point1 = point1->next;
		}
		point1->next = point;
	}
}
void print(biao* head)
{
	biao* point = head->next;
	while (point)
	{
		cout << point->data << ' ';
		point = point->next;
	}

}
int main()
{
	int a;
	cin >> a;
	biao* head = new biao;
	head->next = nullptr;
	for (int i = 0; i < a; i++)
	{
		string s;
		cin >> s;
		creat(head, s);
	}
	string s1;
	cin >> s1;
	biao* cur = head->next;
	biao* pre = head;
	while (cur)
	{
		if (cur->data == s1)
		{
			break;
		}
		pre = cur;
		cur = cur->next;

	}
	if (cur->data != s1)
	{
		print(head);
	}
	else
	{
		pre->next = cur->next;
		cur->next = head->next;
		head->next = cur;
		print(head);
	}
	return 0;
}
#include<iostream>
#include<vector>
using namespace std;
typedef struct tree
{
	int data;
	tree* left;
	tree* right;
}tree;
void creat(tree*& root, int a)
{
	if (root == nullptr)
	{
		root = new tree;
		root->data = a;
		root->left = nullptr;
		root->right = nullptr;
	}
	else
	{
		if (a < root->data)
		{
			creat(root->left, a);
		}
		else
		{
			creat(root->right, a);
		}
	}
}
vector<int>a;
void back(tree* root)
{
	if (root == nullptr)
	{
		return;
	}
	back(root->left);
	back(root->right);
	a.push_back(root->data);
}
int main()
{
	vector<int>s;
	int l = 0;
	while (1)
	{
		int t;
		cin >> t;
		if (t == 0)
		{
			break;
		}
		s.push_back(t);
		l++;
	}
	tree* root = nullptr;
	for (int i = 0; i < l; i++)
	{
		creat(root, s[i]);
	}
	int t;
	cin >> t;
	back(root);
	printf("%d", a[t-1]);
	return 0;
}
#include<iostream>
#include<vector>
using namespace std;
int grap[50][50];
typedef struct tree
{
	int parent;
	int weight;
	int flag;
}tree;
int getmin(tree* arr, int limit)
{
	int ret = 0;
	int minweight = 999;
	for (int i = 1; i <= limit; i++)
	{
		if (arr[i].weight < minweight&&arr[i].flag==0)
		{
			minweight = arr[i].weight;
			ret = i;
		}
	}
	return ret;
}
void plm(int limit)
{
	int sum = 0;
	tree arr[100];
	vector<int>s;
	s.push_back(1);
	for (int i = 1; i <= limit; i++)
	{
		arr[i].weight = grap[1][i];
		arr[i].flag = 0;
		arr[i].parent = 1;
	}
	arr[1].parent = 999;
	for (int i = 2; i <= limit; i++)
	{
		int min = getmin(arr, limit);
		sum += arr[min].weight;
		arr[min].flag = 1;
		s.push_back(min);
		for (int i = 2; i <= limit; i++)
		{
			if (grap[min][i] < arr[i].weight)
			{
				arr[i].weight = grap[min][i];
				arr[i].parent = min;
			}
		}
	}
	for (int i = 0; i < s.size(); i++)
	{
		cout << s[i]<<' ';
	}
	cout << endl << sum;
}
int main()
{
	int num;
	int edge;
	cin >> num >> edge;
	for (int i =1; i <= num; i++)
	{
		for (int j = 1; j <= num; j++)\
		{
			grap[i][j] = 999;
		}
	}
	for (int i = 0; i < edge; i++)
	{
		int begin;
		int end;
		int weight;
		cin >> begin >> end >> weight;
		grap[begin][end] = grap[end][begin] = weight;
	}
	plm(num);
	return 0;
}
#include<iostream>
#include<vector>
using namespace std;
void sort(vector<int>& s, int n)
{
	for (int i = 0; i < n; i++)
	{
		int end = i - 1;
		int tmp = s[i];
		while (end >= 0)
		{
			if (s[end] < tmp)
			{
				s[end + 1] = s[end];
				end--;
			}
			else
			{
				break;
			}
		}
		s[end + 1] = tmp;
	}
}
int main()
{

	vector<int>s;
	int count = 0;
	while (1)
	{
		int t;
		cin >> t;
		if (t == 0)
		{
			break;
		}
		count++;
		s.push_back(t);
	}
	sort(s, count);
	for (int t = 0; t < count; t++)
	{
		cout << s[t] << ' ';

	}
	return 0;
}*/
#include<iostream>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
typedef struct tree
{
	int parent;
	int weight;
	int left;
	int right;
}tree;
void select(tree* arr, int limit, int& m1, int& m2)
{
	m1 = -1;
	m2 = -2;
	int minweight1 = 999;
	int minweight2 = 999;
	for (int i = 0; i < limit; i++)
	{
		if (arr[i].weight < minweight1)
		{
			minweight1 = arr[i].weight;
			m1 = i;
		}
		else if (arr[i].weight < minweight2)
		{
			minweight2 = arr[i].weight;
			m2 = i;
		}
	}
}
void creat(tree* arr, int*data, int n)
{
	for (int i = 0; i < n; i++)
	{
		arr[i].parent = -1;
		arr[i].weight = data[i];
		arr[i].left = arr[i].right = -1;
	}
	int m = 2 * n - 1;
	for (int i = n; i < m; i++)
	{
		arr[i].parent = arr[i].left = arr[i].right = -1;
		arr[i].weight = -1;
	}
	for (int i = n; i < m; i++)
	{
		int m1 = 0;
		int m2 = 0;
		select(arr, i, m1, m2);
		arr[i].left = m1;
		arr[i].right = m2;
		arr[m1].parent = arr[m2].parent = i;
		arr[i].weight = arr[m1].weight + arr[m2].weight;
	}
}
void outpom(tree* arr, int limit, int pos)
{
	int num[100];
	int count = 0;
	int p = arr[pos].parent;
	while (p!= 0)
	{
		if (pos = arr[p].left)
		{
			num[count++] = 0;
		}
		if (pos = arr[p].right)
		{
			num[count++] = 1;
		}
		pos = p;
		p = arr[pos].parent;
	}
}
void inpom(tree* arr, int limit)
{
	string code;
	cin >> code;
	int pos = 0;
	int next = limit;
	while (pos < code.size())
	{
		if (code[pos] == '0')
		{
			next = arr[next].left;
		}
		else if (code[pos] == '1')
		{
			next = arr[next].right;
		}
		if (arr[next].left == -1 && arr[next].right == -1)
		{
			char c = 'a';
			c = c + next;
			cout << c;
			next = limit;
		}
		pos++;
	}
}
int main()
{
	int leave;
	cin >> leave;
	int w[100];
	int i = 0;
	for (i = 0; i < leave; i++)
	{
		cin >> w[i];
	}
	tree* arr;
	creat(arr, w, leave);
	for (int j = 0; j < leave; j++)
	{
		outpom(arr, 2 * leave - 2, j);
		cout << endl;
	}
	string s;
	cin >> s;
	for (int i = 0; i < s.size(); i++)
	{
		int t = s[i] - 97 + 1;
		outpom(arr, 2 * leave - 2, t);
	}
	cout << endl;
	inpom(arr, 2 * leave - 2);
	return 0;
}