常见面试算法总结

最新推荐文章于 2023-05-25 09:00:00 发布
最新推荐文章于 2023-05-25 09:00:00 发布
阅读量255 收藏 1
点赞数 2
分类专栏： leetcode 文章标签： 算法 面试 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Frankiehp/article/details/123059165
版权

快排

时间复杂度 O（n*log(n)）

空间复杂度 O（1）

#pragma once
#include <vector>
using namespace std;

static void exchnage_number(vector<int> &nums, int x, int y) {
	int tmp = nums[x];
	nums[x] = nums[y];
	nums[y] = tmp;
}

static int partition(vector<int> &nums, int begin, int end) {
	//随机一个元素，避免最差情况 1，2，3，4
	int x = begin + rand() % (end - begin + 1);
	exchnage_number(nums, x, end);
	//p1 始终指向第一个小于x的位置初始化为 -1
	//p2 用于遍历
	int p1 = begin - 1, p2 = begin;
	while (p2 < end)
	{
		if (nums[p2] < nums[end]) {//一旦发小了就让P1+1的位置为这个数字
			p1++;
			exchnage_number(nums, p1, p2);//原先p1 + 1 的位置一定大于x
		}
		p2++;
	}

	p1++; //p1此时为第一个大于等于x的位置
	exchnage_number(nums, p1, end);
	return p1;
}

void quick_sort(vector<int> &nums, int begin, int end) {
	if (begin < end) {
		int pos = partition(nums, begin, end);
		quick_sort(nums, begin, pos - 1);
		quick_sort(nums, pos + 1, end);
	}
}

归并

时间复杂度 O（n*log(n)）

空间复杂度 O（n）

static void merge_vec(vector<int> &nums, int p1, int p2, int len) {
	int cur = 0;
	int i = p1, j = p2;
	vector<int> tmpVec(len * 2);
	//j不能越界
	while (i < p1 + len && j < p2 + len && j < nums.size()) {
		tmpVec[cur++] = nums[i] < nums[j] ? nums[i++] : nums[j++];
	}

	while (i < p1 + len) {
		tmpVec[cur++] = nums[i++];
	}

	while (j < p2 + len && j < nums.size()) {
		tmpVec[cur++] = nums[j++];
	}

	for (int k = 0; k < cur; ++k) {
		nums[p1++] = tmpVec[k];
	}
}

void merge_sort(vector<int> &nums) {
	int len = 1;
	while (len < nums.size()) {
		int i = 0;
		while (i < nums.size()) {
			int fir = i;
			int sec = i + len;
			if (sec < nums.size()) {
				merge_vec(nums, fir, sec, len);
			}
			i += 2 * len;
		}
		len *= 2;
	}
}

KMP

时间复杂度 O（n + m）

空间复杂度 O（n）

aa b aa
前缀aa 和 后最aa 相等那么我们直接判断 aa 后面的下一个字符

int KMP(string haystack, string needle) {
	if (needle.empty()) {
		return 0;
	}
	//0 意味着你需要从第一个位置开始判断了
	vector<int> pre(needle.size(), 0);
	/*
	* 根据模式串来构建前缀表
	*/
	for (int i = 1, j = 0; i < needle.size(); ++i) {
		while (j > 0 && needle[j] != needle[i]) {
			//如果当前失败了 前缀数组指引我们应该从哪一个位置开始判断
			j = pre[j - 1];
		}

		if (needle[j] == needle[i]) {
			j++;
		}
		//needle[i] 和 needle[i] 相等，所以前缀表的第i个位置指向 j + 1
		//就是该位置的后一个位置期望是当前前缀的j + 1位置
		pre[i] = j;
	}

	for (int i = 0, p = 0; i < haystack.size(); i++) {
		while (p > 0 && haystack[i] != needle[p]) {
			//因为相对的P位置已经匹配不上
			//查询前缀表 我们当前位置最快可以和谁比较
			p = pre[p - 1];
		}

		if (haystack[i] == needle[p]) {
			p++;
		}
		//已经等于模式串的长度了，可以结束了
		if (p == needle.size()) {
			return i - needle.size() + 1;
		}
	}

	return -1;
}

并查集

	int findFather(vector<int> &father, int i) {
		if (father[i] != i) {
			father[i] = findFather(father, father[i]);
		}

		return father[i];
	}

	bool uion(vector<int> &father, int i, int j) {
		int fatherI = findFather(father, i);
		int fatherJ = findFather(father, j);

		if (fatherI != fatherJ) {
			father[fatherI] = fatherJ;
			return true;
		}

		return false;
	}
//use....................
	for (int i = 0; i < n; ++i) {
		for (int j = i + 1; j < n; ++j) {
			if (graph[i][j] == 1 && uion(father, i, j))
				ret--;
		}
	}

最大堆 和 最小堆

struct AA {
	int id;	

	bool operator< (const AA &a) const {
		return id < a.id;
	}
	bool operator> (const AA &a) const {
		return id > a.id;
	}

};

//less -> 最大堆；  greater -> 最小堆
	priority_queue<AA, vector<AA>, greater<AA>> mQ;

/ 最新
/ 用法
/ 想要小的在前就用大于号，比如按字母顺序输出，就要用大于号
/

	auto cmp = [](const pair<string, int> & x, const pair<string, int> & y) {
		return x.second == y.second ? x.first > y.first : x.second < y.second;
	};
	priority_queue<pair<string, int>, vector<pair<string, int>>, decltype(cmp) > q(cmp);

STL堆——通过map 找第一个大于x的元素

	map<int, int>::iterator it, p1, p2;
	//大于等于 x 的第一个元素
	p1 = mp.lower_bound(3);
	//大于 x 的第一个元素
	p2 = mp.upper_bound(3);

String 使用

	string s1 = "01234";
	auto s2 = s1.substr(1, 1); // "1"
	s1 = s1.erase(3);	//"012"
	s1.append(2, '#'); //"012##"

链表常用操作

	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) {}
		
	};
	/** ---------------- 反转链表 ---------------------**/
	ListNode* reverseList(ListNode* head) {
		ListNode *pre = NULL, *cur = head;
		while (cur != NULL) {
			ListNode *next = cur->next;
			cur->next = pre;
			pre = cur;
			cur = next;
		}

		return pre;
	}
	/** ---------------- 获取链表中位数 ---------------------**/
		//偶数时正好 奇书时前半段多一个
	ListNode* getMidList(ListNode* head) {
		ListNode dummy;
		dummy.next = head;

		ListNode *fast = &dummy, *slow = &dummy;
		while (fast != NULL && fast->next != NULL) {
			slow = slow->next;
			fast = fast->next;
			if (fast->next != NULL)
				fast = fast->next;
		}
		return slow->next;
	}

组合问题

整体思路都是围绕每一个位置的元素是选还是不选

	void serchSubsets(vector<vector<int>> &rets, vector<int> &cache, vector<int>& nums, int p) {
		if (p >= nums.size()) {
			rets.emplace_back(cache);
			return;
		}
		//不要
        serchSubsets(rets, cache, nums, p + 1);
		//要
		cache.push_back(nums[p]);
		serchSubsets(rets, cache, nums, p + 1);
		cache.pop_back();
	}
	/ 过滤重复元素 / 
	void dfs(vector<vector<int>> &rets, vector<int> &cache, vector<int>& candidates, int target, int p) {
		if (target == 0) {
			rets.emplace_back(cache);
		} else if (target > 0 && p < candidates.size()) {
		

			cache.push_back(candidates[p]);
			dfs(rets, cache, candidates, target - candidates[p], p + 1);
			cache.pop_back();

            dfs(rets, cache, candidates, target, getNext(candidates, p));
		}
	}

	int getNext(vector<int>& candidates, int index) {
		int next = index + 1;
		while (next < candidates.size() && candidates[index] == candidates[next]) {
			next++;
		}

		return next;
	}

排列问题

不含重复元素，我最早的构想，拿标记 递归 回溯
	#define USED 100

	void dfs(vector<vector<int>> &rets, vector<int> &cache, vector<int>& nums) {
		if (cache.size() == nums.size()) {
			rets.emplace_back(cache);
		}
		else {
			for (int i = 0; i < nums.size(); ++i) {
				if (USED != nums[i]) {
					cache.push_back(nums[i]);
					nums[i] = USED;
					dfs(rets, cache, nums);
					nums[i] = cache.back();
					cache.pop_back();
				}
			}
		}
	}

	vector<vector<int>> permute(vector<int>& nums) {
		vector<vector<int>> rets;
		vector<int> cache;

		dfs(rets, cache, nums);

		return rets;
	}
版本2
	void search(vector<vector<int>> &rets, vector<int>& nums, int i) {
		if (i == nums.size() - 1) {
			rets.emplace_back(nums);
		}
		else {
			for (int j = i; j < nums.size(); ++j) {
				int tmp = nums[j]; nums[j] = nums[i]; nums[i] = tmp;
				search(rets, nums, i + 1);
                tmp = nums[j]; nums[j] = nums[i]; nums[i] = tmp;
			}
		}
	}

	vector<vector<int>> permute(vector<int>& nums) {
		vector<vector<int>> rets;
		search(rets, nums, 0);

		return rets;
	}
包含重复元素

核心思想，如果排序后和前一个相等，且前一个已经推出搜索，我们直接跳过，因为会做重复的工作


	void dfs(vector<vector<int>> &rets, vector<int> &cache, vector<int>& nums, vector<int> &mark) {
		if (cache.size() == nums.size()) {
			rets.emplace_back(cache);
		}
		else {
			for (int i = 0; i < nums.size(); ++i) {
				if (mark[i] == 0) {
					if (i - 1 >= 0 && nums[i] == nums[i - 1] && mark[i - 1] == 0)
						continue;

					cache.push_back(nums[i]);
					mark[i] = 1;
					dfs(rets, cache, nums, mark);
					mark[i] = 0;
					cache.pop_back();
				}
			}
		}
	}

	vector<vector<int>> permuteUnique(vector<int>& nums) {
		vector<vector<int>> rets;
		vector<int> cache;
		vector<int> mark(nums.size(), 0);
		sort(nums.begin(), nums.end());
		dfs(rets, cache, nums, mark);

		return rets;
	}
版本2
	void ExChange(vector<int> &nums, int i, int j) {
		int tmp = nums[i];
		nums[i] = nums[j];
		nums[j] = tmp;
	}

	void searchPer(vector<vector<int>> &ret, vector<int>& nums, int p) {
		if (p == nums.size()) {
			ret.emplace_back(nums);
			return;
		}
		else {
			unordered_set<int> st;

			for (int i = p; i < nums.size(); ++i) {
				if (st.find(nums[i]) == st.end()) {
					st.insert(nums[i]);
					
					ExChange(nums, i, p);
					searchPer(ret, nums, p + 1);
					ExChange(nums, i, p);
				}
			}
		}
	}

	vector<vector<int>> permuteUnique(vector<int>& nums) {
		vector<vector<int>> ret;

		searchPer(ret, nums, 0);

		return ret;
	}

前缀树

每一步的时间复杂度都是 n（单词长度）

	struct Node {
		vector<Node*> chirds;
		bool isEnd;
		Node() :chirds(vector<Node*>(26, NULL)), isEnd(false) {
		};
	};

	void insertToTree(Node* root, const string& str) {
		Node* p = root;
		for (char c : str) {
			if (p->chirds[c - 'a'] == NULL) {
				p->chirds[c - 'a'] = new Node();
			}
			p = p->chirds[c - 'a'];
		}

		p->isEnd = true;
	}

	string findPre(Node* root, string &word) {
		string ret = "";
		Node* p = root;
		for (char c : word) {
			if (p->chirds[c - 'a'] == NULL)
				break;

			p = p->chirds[c - 'a'];
			ret.append(1, c);

			if (p->isEnd)
				break;
		}

		return p->isEnd ? ret : "";
	}

二分

右收敛 那么左可以相等
左收敛 那么右可以相等
根据题意

	int peakIndexInMountainArray(vector<int>& arr) {
		int i = 0, j = arr.size() - 1;

		while (i < j) {
			int mid = j - (j - i) / 2; 
			if (arr[mid] > arr[mid - 1]) {
				i = mid;
			}
			else {
				j = mid - 1;
			}
		}
		return i;
	}

滑动窗口

1.初始化 i = 0 ，j =0
2.j 向后扩展，记录满足条件的元素
3 i 弹出不满足的窗口前部
4. 窗口大小为 j - i + 1

	 int lengthOfLongestSubstringKDistinct(string s, int k) {
		 unordered_map<char, int> table;
		 int count = 0;

		 int ret = 0;

		 for (int i = 0, j = 0; j < s.size(); ++j) {
			 table[s[j]]++;
			 if (table[s[j]] == 1) {
				 count++;
			 }
		 
			 while (count > k) {
				 
				 table[s[i]]--;
				 if (table[s[i]] == 0) {
					 count--;
				 }
				 i++;
			 }

			 ret = max(ret, j - i + 1);
		 }

		 return ret;
	 }

水塘抽样

在这里插入图片描述

	int pick(int target) {
		int ans;
		for (int i = 0, cnt = 0; i < nums.size(); ++i) {
			if (nums[i] == target) {
				++cnt; // 第 cnt 次遇到 target
				if (rand() % cnt == 0) {
					ans = i;
				}
			}
		}
		return ans;
	}

除法不要比大小

6076. 表示一个折线图的最少线段数

本来我是用的是除法，但是一直ac不了，改成乘法后AC

	int minimumLines(vector<vector<int>>& stockPrices) {
		if (stockPrices.size() < 2)
			return 0;

		sort(stockPrices.begin(), stockPrices.end());

		long y = stockPrices[1][1] - stockPrices[0][1];
		long x = stockPrices[1][0] - stockPrices[0][0];

		int ret = 1;

		for (int i = 2; i < stockPrices.size(); ++i) {
			long _y = stockPrices[i][1] - stockPrices[i - 1][1];
			long _x = stockPrices[i][0] - stockPrices[i - 1][0];

			if (_x * y != _y * x) {
				y = _y;
				x = _x;
				ret++;
			}
		}

		return ret;
	}

最小栈

最小栈确定边界

TODO

前缀和

TODO

Frankiehp
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机常见算法面试题
10-13
各大名企常见面试题，在网上搜集整理的，很不错的资源。希望要去面试的人下下来看看
总结----20个最常见的算法面试问题
热门推荐
Gassuih的博客
03-16 2万+
在互联网面试的过程中，有一个环节是逃不掉的，就是算法面试。一般，面试官出的面试题都是从题库里抽出来的，很少有自己出新题的（当然，算法笔试过程除外）。所以，只要我们刷题刷的足够多，就总有概率遇到原题。当然，我们也可以押题，毕竟，一些高频率的题目总是有代表性的。 本文列举了20个在计算机面试过程中经常被问到的算法题，排名不分前后，这些题目也只是代表我自己在面试过程中的体会，所以有些好题目没有加入进来也请轻喷，仅供参考。 方法 前缀和 双指针法 滑动窗口 广度、深度优先搜索 回溯法 二分法 动态规划 20个常
面试10大算法汇总+常见题目解答
wuhua_amazing的专栏
12-16 3347
面试10大算法汇总＋常见题目解答 最近更新： 2013年12月15日 持续更新… 英文版的面试10大算法汇总日最高访问量已高达4,318次。这说明总结程序员面试算法有实际意义，比读算法书更有效。下面是中文版的10大算法汇总＋有代表性的题目汇总。这些概念是专门为面试准备的，因为日常编程中我们很少会自己去写一个链表或者做一个图，也不会
计算机面试常见题目-算法
谅至的博客
05-11 2562
面试问题之软件工程题 1.软件重用？ 同一个函数重复用。 2.软件测试类型？ 单元，集成，黑盒，白盒。 3.软件工程步骤 需求，设计，开发，测试。 4.UML 系统流程建模工具 5软件工程的认识？ 运用工程化的方法管理软件开发。 ...
代码面试最常用的10大算法
chiman6219的博客
06-19 156
 在程序员的职业生涯中，算法亦算是一门基础课程，尤其是在面试的时候，很多公司都会让程序员编写一些算法实例，例如快速排序、二叉树查找等等。 本文总结了程序员在代码面试中最常遇到的10大算法类型，想要真正了解这些算法的原理，还需程序员们花些功夫。 1.String/...
面试常见基础算法题总结
04-29
面试中的算法题是每个IT求职者都需要准备的...以上知识点覆盖了基础的算法和数据结构，是面试中常见的题目类型。熟练掌握这些概念和技巧，对于提升面试成功率至关重要。建议通过不断刷题来加深理解和提高实际应用能力。
互联网面试常见算法总结.docx
09-09
【互联网面试常见算法总结】 在IT行业的面试中，算法题是评估候选人技术能力的重要环节，尤其是对于互联网公司的软件工程师职位。以下是一些常见的排序算法，它们在面试中经常出现，对于理解和掌握数据结构与算法至...
常见：算法面试题总结1
08-08
以下是一些常见的算法面试题及其解题思路： 1. **二元查找树转双向链表**： - 对于这个问题，我们可以采用中序遍历的方式，因为二元查找树中序遍历的结果是有序的。在遍历过程中，将前一个节点的右指针指向当前...
前端JS面试中常见的算法问题总结
01-21
学习数据结构与算法对于工程师去理解和分析问题都是有帮助的。如果将来当我们面对较为复杂的问题，这些基础知识的积累可以帮助我们更好的优化解决思路。下面罗列在前端面试中经常撞见的几个问题吧。 Q1 判断一个单词...
程序员面试必备：七种经典排序算法总结（介绍+步骤+动画+python3实现）
qq_32799165的博客
02-22 2792
一、冒泡排序 介绍 冒泡排序是排序算法中较为简单的一种，英文称为 Bubble Sort。它遍历所有的数据，每次对相邻元素进行两两比较，如果顺序和预先规定的顺序不一致，则进行位置交换；这样一次遍历会将最大或最小的数据上浮到顶端，之后再重复同样的操作，直到所有的数据有序。 如果有n个数据，那么需要的比较次数，所以当数据量很大时，冒泡算法的效率并不高。 当输入的数据是反序时，花的时间最长，当输入的数...
计算机专业保研面试复习笔记——数据结构中的重要算法
weixin_43117620的博客
10-21 2253
字符串匹配 KMP算法 判断模式串是否是主串的子串 对模式串的字符特点，求得next数组。next[i]代表如果第i位匹配失败，应该向后移动几位。时间复杂度O(m+n)，即主串长度+模式串长度。是一种空间换时间的算法。 最小生成树 普里姆算法 加点法 普里姆算法是归并顶点的算法，与边数无关，所以适用于稠密图。 算法从某一个顶点s开始，将s加入已连接顶点集合，每次迭代选择已连接定点集合和未连接定点集合中代价最小的边对应的点，加入到最小生成树中。 最小生成树 克鲁斯卡尔算法 加边法 每次寻找不连通的两个顶点间
计算机专业保研面试备考：计算机算法（必看）
乔卿的博客
07-14 2623
本文总结了计算机专业保研面试中较为常考的算法题目，也是博主当年的备考材料。如果这篇文章对你有帮助，请给博主点个赞鼓励一下吧。 排序算法 综述 评价标准 时间复杂度：比较+移动/交换，最好/最坏/平均 空间复杂度：是否原地排序 稳定性：顺序的问题 常见算法 插入排序（稳定） 通过while向前移动 最好：O(n)；最坏：O(n^2). 选择排序（不稳定） 每次选择最小的元素
计算机考试得分算法,计算机面试最常考的两个算法是什么？
weixin_35816805的博客
07-20 165
原标题：计算机面试最常考的两个算法是什么？直播课程我们一起学习精心设计的课题每周六晚上七点LIVE #3: 3/30 计算机算法面试最爱问的题目之排序算法查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有...
面试常用算法归纳
上官宏竹的专栏
11-17 3297
注意：这里需要使用一个pair记录前一个dp[i]的最长子串的始末位置，在判断s[i]与s[i-1]不等时，需要继续往前判断s[i]是否包含在前一个dp[i-1]的子串中，如果在，则当前的dp[i]需要减去dp[i-1]子串的前一部分。对于二维dp的状态转移方程，大致都会是要从左、上及左上三个方向来推导，即：dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])。对于dp[i]的定义为：以s[i]为结尾的【无重复字符的最长子串】的长度。
程序员必备10 大面试基础算法
开发者技术前线-DevolperFront
10-17 746
点击“开发者技术前线”，选择“星标????”让一部分开发者看到未来来源：博客园 链接：http://kb.cnblogs.com/page/210687/算法一：快速排序算法快速排序...
29道面试基础算法题，试试看会不会
最新发布
Android茶话会
05-25 7843
本文主要整理了一些面试常见的算法题，涵盖 数组、字符串、哈希表、链表、二叉树。
十道腾讯算法真题解析
m0_63171455的博客
03-10 1692
前言 大家好，收集了腾讯常考的十道算法题（真题）。在金三银四，希望对大家有帮助呀。 重排链表 最长递增子序列 环形链表 反转链表 最长回文子串 全排列 LRU 缓存 合并K个升序链表 无重复字符的最长子串 删除链表的倒数第 N 个结点 1. 重排链表 给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → … → Ln - 1 → Ln 复制代码 请将其重新排列后变为： L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 →
前端面试常见算法
Better_Xing的博客
03-17 3000
前端面试常见算法 文章目录前端面试常见算法1.数组去重2.数组排序2.1冒泡排序2.2 插入排序2.3 快速排序2.4 堆排序2.5 桶排序2.6 归并排序3.二叉树的遍历3.1广度优先遍历3.2深度优先遍历4.数组扁平化5.斐波那契数列 1.数组去重 //数组去重 let arr = [1, 3, 7, 5, 4, 5, 2, 1, 3]; // 方法一:Set数据结构，它类似于数组，其成员的值都是唯一的 function unique(arr) { //..
面试/工作常见算法(持续更新)
weixin_44278376的博客
06-20 645
冒泡排序;call;apply;bind实现;深拷贝;防抖
LeetCode算法总结：数据结构与字符串常见题目详解
LeetCode解题总结涵盖了广泛的算法和数据结构题目，包括但不限于数组、单链表、字符串、栈、树和排序等多种核心数据结构与问题解决方法。以下是各部分的详细知识点： 1. **数组**： - **删除重复元素**：涉及到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值