【数据结构】跳表+Trie树

最新推荐文章于 2021-06-15 16:24:51 发布
最新推荐文章于 2021-06-15 16:24:51 发布
阅读量253 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pigpigpig64/article/details/110096158
版权

目录

问题 A: 跳表操作

题目描述

实现跳表数据结构，支持增加、查找和删除操作。为保证程序的可复现性，随机生成布尔结果的函数g()定义如下：
g() = 0 if X_t < 8; g() = 1 if X_t >= 8, for all t >= 1，
其中 X_t = (X_t-1 * a + c) % m， X_0 = 7, a=5, c=37, m=19
假定跳表的第0层存放所有元素。为决定一个不在现有跳表中且待插入的新元素a，可以上升到第h层（h初始值为0），程序反复调用g()，若g()=1，则上升一层，即++h，若g()=0则停止上升; 因此，元素a将位于0,1,…,h层。

输入

注意 ：符号//及其后为注解，不是输入/输出的内容。整数之间有1个空格分隔
48 45 45 59 89 //1）随机输入初值数据，可能存在重复（重复的元素不插入跳表）
75 48 90 //2）连续插入跳表的3个整数，若跳表中已经有相应元素，则不插入
45 59 30 //3）在2）之后，从跳表中，连续查找的3个整数，对每个待查整数，输出所在各层的严格下界
45 75 87 //4）在3) 之后，从跳表中，连续删除的3个整数

输出

48 //1+)对应输入1)，输出建立的跳表，从最高层到最底层，递增输出每层元素（每层元素不重复）
48 89
48 89
45 48 59 89
48 75 //2+)对应2)，输出插入3个新数据后的跳表
48 75 89
48 75 89
45 48 59 75 89 90
N N N N //3+)对于要查找的45，输出每层的严格下界b_i={N,N,N,N}, 满足b_i < 45, N表示无穷小
48 48 48 48 //3+)对于要查找的59，输出b_i={48,48,48,48}, 满足b_i < 59
N N N N
48 //4)删除3个整数之后的跳表。
48 89
48 89
48 59 89 90

样例输入

48 45 45 59 89
75 48 90
45 59 30
45 75 87

样例输出

48
48 89
48 89
45 48 59 89
48 75
48 75 89
48 75 89
45 48 59 75 89 90
N N N N
48 48 48 48
N N N N
48
48 89
48 89
48 59 89 90

题解
参考代码链接

#include<iostream>
#include<vector>
#define INFINITY 99999
using namespace std;

const int Max=10;

struct node
{
    int key;
    node* forward[Max];
};

class skiplist
{
public:
    node* head;
    skiplist()
    {
        head = new node();
        head->key = -1;
        node* temp = new node();
        temp->key = INFINITY;
        for (int i = 0; i < Max; i++) {
            head->forward[i] = temp;
            temp->forward[i] = NULL;
        }
    }
    bool g()
    {
        static int x = 7;
        x = (x * 5 + 37) % 19;
        return x >= 8;
    }
    int randomX()
    {
        int sum = 0;
        while (g())
            sum++;
        return sum;
    }
    void add()
    {
        vector<int> v;
        int x;
        while (cin >> x) {
            v.push_back(x);
            if (cin.get() == '\n')
                break;
        }
        for (int i = 0; i < v.size(); i++) {
            insert(v[i]);
        }
    }
    void insert(int key)
    {
        node* p = head;
        node* data[Max];
        for (int i = Max - 1; i >= 0; i--) {
            while (p->forward[i]->key < key)
                p = p->forward[i];
            data[i] = p;
        }
        if (p->forward[0]->key != key) {
            int newlevel = randomX();
            p = new node();
            p->key = key;
            for (int i = 0; i <= newlevel; i++) {
                p->forward[i] = data[i]->forward[i];
                data[i]->forward[i] = p;
            }
        }
    }
    node* search(int key)
    {
        node* data[Max];
        node* p = head;
        for (int i = Max - 1; i >= 0; i--) {
            while ((p->forward[i]->key < key))
                p = p->forward[i];
            data[i] = p;
        }
        return p;
    }

    void Search()
    {
        vector<int> v;
        int x;
        while (cin >> x) {
            v.push_back(x);
            if (cin.get() == '\n')
                break;
        }
        for (int i = 0; i < v.size(); i++) {
            Print(v[i]);
        }
    }

    void Print(int key)
    {
        node* data[Max];
        node* p = head;
        for (int i = Max - 1; i >= 0; i--) {
            while (p->forward[i]->key < key)
                p = p->forward[i];
            data[i] = p;
        }
        if (p->forward[0]->key != key) {
            cout << "N N N N" << endl;
        }
        else {
            for (int i = 0; i < 4; i++) {
                if (!i) {
                    if (data[i]->key == -1)
                        cout << 'N';
                    else cout << data[i]->key;
                }
                else {
                    if (data[i]->key == -1)
                        cout << ' ' << 'N';
                    else cout << ' ' << data[i]->key;
                }
            }
            cout << endl;
        }
    }
    void print()
    {
        for (int i = Max - 1; i >= 0; i--) {
            bool flag = true;
            for (node* p = head->forward[i]; p->key != INFINITY; p = p->forward[i]) {
                if (p == head->forward[i]) {
                    cout << p->key;
                    flag = false;
                }
                else cout << ' ' << p->key;
            }
            if (!flag)
                cout << endl;
        }
    }
    void Delete() {
        vector<int> v;
        int x;
        while (cin >> x) {
            v.push_back(x);
            if (cin.get() == '\n')
                break;
        }
        for (int i = 0; i < v.size(); i++)
            Delete2(v[i]);
    }
    void Delete2(int key) {
        node* target = search(key)->forward[0];
        if (target->key == key) {
            node* p, * q;
            int i = Max - 1;
            while (i >= 0) {
                p = q = head;
                while (p && p != target) {
                    q = p;
                    p = p->forward[i];
                }
                if (p)
                    q->forward[i] = p->forward[i];
                i--;
            }
            delete target;
        }
    }
    void test() {
        add();
        print();
        add();
        print();
        Search();
        Delete();
        print();
    }
};

int main()
{
    skiplist list;
    list.test();
    return 0;
}

问题 B: 点名

题目描述

XS中学化学竞赛组教练是一个酷爱炉石的人。他会一边搓炉石一边点名以至于有一天他连续点到了某个同学两次。校长任命你为特派探员，每天记录他的点名。校长会提供化学竞赛学生的人数和名单，而你需要告诉校长他有没有点错名。

输入

第一行一个整数n，表示班上人数。
接下来 nn 行，每行一个字符串表示其名字（互不相同，且只含小写字母，长度不超过 5050）。
第 n+2n+2 行一个整数 mm，表示教练报的名字个数。
接下来 mm 行，每行一个字符串表示教练报的名字（只含小写字母，且长度不超过50）。

输出

对于每个名字，输出一行。
如果该名字正确且是第一次出现，输出 OK ；如果该名字错误，输出 WRONG；如果该名字正确但不是第一次出现，输出 REPEAT 。

样例输入

5
a
b
c
ad
acd
3
a
a
e

样例输出

OK
REPEAT
WRONG

题解

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;


struct Node {
	char data;
	Node* next[26];
};

class TrieTree {
public:
	Node* root;
	int get_num(struct Node* t);
	void level_print(struct Node* t);
};

int main() {
	TrieTree t;
	t.root = new Node[26];
	for (int i = 0; i < 26; i++) {
		t.root[i].data = NULL;
		for (int j = 0; j < 26; j++)
			t.root[i].next[j] = NULL;
	}
	char str[10000];
	int num = 0;
	while ((str[num] = getchar()) != '\n') {
		num++;
	}
	for (int i = 0; i < num; i++) {
		string string;
		while (str[i] != ' ' && i < num) {
			string += str[i];
			i++;
		}
		struct Node* p = &t.root[string[0] - 'a'];
		p->data = string[0];
		for (int j = 1; j < string.length(); j++)
		{
			if (p->next[string[j] - 'a'] != NULL)
			{
				p = p->next[string[j] - 'a'];
				continue;
			}
			struct Node* temp = new Node;
			temp->data = string[j];
			for (int k = 0; k < 26; k++)
				temp->next[k] = NULL;
			p->next[string[j] - 'a'] = temp;
			p = p->next[string[j] - 'a'];
		}
	}
	t.level_print(t.root);
	int n;
	cin >> n;
	string s;
	for (int i = 0; i < n; i++)
	{
		cin >> s;        //输入前缀
		struct Node* temp = &t.root[s[0] - 'a'];
		for (int j = 1; j < s.length(); j++)
		{
			temp = temp->next[s[j] - 'a'];
			if (temp == NULL)
				break;
		}
		if (temp == NULL)
			cout << 0 << endl;
		else
		{
			int coun = t.get_num(temp);
			cout << coun << endl;
		}
	}
	return 0;
}

int TrieTree::get_num(Node* t)
{
	int count = 0;
	for (int i = 0; i < 26; i++)
	{
		if (t->next[i] != NULL)
		{
			count += get_num(t->next[i]);
		}
	}
	if (count == 0)
		return 1;
	else
		return count;

}

void TrieTree::level_print(Node* t)
{
	queue<struct Node*> q1;
	for (int i = 0; i < 26; i++)
	{
		if (t[i].data != '\0')
		{
			q1.push(&t[i]);
		}
	}
	while (!q1.empty()){
		struct Node* t = q1.front();
		q1.pop();
		cout << t->data;
		for (int i = 0; i < 26; i++)
		{
			if (t->next[i] != NULL)
			{
				q1.push(t->next[i]);
			}
		}
	}
	cout << endl;

}

方法二：字典树
参考代码网址

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
struct Node{
    int son[27],f,vis;
}N[500010];
int n,m,cnt=1;
char name[55];
void insert(char name[]){
    int now=1;
    for(int i=0;name[i]!='\0';i++){
        if(N[now].son[name[i]-'a']) now=N[now].son[name[i]-'a'];
        else{N[now].son[name[i]-'a']=++cnt; now=cnt;}
    }
    N[now].f=1;
}
int find(char name[]){
    int now=1;
    for(int i=0;name[i]!='\0';i++){
        if(!N[now].son[name[i]-'a']) return -1;
        else now=N[now].son[name[i]-'a'];
    }
    if(N[now].f){
        if(N[now].vis) return 0;
        else{
            N[now].vis=1;
            return 1;
        }
    }
    else return -1;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",name);
        insert(name);
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        scanf("%s",name);
        int pd=find(name);
        if(pd==-1) printf("WRONG\n");
        else if(pd==0) printf("REPEAT\n");
        else printf("OK\n");
    }
    return 0;
}

问题 C: 公共前缀

题目描述

输入一组单词，创建Trie树。输入字符串，计算以该字符串为公共前缀的单词数。
（提示：树结点有26个指针，指向单词的下一字母结点。）

输入

测试数据有多组，每组测试数据格式为：
第一行：一行单词，单词全小写字母，且单词不会重复，单词的长度不超过10
第二行：测试公共前缀字符串数量t
后跟t行，每行一个字符串

输出

每组测试数据输出格式为：
第一行：创建的Trie树的层次遍历结果
第2~t+1行：对每行字符串，输出树中以该字符串为公共前缀的单词数。

样例输入

abcd abd bcd efg hig
3
ab
bc
abcde

样例输出

abehbcficddggd
2
1
0

题解

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;


struct Node {
	char data;
	Node* next[26];
};

class TrieTree {
public:
	Node* root;
	int get_num(struct Node* t);
	void level_print(struct Node* t);
};

int main() {
	TrieTree t;
	t.root = new Node[26];
	for (int i = 0; i < 26; i++) {
		t.root[i].data = NULL;
		for (int j = 0; j < 26; j++)
			t.root[i].next[j] = NULL;
	}
	char str[10000];
	int num = 0;
	while ((str[num] = getchar()) != '\n') {
		num++;
	}
	for (int i = 0; i < num; i++) {
		string string;
		while (str[i] != ' ' && i < num) {
			string += str[i];
			i++;
		}
		struct Node* p = &t.root[string[0] - 'a'];
		p->data = string[0];
		for (int j = 1; j < string.length(); j++)
		{
			if (p->next[string[j] - 'a'] != NULL)
			{
				p = p->next[string[j] - 'a'];
				continue;
			}
			struct Node* temp = new Node;
			temp->data = string[j];
			for (int k = 0; k < 26; k++)
				temp->next[k] = NULL;
			p->next[string[j] - 'a'] = temp;
			p = p->next[string[j] - 'a'];
		}
	}
	t.level_print(t.root);
	int n;
	cin >> n;
	string s;
	for (int i = 0; i < n; i++)
	{
		cin >> s;        //输入前缀
		struct Node* temp = &t.root[s[0] - 'a'];
		for (int j = 1; j < s.length(); j++)
		{
			temp = temp->next[s[j] - 'a'];
			if (temp == NULL)
				break;
		}
		if (temp == NULL)
			cout << 0 << endl;
		else
		{
			int coun = t.get_num(temp);
			cout << coun << endl;
		}
	}
	return 0;
}

int TrieTree::get_num(Node* t)
{
	int count = 0;
	for (int i = 0; i < 26; i++)
	{
		if (t->next[i] != NULL)
		{
			count += get_num(t->next[i]);
		}
	}
	if (count == 0)
		return 1;
	else
		return count;

}

void TrieTree::level_print(Node* t)
{
	queue<struct Node*> q1;
	for (int i = 0; i < 26; i++)
	{
		if (t[i].data != '\0')
		{
			q1.push(&t[i]);
		}
	}
	while (!q1.empty()){
		struct Node* t = q1.front();
		q1.pop();
		cout << t->data;
		for (int i = 0; i < 26; i++)
		{
			if (t->next[i] != NULL)
			{
				q1.push(t->next[i]);
			}
		}
	}
	cout << endl;

}
Alex_SCY
关注
专栏目录
Java数据结构与算法源代码
02-04
a.10 个数据结构：数组，链表，栈，队列，散列表，三叉树，堆，跳表图，Trie 树。 b.10 个算法：递归，排序，二分查找，搜索，哈希算法，贪心算法，分治算法，回溯算法，动态规划，字符串匹配算法。 四。学习技巧 ...
跳表--板子题
NP_hard的博客
11-21 296
问题 A: 跳表操作 题目描述 实现跳表数据结构，支持增加、查找和删除操作。为保证程序的可复现性，随机生成布尔结果的函数g()定义如下： g() = 0 if X_t < 8; g() = 1 if X_t >= 8, for all t >= 1， 其中 X_t = (X_t-1 * a + c) % m， X_0 = 7, a=5, c=37, m=19 假定跳表的第0层存放所有元素。为决定一个不在现有跳表中且待插入的新元素a，可以上升到第h层（h初始值为0），程序反复调用g()，
mysql 跳表 b 树_红黑树、B(+)树、跳表、AVL等数据结构，应用场景及分析，以及一些英文缩写...
weixin_42575505的博客
02-18 605
转载自https://www.cnblogs.com/charlesblc/p/5987812.html在网上学习了一些材料。这一篇：https://www.zhihu.com/question/30527705AVL树:最早的平衡二叉树之一。应用相对其他数据结构比较少。windows对进程地址空间的管理用到了AVL树红黑树:平衡二叉树，广泛用在C++的STL中。map和set都是用红黑树实现的。...
trie树的数据结构_Trie数据结构实现
08-16 397
trie树的数据结构 介绍 (Introduction ) The word trie is an inflix of the word “retrieval”, because the trie can find a single word in a dictionary with only a prefix of the word. 单词trie是单词“ re trie val”的词缀，因为t...
跳表（SkipList）数据结构介绍
jameswhale的博客
03-14 776
使用场景跳表（Skiplist）是一个特殊的链表，相比一般的链表，有更高的查找效率，可比拟二叉查找树，平均期望的查找、插入、删除时间复杂度都是O(logn)，许多知名的开源软件（库）中的...
二叉树 跳表_树与跳表
weixin_29426299的博客
01-16 977
0x01、树与跳表介绍二分查找需要把元素存储在连续的内存中，查找的速度很快，但是插入、删除操作时需要保证元素有序性而移动大量元素比较耗性能。如果需要一个有二分查找的速度，又能快速添加和删除元素的数据结构，首先就是二叉树，但是二叉树最坏的情况下可能变成一个链表。于是出现了平衡二叉树，根据平衡算法不同分为AVL树(平衡二叉树)，B-Tree，B+Tree(Balance)，红黑树等，但是AVL树实现起...
计算机数据结构.zip
04-14
除了基础数据结构，还有一些更复杂的数据结构，如堆、跳表、Trie树（字典树）、B树和红黑树等。它们各自解决了特定的问题，比如堆用于优先队列，跳表用于快速随机访问，Trie树用于高效字符串查找，B树则在数据库和...
数据结构知识点PPT
02-03
这部分可能介绍了一些更高级的数据结构，如Trie树（字典树）、堆、跳表等，以及它们在特定问题中的应用。 第十/十一章：算法效率分析 这部分通常涉及时间复杂度和空间复杂度分析，以及如何通过算法优化提高效率。...
数据结构新版PPT.rar
04-08
以上只是数据结构基础知识的一部分，实际应用中还有更多高级和特定领域的数据结构，如Trie树、Splay树、跳表等。学习数据结构不仅可以提升编程能力，也是理解和设计复杂算法的基础。通过李春葆教授的《数据结构》第...
重庆邮电大学802数据结构历年真题.rar
11-20
9. **数据结构设计**：根据实际问题设计合适的数据结构，如堆（优先队列）、跳表等。 在复习过程中，考生应注重理解这些数据结构的特性，掌握它们的插入、删除、查找等基本操作，同时，要能够灵活应用这些知识解决...
Trie树_字典树(字符串排序)简介及实现
10-26
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)
后缀树的实现代码(国外一牛人写的,有注释)
10-07
相信大家都了解后缀树难弄.给一源代码就好学习了.
红黑树、B(+)树、跳表、AVL等数据结构，应用场景及分析，以及一些英文缩写
weixin_34198762的博客
10-22 720
在网上学习了一些材料。 这一篇：https://www.zhihu.com/question/30527705 AVL树:最早的平衡二叉树之一。应用相对其他数据结构比较少。windows对进程地址空间的管理用到了AVL树 红黑树:平衡二叉树，广泛用在C++的STL中。map和set都是用红黑树实现的。我们熟悉的STL的map容器底层是RBtree,当然指的不是unordered_map,后者是...
问题 C: 公共前缀
NP_hard的博客
11-22 267
问题 C: 公共前缀 题目描述 输入一组单词，创建Trie树。输入字符串，计算以该字符串为公共前缀的单词数。 （提示：树结点有26个指针，指向单词的下一字母结点。） 输入 测试数据有多组，每组测试数据格式为： 第一行：一行单词，单词全小写字母，且单词不会重复，单词的长度不超过10 第二行：测试公共前缀字符串数量t 后跟t行，每行一个字符串 输出 每组测试数据输出格式为： 第一行：创建的Trie树的层次遍历结果 第2~t+1行：对每行字符串，输出树中以该字符串为公共前缀的单词数。 样例输入 abcd abd
跳跃表，字典树（单词查找树，Trie树），后缀树，KMP算法，AC 自动机相关算法原理详细汇总
zhongwen7710的专栏
09-14 4122
第一部分：跳跃表 本文将总结一种数据结构：跳跃表。前半部分跳跃表性质和操作的介绍直接摘自《让算法的效率跳起来--浅谈“跳跃表”的相关操作及其应用》上海市华东师范大学第二附属中学 魏冉。之后将附上跳跃表的源代码，以及本人对其的了解。难免有错误之处，希望指正，共同进步。谢谢。     跳跃表（Skip List）是1987年才诞生的一种崭新的数据结构，它在进行查找、插入、删除等操作时的期望
Trie树
z-k的博客
12-18 795
题目描述 Trie树又称单词查找树，是一种树形结构，如下图所示。 它是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来节约存储空间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。  输入的一组单词，创建Trie树。输入字符串，计算以该字符串为公共前缀的单词数。 （提示：树结...
Redis 为什么用跳表而不用平衡树？
weixin_34191845的博客
10-09 3459
本文是《Redis内部数据结构详解》系列的第六篇。在本文中，我们围绕一个Redis的内部数据结构——skiplist展开讨论。 Redis里面使用skiplist是为了实现sorted set这种对外的数据结构。sorted set提供的操作非常丰富，可以满足非常多的应用场景。这也意味着，sorted set相对来说实现比较复杂。同时，skiplist这种数据结构对于很多人来说都比较陌生，因为大部...
数据结构（荣誉）实验二 跳表 Trie树
上山打老虎的博客
06-15 295
目录1. 跳表操作题目描述输入输出样例输入样例输出题解2. 点名题目描述输入输出样例输入样例输出题解3.公共前缀题目描述输入输出样例输入样例输出题解 1. 跳表操作 题目描述 实现跳表数据结构，支持增加、查找和删除操作。为保证程序的可复现性，随机生成布尔结果的函数g()定义如下： g() = 0 if XtX_tXt​ < 8; g() = 1 if XtX_tXt​ >= 8, for all t >= 1， 其中 XtX_tXt​ = (Xt−1X_{t-1}Xt−1​ * a +
BestCoder Round #92 1001 Skip the Class —— trie树 or map容器
A man can be destroyed, but not defeated.
03-17 430
题目链接：http://bestcoder.hdu.edu.cn/contests/contest_showproblem.php?cid=748&pid=1001 题解： 1.trie树 关键是如何将科目与分数进行对应，即如果将字符串与数字对应。由于之前解除了字典树，所以就想到用字典树存储单词，并为每种编上编号，之后就用这个编号与分数对应。 就个人观点而言，a[][]
Java数据结构与算法视频教程：进阶高薪必备
- B树与B+树：在数据库索引中的重要作用。 4. 动态规划与贪心算法： - 动态规划：通过实例学习动态规划的基本思想，如背包问题、最长公共子序列、最短路径等。 - 贪心算法：理解局部最优解如何导出全局最优解，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Alex_SCY

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值