【LittleXi】算法模板总结

已于 2022-09-21 20:27:54 修改
阅读量247 收藏 2
点赞数 1
文章标签： 算法 c++ 图论 数据结构 leetcode
于 2022-08-08 21:32:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68591679/article/details/126236538
版权
本文档汇总了作者在过去六个月中整理的各种算法模板和数据结构应用，包括二叉树的中序遍历和层级遍历、回溯法、并查集、基于BFS的汇入两洋问题、分治法解决LeetCode问题、构建平衡二叉树、SPF算法以及广度优先搜索在迷宫问题中的应用。此外，还提供了自定义的输出向量和集合的友元函数，以及用于处理字符串的next数组。
摘要由CSDN通过智能技术生成

README:This article is used to share some templates and methods that I have summarized in the past six months。

模板

#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<algorithm>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<math.h>
#include<unordered_set>
#include<unordered_map>
using namespace std;

#define _for(i,a,b) for(int i=(a);i<(b);++i)
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)

template<typename T>
ostream& operator<<(ostream & os, const vector<T>&v)
{
    for (int i = 0; i < v.size(); i++)
        os << v[i] << " ";
    return os;
}

template<typename T>
ostream& operator<<(ostream& os, const set<T>& v)
{
    for (typename set<T>::iterator it = v.begin(); it != v.end(); it++)
        os << *it << " ";
    return os;
}

 struct TreeNode {
     int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode() : val(0), left(nullptr), right(nullptr) {}
      TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
      TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };
struct ListNode {
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
  };



int main() {

	system("pause");
}

中序遍历二叉树

    void midsearch(TreeNode*root ,vector<int> &vec)
    {
        if(root==NULL)
        {
            return;
        }
        midsearch(root->left,vec);
        vec.push_back(root->val);
        midsearch(root->right,vec);
    }

层级遍历二叉树

    void Leveltraverse(TreeNode* root, vector<int> &v)
    {
        TreeNode* p;
        if (!root)
            return;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty())
        {
            p = q.front();
            q.pop();
            v.push_back(p->val);
            if (p->left)
            {
                q.push(p->left);
            }
            if (p->right)
            {
                q.push(p->right);
            }

        }
        return;
    }

回溯

class Solution {
public:
    bool backtrack(int p,int sub, vector<int> &v, vector<int>& matchsticks)
    {
        if (p >= matchsticks.size())
            return true;
        for (int i = 0; i < 4; i++)
        {
            if (v[i] + matchsticks[p] > sub)
                continue;
            v[i] += matchsticks[p];
            if (backtrack(p+1, sub, v, matchsticks))
            {
                return true;
            }
            v[i] -= matchsticks[p];
        }
        return false;
    }
    static bool pred(int a, int b)
    {
        return a > b;
    }
    bool makesquare(vector<int>& matchsticks) {
        int len = matchsticks.size();
        int all = 0;
        for (int i = 0; i < len; i++)
        {
            all += matchsticks[i];
        }
        if (all % 4 != 0)
        {
            return false;
        }
        sort(matchsticks.begin(), matchsticks.end(),pred);
        int sub = all / 4;
        vector<int> v(4, 0);
        int p = 0;
        return backtrack(p, sub, v, matchsticks);
        
    }
};

并查集

    void init(int n)
    {
        fa[n] = n;
    }
    int find(int i)
    {
        if (fa[i] == i)
            return i;
        fa[i] = find(fa[i]);
        return fa[i];
    }
    void unionn(int x,int y)
    {
        int fa1 = find(x);
        int fa2 = find(y);
        fa[fa1] = fa2;
    }

基于BFS的汇入两洋问题

class Solution {
public:
    bool ifon(int x, int y, int m,int n)
    {
        if (x < 0 || x > m-1 || y < 0 || y > n-1)
            return false;
        else
            return true;
    }

    vector<vector<int>> pacificAtlantic(vector<vector<int>>& h) {
        int m = h.size();
        int n = h[0].size();
        int a1[250][250];
        int a2[250][250];
        int dirx[4] = { -1,1,0,0 };
        int diry[4] = { 0,0,-1,1 };
        queue<int> qx1;
        queue<int> qy1;
        queue<int> qx2;
        queue<int> qy2;

        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                a1[i][j] = 0;
                a2[i][j] = 0;
                if (i == 0 || j == 0)
                {
                    a1[i][j] = 1;
                    qx1.push(i);
                    qy1.push(j);
                }

                if (i == m - 1 || j == n - 1)
                {
                    a2[i][j] = 1;
                    qx2.push(i);
                    qy2.push(j);
                }

            }
        }

        while (!qx1.empty())
        {  for (int k = 0; k < 4; k++)
            {
                if (!ifon(qx1.front() + dirx[k],qy1.front()+diry[k], m,n)||a1[qx1.front() + dirx[k]][qy1.front() + diry[k]]==1)
                    continue;
                else
                {
                    if (h[qx1.front() + dirx[k]][qy1.front() + diry[k]] >= h[qx1.front()][qy1.front()])
                    {
                        qx1.push(qx1.front() + dirx[k]);
                        qy1.push(qy1.front() + diry[k]);
                        a1[qx1.front() + dirx[k]][qy1.front() + diry[k]] = 1;
                    }

                }
            }
        qx1.pop();
        qy1.pop();
        }

        while (!qx2.empty())
        {
            for (int k = 0; k < 4; k++)
            {
                if (!ifon(qx2.front() + dirx[k], qy2.front() + diry[k], m,n)||a2[qx2.front() + dirx[k]][qy2.front() + diry[k]]==1)
                    continue;
                else
                {
                    if (h[qx2.front() + dirx[k]][qy2.front() + diry[k]] >= h[qx2.front()][qy2.front()])
                    {
                        qx2.push(qx2.front() + dirx[k]);
                        qy2.push(qy2.front() + diry[k]);
                        a2[qx2.front() + dirx[k]][qy2.front() + diry[k]] = 1;
                    }

                }
            }
            qx2.pop();
            qy2.pop();
        }
        vector<vector<int>> vec;
        vector<int> v;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (a1[i][j] ==1&&a2[i][j]==1)
                {
                    v.push_back(i);
                    v.push_back(j);
                    vec.push_back(v);
                    v.clear();
                }
            }
        }
        return vec;
    }
};

分治例题leet241

class Solution {
public:
    vector<int> diffWaysToCompute(string str) {
        int len = str.size();
        vector<int> ans;
        for (int i = 0; i < len; i++)
        {
            if (str[i] == '+' || str[i] == '*' || str[i] == '-')
            {
                vector<int> ans1 = diffWaysToCompute(str.substr(0, i));
                vector<int> ans2 = diffWaysToCompute(str.substr(i + 1));
                for (int val1 : ans1)
                {
                    for (int val2 : ans2)
                    {
                        if (str[i] == '-')
                            ans.push_back(val1 - val2);
                        if (str[i] == '+')
                            ans.push_back(val1 + val2);
                        if (str[i] == '*')
                            ans.push_back(val1 * val2);
                    }
                }
            }
        }
        if (ans.empty())
            ans.push_back(stoi(str));
        return ans;
    }
};

建立平衡二叉树

    TreeNode* BuildValTree(vector<int>& v, int l, int r)
    {
        if (l > r)
            return NULL;
        int m = (l + r) / 2;
        TreeNode* root = new TreeNode(v[m]);
        root->left = BuildValTree(v, l, m - 1);
        root->right = BuildValTree(v, m + 1, r);
        return root;
    }

SPF广度优先搜索迷宫问题

#include<iostream>
#include<string>
#include<vector>
#include<queue>
#include<cstdlib>
using namespace std;

class point
{
public:
	int x;
	int y;
	int step;
};

//初始化地图
void create_map(int arr[][100], int temparr[][100], int x_num,int y_num)
{
	for (int i = 0; i < 100; i++)
	{
		for (int j = 0; j < 100; j++)
		{
			arr[i][j] = 0;
			temparr[i][j] = 0;
		}
	}

	for (int i = 1; i <= x_num; i++)
	{
		for (int j = 1; j <= y_num; j++)
		{
			//1为路，2为墙
			cin>>arr[i][j];
		}
	}

}
/*
测试代码
5 4
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1
4 3
*/

int main() {
	int arr[100][100],x_num,y_num,star_x,star_y,px,py;
	int temparr[100][100];
	int move_x[4] = { 0,0,-1,1 };
	int move_y[4] = { 1,-1,0,0 };
	queue<point> que;
	point po;
	cin >> x_num >> y_num;
	create_map(arr,temparr, x_num, y_num);
	cin >> star_x >> star_y;
	cin >> px >> py;
	po.x = star_x;
	po.y = star_y;
	temparr[star_x][star_y] = 2;
	po.step = 0;
	que.push(po);
	int flag = 0;
	int re = 0;
	while (que.empty() == 0)
	{
		flag = 0;
		int x = que.front().x, y = que.front().y;
		for (int i = 0; i < 4; i++)
		{
			if (arr[x + move_x[i]][y + move_y[i]] == 1 && temparr[x + move_x[i]][y + move_y[i]] == 0)
			{
				point temppo;
				temppo.x = x + move_x[i];
				temppo.y = y + move_y[i];
				temppo.step = que.front().step+1;
				if (temppo.x == px && temppo.y == py)
				{
					re = temppo.step;
					break;
				}
				que.push(temppo);
				temparr[x + move_x[i]][y + move_y[i]] = 2;
				flag = 1;
			}
		}
		if (re != 0)
			break;
			que.pop();
	}
	cout << re << endl;
	system("pause");
}

Point

struct Point
{
    int x, y;
    Point(int x = 0,int y=0):x(x),y(y){}
    Point& operator=(Point& p)  {x = p.x; y = p.y; return *this; }
};
typedef Point Vector;


Vector operator+(const Vector& A, const Vector& B)
{
    return Vector(A.x + B.x, A.y + B.y);
}

Vector operator-(const Vector& A, const Vector& B)
{
    return Vector(A.x - B.x, A.y - B.y);
}

Vector operator-(const Vector& A, int p)
{
    return Vector(A.x*p, A.y*p);
}

bool operator==(const Vector& a, const Vector& b)
{
    return a.x == b.x && a.y == b.y;
}

bool operator<(const Point& p1, const Point& p2)
{
    return p1.x < p2.x || (p1.x == p2.x && p1.y < p2.y);
}

istream& operator>>(istream& is, Point& p)
{
    return is >> p.x >> p.y;
}

next数组求法

#include<iostream>
#include<string>
#include<vector>
using namespace std;

void getnext(int next[], string str)
{
	int j = 0;
	next[0] = 0;
	for (int i = 1; i < str.size(); i++)
	{
		while (j > 0 && str[i] != str[j])
			j = next[j - 1];
		if (str[i] == str[j])
			j++;
		next[i] = j;
	}
}

int main() {
	string str;
	cin >> str;
	int* arr = new int[str.size()];
	getnext(arr, str);
	for (int i = 0; i < str.size(); i++)
	{
		cout << arr[i] << " ";
	}
	system("pause");
}

cout_vector_set

template<typename T>
ostream& operator<<(ostream & os, const vector<T>&v)
{
    for (int i = 0; i < v.size(); i++)
        os << v[i] << " ";
    return os;
}

template<typename T>
ostream& operator<<(ostream& os, const set<T>& v)
{
    for (typename set<T>::iterator it = v.begin(); it != v.end(); it++)
        os << *it << " ";
    return os;
}
Little Xi
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【LittleXi】排序算法
qq_68591679的博客
11-02 251
【LittleXi】排序算法
【LittleXi】CCPC2023 深圳站 总结
qq_68591679的博客
11-21 541
【LittleXi】CCPC2023 深圳站 总结
【LittleXi】规划兼职工作
qq_68591679的博客
10-22 983
【LittleXi】规划兼职工作
【LittleXi】字典树
qq_68591679的博客
11-09 246
【LittleXi】字典树
【LittleXi】快速排序
qq_68591679的博客
03-06 122
【LittleXi】快速排序
【LittleXi】计数质数
qq_68591679的博客
10-17 151
【LittleXi】计数质数
【LittleXi】手搓归并排序
qq_68591679的博客
10-13 156
【LittleXi】手搓归并排序
【LittleXi】2023 ICPC ECfinal 出线 官方数据 民间预测
qq_68591679的博客
12-13 1534
【LittleXi】2023 ICPC ECfinal 出线 官方数据 民间预测
【LittleXi】binary bomb(二进制炸弹)
qq_68591679的博客
10-16 603
【LittleXi】binary bomb(二进制炸弹)
P1145 约瑟夫
zty20120913的博客
08-06 418
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 933
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
m0_73924943的博客
08-08 246
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 572
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 187
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
数据结构之八大排序（下）
我要学编程的博客
08-03 1491
快速排序及其优化 归并排序 计数排序
备战秋招60天算法挑战，Day13
溜达虎的博客
08-06 761
在我们刷题的时候，适当的借助现有的数据结构往往会起到事半功倍的效果，今天我们讨论一下栈的使用。栈的特点是先进后出，利用栈的这个特点可以巧妙的解决很多问题，借助下面这道题我们进一步来体会一下栈的妙用。给定一个只包括 ，，，，， 的字符串 ，判断字符串是否有效。有效字符串需满足：举个例子： 视频题解 有效的括号 思路来源 思路来源 思路解析 首先要理解题意，什么才是题目中描述的有效括号，比如, 如下图，把同类型的括号单独按顺序拆出来，每种类型的括号都是能闭合的，但是并不是合法的。因为最先和闭合的是，违背了
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 875
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
补录:day023-回溯法
最新发布
m0_62956971的博客
08-10 736
思路: 和上一道题很像，主要就是和组合二大体思路的去重，树层去重和树枝去重，通过一个used数组来记录是否使用过这个数字，当当前的值与前一个值相等时，并且前一个值为FALSE，代表是树层去重，无需遍历当前的树枝了，因为前面的树枝遍历已经包含了这个的树枝遍历，还需要注意的一点是，因为子集是找出所以的组合并记录，所以要在回溯函数开头将一维数组存到二维数组中。思路:组合题目二，这个题目与组合一的区别在于，本题目中的candidates的每个元素只能使用一次，而且本题中的candidate数组中会有重复的元素。
用霍夫变换算法来识别图像中圆形的轮廓cv::HoughCircles
追赶时代的博客
08-06 414
霍夫变换 圆形轮廓检测 cv::HoughCircles
【littlexi】操作系统
12-05
操作系统是计算机系统中的一个重要组成部分，它是计算机硬件与应用软件之间的接口，负责管理和协调计算机系统中的各种资源，为用户和其他软件提供服务。操作系统的主要功能包括进程管理、内存管理、文件系统管理、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值