数据结构实验期末押题卷2

1.链表：输出倒数第k个节点

#include<iostream>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
/*押题第一道，输出链表倒数第k个节点，样例输入：1 2 3 0   2样例输出：2
typedef struct node
{
	int data;
	node* next;
}node;
void creat(node**head,vector<int>& s,int& i)
{
	if (i==s.size())
	{
		return ;
	}
	node* point = new node;
	point->data = s[i];
	point->next = nullptr;
	i++;
	if (*head == nullptr)
	{
		*head = point;
	}
	else
	{
		node* point1 = *head;
		while (point1->next)
		{
			point1 = point1->next;
		}
		point1->next = point;
	}
	creat(head, s, i);
}
void judge(node* head, int k)
{
	node* fast = head;
	node* slow = head;
	for (int i = 0; i < k; i++)
	{
		fast = fast->next;
	}
	while (fast)
	{
		slow = slow->next;
		fast = fast->next;
	}
	cout << slow->data;
}

int main()
{
	vector<int>s;
	while (1)
	{
		int t;
		cin >> t;
		if (t == 0)
		{
			break;
		}
		s.push_back(t);
	}
	int k;
	cin >> k;
	node* head = nullptr;
	int i = 0;
	creat(&head, s, i);
	judge(head, k);
	return 0;
}

2.二叉树：层序遍历

押题二：二叉树的层序遍历,已知前序遍历序列AB#D##CE###
typedef struct tree
{
	char data;
	tree* left;
	tree* right;
}tree;
tree* creat(string s, int& i)
{
	if (s[i] == '#' || i >= s.size())
	{
		i++;
		return nullptr;
	}
	tree* point = new tree;
	point->data = s[i++];
	point->left = creat(s, i);
	point->right = creat(s, i);
	return point;
}
void print1(tree* point)
{
	if (point == nullptr)
	{
		return;
	}
	cout << point->data;
	print1(point->left);
	print1(point->right);
}
void print2(tree* root)
{
	queue<tree*>q;
	vector<vector<char>>res;
	if (root)
	{
		q.push(root);
	}
	while (!q.empty())
	{
		int n = q.size();
		res.push_back(vector<char>());
		for (int i = 0; i < n; i++)
		{
			tree* point = q.front();
			q.pop();
			res.back().push_back(point->data);
			if (point->left)
			{
				q.push(point->left);
			}
			if (point->right)
			{
				q.push(point->right);
			}
		}
	}
	for (vector<char>i : res)
	{
		for (char t : i)
		{
			cout << t;
		}
}
	cout << endl;
}
int main()
{
	string s = "AB#D##CE###";
	int i = 0;
	tree* root = nullptr;
	root=creat(s, i);
	print1(root);
	cout << endl;
	print2(root);
}*/

3.哈夫曼树与哈夫曼编码

//押题三：根据给定信息创建哈夫曼树，给出每个字符的哈夫曼编码和字符串总体的哈夫曼编码，然后给定一段哈夫曼编码，将它翻译为字符串
typedef struct node
{
    int weight;
    int parent, lc, rc;
    int flag;
} huff;
void select(node v[], int n, int& s1, int& s2)
{
    int min = -1;
    for (int i = 0; i < n; i++)
    {
        if (v[i].parent == 0)
        {
            min = i;
            break;
        }
    }
    for (int i = min + 1; i < n; i++)
    {
        if (v[i].weight < v[min].weight && v[i].parent == 0)
        {
            min = i;
        }
    }
    s1 = min;
    for (int i = 0; i < n; i++)
    {
        if (v[i].parent == 0 && i != s1)
        {
            min = i;
            break;
        }
    }
    for (int i = min + 1; i < n; i++)
    {
        if (v[i].weight < v[min].weight && v[i].parent == 0 && i != s1)
        {
            min = i;
        }
    }
    s2 = min;
}
void build_huff(int n, huff v[], int len)
{
    int s1, s2;
    for (int i = n; i < len; i++)
    {
        select(v, i, s1, s2);

        v[s1].parent = i;
        v[s2].parent = i;
        v[i].lc = s1;
        v[i].rc = s2;
        v[i].weight = v[s1].weight + v[s2].weight;
    }
}
void fun1(huff v[], int n, char c[], int i)
{
    stack<char> s;
    int j = v[i].parent;
    while (j)
    {
        if (v[j].lc == i)
            s.push('0');
        else if (v[j].rc == i)
            s.push('1');
        i = j;
        j = v[j].parent;
    }
    int k = 0;
    while (!s.empty())
    {
        c[k++] = s.top();
        s.pop();
    }
    c[k] = '\0';
}
void fun2(int n, huff v[], string s)
{
    n = (n - 1) * 2;
    int i = 0;
    while (i < s.size())
    {
        int cur = n;
        while (v[cur].flag)
        {
            if (s[i] == '0')
            {
                cur = v[cur].lc;
            }
            else if (s[i] == '1')
            {
                cur = v[cur].rc;
            }
            i++;

        }
        char a = 'a' + cur;
        cout << a;
    }
}
int main()
{
    int n;
    cin >> n;
    huff v[200];
    for (int i = 0; i < n; i++)
    {
        cin >> v[i].weight;
        v[i].parent = v[i].lc = v[i].rc = 0;
        v[i].flag = 0;
    }
    for (int i = n; i < 2 * n - 1; i++)
    {
        v[i].parent = v[i].lc = v[i].rc = 0;
        v[i].flag = 1;
    }
    build_huff(n, v, 2 * n - 1);
    cout << endl;
    string s1;
    string s2;
    cin >> s1 >> s2;
    char c[60];
    for (int i = 0; i < n; i++)
    {
        fun1(v, n, c, i);
        cout << c << endl;
    }
    cout << endl;
    for (int i = 0; i < s1.size(); i++)
    {
        int j = s1[i] - 'a';
        fun1(v, n, c, j);
        cout << c;
    }
    cout << endl;
    fun2(n, v, s2);
}

4.图的拓扑排序

typedef struct node
{
    int data;
    node* next;
}node;
typedef struct grap
{
    int in;
    int data;
    node* edge;
    int flag;
}grap;
grap G[50];
int res[50];
void tube(int limit)
{
    stack <grap*>st;
    int count = 0;
    for (int i = 0; i < limit; i++)
    {
        if (G[i].in == 0)
        {
            st.push(&G[i]);
            G[i].flag = 0;
        }
    }
    while (!st.empty())
    {
        grap* pos = st.top();
        st.pop();
        count++;
        res[count] = pos->data;
        node* p = pos->edge;
        while (p)
        {
            int num = p->data;
            G[num].in--;
            p = p->next;
        }
        for (int i = 0; i < limit; i++)
        {
            if (G[i].flag == 1 && G[i].in == 0)
            {
                st.push(&G[i]);
                G[i].flag = 0;
            }
        }

    }
    if (count == limit)
    {
        for (int i = 0; i <= count; i++)
        {
            cout << res[i] << ' ';
        }
    }
}
int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        G[i].in = 0;
        G[i].edge = nullptr;
        G[i].data = i;
        G[i].flag = 1;
    }
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int num1;
            cin >> num1;
            if (num1 == 0)
            {
                continue;
            }
            else
            {
                node* tmp = new node;
                tmp->data = j;
                tmp->next = nullptr;
                node* pos = G[i].edge;
                while (1)
                {
                    if (pos == nullptr)
                    {
                        break;
                    }
                    if (pos->next == nullptr)
                    {
                        break;
                    }
                    pos = pos->next;
                }
                if (pos == nullptr)
                {
                    G[i].edge = pos;
                }
                else
                {
                    pos->next = tmp;
                }
                G[i].in++;
            }
        }
    }
    tube(n);
    return 0;
}