算法 —— 数据结构

已于 2023-12-15 17:00:49 修改
阅读量128 收藏
点赞数
分类专栏： 算法基础 文章标签： 算法 数据结构 c++
于 2023-11-08 23:55:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/houhuan521/article/details/134300449
版权

目录

一. 单向链表（数组模拟）模板

二. 双向链表（数组模拟）模板

三.单调栈 

 四.单调队列

五.KMP

六. trie树（又名：字典树）

七.并查集

八.堆(小堆顶) 

九. 哈希表 

 拉链法

开放寻址法

字符串前缀哈希法 

一. 单向链表（数组模拟）模板
#include<iostream>
using namespace std;

const int N = 100010;

// head 表示头节点的下标
// e[i] 表示节点 i 的值
// ne[i] 表示节点 i 的 next 指针是多少
// idx 储存当前已经用到了哪个点 
int head, e[N], ne[N], idx;

// 初始化 
void init(){
	head = -1;
	idx = 0;
}

// 将 x 插到头结点 
void add_to_head(int x){
	e[idx] = x;
	ne[idx] = head;
	head = idx;
	idx ++;	
}

// 将 x 插到下标是 k 的点后面 
void add(int k, int x){
	e[idx] = x;
	ne[idx] = ne[k];
	ne[k] = idx;
	idx ++;
}

// 将下标是 k 的点后面的点删掉 
void remove(int k){
	ne[k] = ne[ne[k]];
} 

int main(){
	
	init();
	add_to_head(1);
	add_to_head(2);
	add_to_head(3);
	add(1, 4);
	add(3, 6);
	remove(2);
	
	for (int i=head; i != -1; i = ne[i]) cout << e[i] << " "; 
	
	return 0;
}
二. 双向链表（数组模拟）模板
#include<iostream>
using namespace std;

const int N = 100010;

int n[N], l[N], r[N], idx;

// 初始化
void init(){
	// 0 表示左端点， 1 表示右端点
	r[0] = 1;
	l[1] = 0;
	idx = 2; 
}

// 在下标是 k 的右边插入 x 
void add(int k, int x){
	n[idx] = x;
	r[idx] = r[k];
	l[idx] = k;
	l[r[k]] = idx;
	r[k] = idx;
	idx ++;
}

// 删除下标是 k 的点
void remove(int k){
	r[l[k]] = r[k];
	l[r[k]] = l[k];
} 

int main(){
	
	init();
	add(0, 1);
	add(2, 2);
	add(3, 3);
	add(3, 4);
	remove(2);
	
	for (int i=r[0]; i!=1; i=r[i]) cout << n[i] << " ";
	
	return 0;
}
三.单调栈 

给一串序列：1 3 2 5 3 4；

判断每个数前面离它最近且比它小的数是多少；如果没有，输出 -1；

则会输出：-1 1 1 2 2 3。

#include<bits/stdc++.h>
using namespace std;

const int N = 100010;

int n;
int stk[N], tt;

int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> n;
	
	for (int i=0; i<n; i++){
		int x;
		cin >> x;
		while (tt && stk[tt] >= x) tt --;
		if (tt) cout << stk[tt] << " ";
		else cout << -1 << " ";
		
		stk[++ tt] = x;
	}
	
	
	return 0;
}
 四.单调队列

给一串序列：1 3 2 -1 -5 2 -3 2；

给一个特定的长度 k = 3；判断每三个数中，最小的那个数，并将其输出；

则输出：1 -1 -5 -5 -5 -3。

#include<bits/stdc++.h>
using namespace std;

const int N = 100010;

int n, k;
int a[N];
int hh, tt = -1, q[N];

int main()
{
	scanf("%d %d", &n, &k);
	for (int i=0; i<n; i++) scanf("%d", &a[i]);
	
	for (int i=0; i<n; i++){
		//判断队头是否已经滑出窗口
		if (hh <= tt && i - k + 1 > q[hh]) hh ++;
		while (hh <= tt && a[q[tt]] >= a[i]) tt --;
		q[++ tt] = i;
		if (i >= k - 1) printf("%d ", a[q[hh]]); 
	}
	
	return 0;
}
五.KMP

给一串长为 n 的字符串 p = ab;

给一串长为 m 的字符串 s = sababababa，且 m >= n；

判断 p 在 s 中出现的所有位置； 

则输出：1 3 5 7。

#include<iostream>
using namespace std;

const int N = 10010, M = 100010;

int n, m;
char p[N], s[M];
int ne[N];

int main(){
	
	cin >> n >> p + 1 >> m >> s + 1;
	
	//求next的过程
	for (int i=2, j=0; i<=n; i++){
		while (j && p[i] != p[j + 1]) j = ne[j];
		if (p[i] == p[j + 1]) j++;
		ne[i] = j;
	}
	
	//kmp 匹配过程
	for (int i=1, j=0; i<=m; i++){
		while (j && s[i] != p[j + 1]) j = ne[j];
		if (s[i] == p[j + 1]) j++;
		if (j == n){
			printf("%d ", i - n);
			j = ne[j];
		}
	} 
	
	
	return 0;
}
六. trie树（又名：字典树）

 实现对字符串的快速插入和查找。

#include <bits/stdc++.h>
using namespace std;

const int N = 100010;

int son[N][26], cnt[N], idx;	// 下标是 0 的点，即是根节点，又是空节点
char str[N];

void insert(char str[]){
	
	int p = 0;
	for (int i = 0; str[i]; i++){
		int u = str[i] - 'a';
		if (!son[p][u]) son[p][u] = ++ idx;
		p = son[p][u];
	}
	
	cnt[p] ++;
}

int query(char str[]){
	int p = 0;
	for (int i =0; str[i]; i++){
		int u = str[i] - 'a';
		if (!son[p][u]) return 0;
		p = son[p][u];
	}
	
	return cnt[p];
}

int main(){
	
	int n;
	scanf("%d", &n);
	while (n --){
		char op[2];
		scanf("%s%s", op, str);
		if (op[0] == 'I') insert(str);
		else printf("%d\n", query(str));
	}
	
	return 0;
}
七.并查集

#include <iostream>
using namespace std;

const int N = 100010;

int n, m;
int p[N];
// find 函数是最重要的部分 
int find(int x){	//返回 x 的祖宗节点 + 路径压缩 
	
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}

int main(){
	
	scanf("%d%d", &n, &m);
	
	for (int i = 1; i <= n; i++) p[i] = i;
	
	while (m --){
		char op[2];
		int a, b;
		scanf("%s%d%d", op, &a, &b);
		
		if (op[0] == 'M') p[find(a)] = find(b);
		else{
			if (find(a) == find(b)) puts("Yes");
			else puts("No");
		}
	}
	
	return 0;
}
八.堆(小堆顶) 

 

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int N = 100010;

int h[N], ph[N], hp[N], size;

void heap_swap(int a, int b)
{
	swap(ph[hp[a]], ph[hp[b]]);
	swap(hp[a], hp[b]);
	swap(h[a], h[b]);
}

void down(int u)
{
	int t = u;
	if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
	if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
	if (u != t)
	{
		heap_swap(u, t);
		down(t);
	}
}

void up(int u)
{
	while (u / 2 && h[u / 2] > h[u])
	{
		heap_swap(u / 2, u);
		u /= 2;
	}
}

int main()
{
	int n, m = 0;
	cin >> n;
	while (n--)
	{
		char op[10];
		int k, x;
		
		cin >> op;
		if (!strcmp(op, "I"))
		{
			cin >> x;
			size ++;
			m ++;
			ph[m] = size, hp[size] = m;
			h[size] = x;
			up(size);
		}
		else if (!strcmp(op, "PM")) cout << h[1];
		else if (!strcmp(op, "DM"))
		{
			heap_swap(1, size);
			size --;
			down(1);
		}
		else if (!strcmp(op, "D"))
		{
			cin >> k;
			k = ph[k];
			heap_swap(k, size);
			size --;
			down(k), up(k);
		}
		else
		{
			cin >> k >> x;
			k = ph[k];
			h[k] = x;
			down(k), up(k);
		}
	}
	
	return 0;
}
九. 哈希表 

 拉链法
#include <cstring>
#include <iostream>
using namespace std;
const int N = 100003;

int h[N], e[N], ne[N], idx;

void insert (int x) //向表中插入元素 
{
	int k = (x % N + N) % N;
	e[idx] = x;
	ne[idx] = h[k];
	h[k] = idx ++;
}

bool find (int x) //查找表中的元素 
{
	int k = (x % N + N) % N;
	for (int i = h[k]; i!=-1; i = ne[i])
		if (e[i] == x)
			return true;
	return false;
}

int main()
{
	int n;
	cin >> n;
	
	memset(h, -1, sizeof h);
	
	while (n--)
	{
		char op[2];
		int x;
		cin >> op >> x;
		
		if (*op == 'I') insert(x);
		else
		{
			if (find(x)) puts("yes");
			else puts("no"); 
		}
	}
	
	return 0;
}
开放寻址法
#include <cstring>
#include <iostream>
using namespace std;
const int N = 200003, null = 0x3f3f3f3f; // N一般开到数据范围的 2~3 倍（解决冲突） 

int h[N]; 

int find (int x) // 如果 x 在表中，返回 x 的位置；否则返回 x  应该在的位置 
{
	int k = (x % N + N) % N;
	
	while (h[k]!=null && h[k]!=x)
	{
		k ++;
		if (k == N) k = 0;
	}
	
	return k;
}

int main()
{
	int n;
	cin >> n;
	
	memset(h, 0x3f, sizeof h);
	
	while (n--)
	{
		char op[2];
		int x;
		scanf("%s%d", op, &x);
		
		int k = find (x);
		if (*op == 'I') h[k] = x;
		else
		{
			if (h[k] != null) puts("yes");
			else puts("no");
		}
	}
	for (int i=1;i<=5; i++) cout << h[i] << " ";
	
	return 0;
}
字符串前缀哈希法 
#include<iostream>
#include<cstring>
using namespace std;
typedef unsigned long long ULL; // 超出这个范围，就相当于取模操作 
const int N = 100010, P = 131; // P 是进制，经验值取 131 或 13331 的 冲突最少

int n, m;
char str[N];
ULL h[N], p[N];

ULL get(int l, int r)
{
	return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
	scanf("%d%d%s", &n, &m, str + 1);
	
	p[0] = 1;
	for (int i=1; i<=n; i++)
	{
		p[i] = p[i-1] * P;
		h[i] = h[i-1] * P + str[i];
	}
	
	while (m --)
	{
		int l1, r1, l2, r2;
		scanf ("%d%d%d%d", &l1, &r1, &l2, &r2);
		
		if (get(l1, r1) == get(l2, r2)) puts("yes");
		else puts("no");
	}
	
	return 0;
}
hh_joker
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构-算法
不正常人类研究中心
04-17 591
一个例子 计算1到100的前n项和 第一种算法 int i，sum=0,n=100; for(i=1;i<=n;i++){ { sum=sum+i; } printf("%d",sum); } 第二种算法 （（1+100）+（2+99）+…+（100+1））/2=（101*100）/2 int sum=0,n=100; sum=(1+n)*n/2; printf(%d",s...
数据结构及算法
gxz987的博客
04-06 801
数据结构与算法 一、算法概念 算法是独⽴存在的⼀种解决问题的⽅法和思想。 算法的五⼤特性：输⼊、输出、有穷性、确定性、可⾏性 1、时间复杂度 1.1 时间复杂度与“⼤O记法” “⼤O记法”用来表示算法的时间效率。 “⼤O记法”：对于单调的整数函数f，如果存在⼀个整数函数g和实常数c>0，使得对于充分⼤的n总有f(n)<=c*g(n)，就说函数g是f的⼀个渐近函数（忽略常数），记为f(n...
数据结构与算法——算法
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-04 1万+
算法是对特定问题求解的步骤的一种具体描述，算法是指令的有有限序列，其中每一条指令表示一个或是多个操作，用于解决某个问题。本文主要讲解了数据结构与算法——算法的基本概念，知识点详细。...
Java——数据结构与算法
定期分享编程干货~
04-14 4293
一.数据结构： 1.定义：数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。 2.常见类型：数组Array、栈stack、队列queue、链接LinkedList、树Tree、哈希表、堆heap、图graph 3.区别：主要有四个方面，【底层（数组、链表、树）、是否线程安全、是否有序、值是否唯一】 大多数底层都是（数组+链表） 线程安全：vector、hashTable、ConcurrentHashMap 有序：vector、LinkedList...
数据结构与算法——绪论
01解题者~博客
02-26 3542
前言：数据结构与算法是计算机科学与工程的基础，它们的相互关系和作用是程序的本质。凭借一句话获得图灵奖的Pascal之父Nicklaus Wirth把它们表示为 算法+数据结构=程序 目录：1/数据结构与算法的重要性①数据结构的定义 1/数据结构与算法的重要性 ①数据结构的定义 ...
KPM算法——数据结构|复习局|串|复杂模式匹配算法|二维数组解决KPM
小彭爬坑之旅
08-11 1326
数据结构复习局——KPM算法何为KPM——Knuth-Morris-Pratt阿斯蒂新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 何为KPM——Knuth-Morris-Pratt 命名来自算法发表人，简写为KPM。 阿
查找 算法——数据结构
06-24
本实验主要探讨了一种高效查找算法——折半查找（Binary Search），并将其与线性查找等其他查找方法进行了对比。 折半查找，也称为二分查找，是一种基于排序数组的查找算法。它的基本思想是在已知目标值与数组中...
数据结构&算法——Java.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
C语言经典算法——数据结构
08-03
图的最小生成树 利用栈来实现单链表的逆序 Bresenham高效画线算法 约瑟夫环问题 二叉树的集合操作 递归算法的应用 ...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 652
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
dp算法练习【7】
最新发布
MADAO的博客
09-08 739
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1071
动态规划
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 565
四、实验结果。
树状数组记录
volcan的博客
09-06 518
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 318
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 355
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1102
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
备战秋招60天算法挑战，Day30
溜达虎的博客
09-03 435
给你一个字符串 和一个字符串列表 作为字典。请你判断是否可以利用字典中出现的单词拼接出 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。举个例子： 视频题解 单词拆分 思路来源 思路来源 知识回顾 动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值