收录一些常见的算法题型

常用算法

字符串

  1. s.trim():去掉字符串首尾的空格
  2. s.split("\\s+"):按照空格对字符串分割

树

前中后序遍历

 /*** 统一一下* @param root* @return*///前序public static List<Integer> preOrder(TreeNode root){List<Integer> list = new ArrayList();Stack<TreeNode> stack = new Stack();TreeNode cur = root;while(cur!=null || !stack.isEmpty()){//一直往左压入栈while(cur!=null){list.add(cur.val);stack.push(cur);cur = cur.left;}cur = stack.pop();cur = cur.right;}return list;}//中序public List<Integer> inorderTraversal(TreeNode root) {if(root == null){return new ArrayList();}List<Integer> list = new ArrayList();Stack<TreeNode> stack = new Stack();TreeNode cur = root;while(cur != null || !stack.isEmpty()){while(cur!=null){stack.push(cur);cur = cur.left;}cur = stack.pop();list.add(cur.val);cur = cur.right;}return list;}//后序遍历，非递归public static List<Integer> postOrder(TreeNode root){Stack<TreeNode> stack = new Stack<>();List<Integer> list = new ArrayList<>();TreeNode cur = root;TreeNode p = null;//用来记录上一节点while(!stack.isEmpty() || cur != null){while(cur != null){stack.push(cur);cur = cur.left;}cur = stack.peek();
//            后序遍历的过程中在遍历完左子树跟右子树cur都会回到根结点。所以当前不管是从左子树还是右子树回到根结点都不应该再操作了，应该退回上层。
//            如果是从右边再返回根结点，应该回到上层。//主要就是判断出来的是不是右子树，是的话就可以把根节点=加入到list了if(cur.right == null || cur.right == p){list.add(cur.val);stack.pop();p = cur;cur = null;}else{cur = cur.right;}}return list;
}

回溯

  • 寻找所有的组合，给的candidates中没有重复的元素，candidates中的元素可以重复取

题目链接：https://leetcode.cn/problems/combination-sum/submissions/

class Solution {private List<List<Integer>> ans;// 普通的回溯+关键的去重使用startIndexpublic List<List<Integer>> combinationSum(int[] candidates, int target) {ans = new ArrayList<>();backtracking(0,candidates,target,0,new ArrayList<>());return ans;}public void backtracking(int startIndex,int[] candidates,int target,int sum,List<Integer> path){if(sum==target){ans.add(new ArrayList<>(path));}if(sum>target){return;}for(int i=startIndex;i<candidates.length;i++){path.add(candidates[i]);backtracking(i,candidates,target,sum+candidates[i],path);path.remove(path.size()-1);}}
}
  • 组合问题：candidtes无序，candidates中元素有重复的，要求计算组合数，且candidates中同一个数只能取一次
class Solution {private List<List<Integer>> ans;public List<List<Integer>> combinationSum2(int[] candidates, int target) {ans = new ArrayList<>();Arrays.sort(candidates);backtracking(0,candidates,target,0,new ArrayList<>());return ans;}public void backtracking(int startIndex,int[] candidates,int target,int sum,List<Integer> path){if(sum==target){ans.add(new ArrayList<>(path));}if(sum>target){return;}for(int i=startIndex;i<candidates.length;i++){// 这里是i>startIndex表示每次遍历时，如果跟上一次相同就不用再次遍历if(i>startIndex&&candidates[i-1]==candidates[i]){continue;}path.add(candidates[i]);backtracking(i+1,candidates,target,sum+candidates[i],path);path.remove(path.size()-1);}}
}

二分

  • 注意要是升序或者降序，时间复杂度：O(log n)
  • 正常的二分写法
class Solution {
public:int search(vector<int>& nums, int target) {int left = 0;int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2if (nums[middle] > target) {right = middle - 1; // target 在左区间，所以[left, middle - 1]} else if (nums[middle] < target) {left = middle + 1; // target 在右区间，所以[middle + 1, right]} else { // nums[middle] == targetreturn middle; // 数组中找到目标值，直接返回下标}}// 未找到目标值return -1;}
};
  • 变形写法，寻找端点，题目链接：https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/description/
class Solution {public int[] searchRange(int[] nums, int target) {// 因为要取得O(log n)的时间复杂度，因此考虑使用二分法return new int[] {findleft(nums,target),findright(nums,target)};}// 寻找小于等于target的最大的数的下标public int findleft(int[] nums,int target){int l=0,r=nums.length-1;while(l<=r){int mid = (l+r)/2;if(nums[mid]>=target){r = mid-1;}else{l = mid+1;}}if(l>=nums.length||nums[l]!=target){return -1;}return l;}// 寻找大于等于target的最大的数的下标public int findright(int[] nums,int target){int l=0,r=nums.length-1;while(l<=r){int mid = (l+r)/2;if(nums[mid]<=target){l = mid+1;}else{r = mid-1;}}if(r<0||nums[r]!=target){return -1;}return r;}
}
  • 变形写法，部分有序：https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/

排序算法

选择排序

思路：每一轮选取未排定的部分中最小的部分交换到未排定部分的最开头，经过若干个步骤，就能排定整个数组。即：先选出最小的，再选出第 2 小的，以此类推。

import java.util.Arrays;public class Solution {// 选择排序：每一轮选择最小元素交换到未排定部分的开头public int[] sortArray(int[] nums) {int len = nums.length;// 循环不变量：[0, i) 有序，且该区间里所有元素就是最终排定的样子for (int i = 0; i < len - 1; i++) {// 选择区间 [i, len - 1] 里最小的元素的索引，交换到下标 iint minIndex = i;for (int j = i + 1; j < len; j++) {if (nums[j] < nums[minIndex]) {minIndex = j;}}swap(nums, i, minIndex);}return nums;}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;}public static void main(String[] args) {int[] nums = {5, 2, 3, 1};Solution solution = new Solution();int[] res = solution.sortArray(nums);System.out.println(Arrays.toString(res));}
}

总结：

  • 算法思想 1：贪心算法：每一次决策只看当前，当前最优，则全局最优。注意：这种思想不是任何时候都适用。

  • 算法思想 2：减治思想：外层循环每一次都能排定一个元素，问题的规模逐渐减少，直到全部解决，即「大而化小，小而化了」。运用「减治思想」很典型的算法就是大名鼎鼎的「二分查找」。

  • 优点：交换次数最少。

  • 时间复杂度：O(N^2)，这里 N 是数组的长度；
  • 空间复杂度：O(1)，使用到常数个临时变量。

插入排序

思路：每次将一个数字插入一个有序的数组里，成为一个长度更长的有序数组，有限次操作以后，数组整体有序。

public class Solution {// 插入排序：稳定排序，在接近有序的情况下，表现优异public int[] sortArray(int[] nums) {int len = nums.length;// 循环不变量：将 nums[i] 插入到区间 [0, i) 使之成为有序数组for (int i = 1; i < len; i++) {// 先暂存这个元素，然后之前元素逐个后移，留出空位int temp = nums[i];int j = i;// 注意边界 j > 0while (j > 0 && nums[j - 1] > temp) {nums[j] = nums[j - 1];j--;}nums[j] = temp;}return nums;}
}

  • 优化：「将一个数字插入一个有序的数组」这一步，可以不使用逐步交换，使用先赋值给「临时变量」，然后「适当的元素」后移，空出一个位置，最后把「临时变量」赋值给这个空位的策略（就是上面那张图的意思）。编码的时候如果不小心，可能会把数组的值修改，建议多调试；

  • 特点：「插入排序」可以提前终止内层循环（体现在 nums[j - 1] > temp 不满足时），在数组「几乎有序」的前提下，「插入排序」的时间复杂度可以达到 O(N)O(N)O(N)；

  • 由于「插入排序」在「几乎有序」的数组上表现良好，特别地，在「短数组」上的表现也很好。因为「短数组」的特点是：每个元素离它最终排定的位置都不会太远。为此，在小区间内执行排序任务的时候，可以转向使用「插入排序」。

复杂度分析：

  • 时间复杂度：O(N^2),这里 N 是数组的长度；
  • 空间复杂度：O(1)，使用到常数个临时变量。

归并排序

思路：借助额外空间，合并两个有序数组，得到更长的有序数组。

class Solution {//归并排序public int[] sortArray(int[] nums) {return mergeSort(nums, 0, nums.length-1);  }public int[] mergeSort(int[] nums, int left, int right){//递归退出条件//如果左指针大于右指针，就退出循环//经过左右拆分，数组元素形成单个元素的树if(left >=right){return nums;}//数组中的中位数int mid = (right+left)/2;//数组左拆分mergeSort(nums, left, mid);//数组右拆分mergeSort(nums, mid+1, right);//数组合并，将单个元素进行合并return merge(nums, left, mid, right);}public int[] merge(int[] nums, int left, int mid, int right){//定义一个临时数组，存储排序好的元素int[] temp = new int[right-left+1];//左排序的元素数组的左指针int i = left;//右排序的元素数组的左指针int j = mid+1;//定义一个指向临时数组的左指针int t = 0;//循环判断条件//左数组到mid，右数组到right//左右数组都有元素的时候，进行比较while(i<=mid&&j<=right){//取左右数组中较小的元素，填入临时数组中//并将较小元素所在数组的左指针和临时数组的左指针都一起右移if(nums[i]<=nums[j]){temp[t++] = nums[i++];}else{temp[t++] = nums[j++];}}//当左右数组其中一个数组没有元素的时候//如果左数组中还有剩余元素，就将剩余元素全部加入到临时数组中while(i<=mid){temp[t++]=nums[i++];}//如果有数组中还有元素，就将剩余元素全部加入到临时数组中while(j<=right){temp[t++] = nums[j++];}//将临时数组的元素复制到原数组中去for(int k = 0; k<temp.length;k++){//特别注意这便nums数组起始位置要从 k+left开始 //原因在加右数组的时候，起始位置要加left//这里不理解，直接把它记住。nums[left+k]=temp[k];}//返回原数组return nums;}
}

「归并排序」比「快速排序」好的一点是，它借助了额外空间，可以实现「稳定排序」，Java 里对于「对象数组」的排序任务，就是使用归并排序（的升级版 TimSort，在这里就不多做介绍）。

复杂度分析：

  • 时间复杂度：O(Nlog⁡N)，这里 N 是数组的长度；

  • 空间复杂度：O(N)，辅助数组与输入数组规模相当。

快速排序

基本思路：快速排序每一次都排定一个元素（这个元素呆在了它最终应该呆的位置），然后递归地去排它左边的部分和右边的部分，依次进行下去，直到数组有序；

import java.util.Random;public class Solution {// 快速排序 1：基本快速排序/*** 列表大小等于或小于该大小，将优先于 quickSort 使用插入排序*/private static final int INSERTION_SORT_THRESHOLD = 7;private static final Random RANDOM = new Random();public int[] sortArray(int[] nums) {int len = nums.length;quickSort(nums, 0, len - 1);return nums;}private void quickSort(int[] nums, int left, int right) {// 小区间使用插入排序if (right - left <= INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int pIndex = partition(nums, left, right);quickSort(nums, left, pIndex - 1);quickSort(nums, pIndex + 1, right);}/*** 对数组 nums 的子区间 [left, right] 使用插入排序** @param nums  给定数组* @param left  左边界，能取到* @param right 右边界，能取到*/private void insertionSort(int[] nums, int left, int right) {for (int i = left + 1; i <= right; i++) {int temp = nums[i];int j = i;while (j > left && nums[j - 1] > temp) {nums[j] = nums[j - 1];j--;}nums[j] = temp;}}// 用来确定pivot的位置private int partition(int[] nums, int left, int right) {int randomIndex = RANDOM.nextInt(right - left + 1) + left;// 交换到最左边swap(nums, left, randomIndex);// 基准值int pivot = nums[left];int lt = left;// 循环不变量：// all in [left + 1, lt] < pivot// all in [lt + 1, i) >= pivotfor (int i = left + 1; i <= right; i++) {if (nums[i] < pivot) {lt++;swap(nums, i, lt);}}swap(nums, left, lt);return lt;}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;}
}

复杂度分析：

  • 时间复杂度：O(Nlog⁡N)，这里 N 是数组的长度；
  • 空间复杂度：O(log⁡N)，这里占用的空间主要来自递归函数的栈空间。

冒泡排序

基本思想：

  1. 从序列的第一个元素开始，对相邻的两个元素进行比较，如果它们的顺序错误就交换它们的位置，即将较大的元素往后移动，直到遍历到序列的最后一个元素。
  2. 对剩下的元素重复上述步骤，直到整个序列都已经有序。
public class Solution {public int[] sortArray(int[] nums) {int len = nums.length;for (int i = len - 1; i >= 0; i--) {// 先默认数组是有序的，只要发生一次交换，就必须进行下一轮比较，// 如果在内层循环中，都没有执行一次交换操作，说明此时数组已经是升序数组boolean sorted = true;for (int j = 0; j < i; j++) {if (nums[j] > nums[j + 1]) {swap(nums, j, j + 1);sorted = false;}}if (sorted) {break;}}return nums;}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;}
}

复杂度分析：

  • 时间复杂度：O(N^2)，这里 N 是数组的长度；
  • 空间复杂度：O(1)，使用到常数个临时变量。

并查集

可以按照多叉树的思想来考虑，我们使用数组的方式来构造一颗两层的多叉树，一般可以套用如下模板：

    public static void init(){for(int i=0;i<father.length;i++){father[i] = i;}}// 连接两条边public static void union(int a,int b){father[find(a)]=find(b);}// 寻找a的根public static int find(int a){return a==father[a]?a:(father[a]=find(father[a]));}

可以参考华为机试题：https://mp.weixin.qq.com/s/BlpsEoitip7ugQYgezCd3g

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/101139.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

MidJourney | AI绘画也有艺术

MidJourney | AI绘画也有艺术

免费绘画&#xff0c;体验更多AI可关&注公&众&号&#xff1a;AI研究工厂
阅读更多...
大数据学习(2)Hadoop-分布式资源计算hive(1)

大数据学习(2)Hadoop-分布式资源计算hive(1)

&&大数据学习&& &#x1f525;系列专栏&#xff1a; &#x1f451;哲学语录: 承认自己的无知&#xff0c;乃是开启智慧的大门 &#x1f496;如果觉得博主的文章还不错的话&#xff0c;请点赞&#x1f44d;收藏⭐️留言&#x1f4dd;支持一下博>主哦&#x…
阅读更多...
【.net core】yisha框架 SQL SERVER数据库 反向递归查询部门（子查父）

【.net core】yisha框架 SQL SERVER数据库 反向递归查询部门（子查父）

业务service.cs中ListFilter方法中内容 //反向递归查询部门列表List<DepartmentEntity> departmentList await departmentService.GetReverseRecurrenceList(new DepartmentListParam() { Ids operatorInfo.DepartmentId.ToString() });if (departmentList ! null &am…
阅读更多...
如何将gif变成视频？3个转换方法

如何将gif变成视频？3个转换方法

如何将gif变成视频&#xff1f;没错&#xff0c;GIF是一种动态图片格式&#xff0c;与视频在本质上有所区别。在一些自媒体平台上&#xff0c;我们无法直接分享GIF格式的图片&#xff0c;但可以将其转换为视频格式后再进行分享。因此&#xff0c;当我们想要分享我们喜欢的GIF图…
阅读更多...
香港硬防服务器的防御有什么优缺点？

香港硬防服务器的防御有什么优缺点？

​　　在选择服务器时&#xff0c;安全性是一个重要的考虑因素。而对于那些需要高级防御功能的用户来说&#xff0c;香港硬防服务器可能是一个不错的选择。它也有一些优缺点需要考虑。 香港硬防服务器优点&#xff1a; 强大的硬件资源&#xff1a;香港硬防服务器拥有足够的硬件…
阅读更多...
nginx如何安装 以及nginx的配置文件

nginx如何安装 以及nginx的配置文件

Nginx 网站服务 是一个高性能 轻量级web服务软件&#xff0c; 高新能&#xff1a;对http并发连接的处理能很高&#xff0c;单台处理器可支持30000-50000个并发请求&#xff0c;&#xff08;一般设置在20000个左右&#xff09; 轻量级&#xff1a;nginx软件很小&#xff0c;安装…
阅读更多...
ChromeDriver驱动最新版下载

ChromeDriver驱动最新版下载

下载地址ChromeDriver - WebDriver for Chrome - Downloads selenium.common.exceptions.SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version 113 Current browser version is 117.0.5938.150 with binar…
阅读更多...
vim基础指令（自用）

vim基础指令（自用）

这个是自己随便写的&#xff0c;类似于笔记 vim 多模式编辑器 查看指令&#xff1a; gg&#xff1a; 定位光标到最开始行 shift(按)g 定位到最结尾行 nshift(按)g 定位到任意行 shift&#xff04; 定位到本行结尾 0 定位到本行开头 w&#xff1a;跨单词移动 h.j.k,l: 左下上右 …
阅读更多...
Python 快速排序

Python 快速排序

快速排序使用分治法&#xff08;Divide and conquer&#xff09;策略来把一个序列&#xff08;list&#xff09;分为较小和较大的2个子序列&#xff0c;然后递归地排序两个子序列。 步骤为&#xff1a; 挑选基准值&#xff1a;从数列中挑出一个元素&#xff0c;称为"基准&…
阅读更多...
【RuoYi-Cloud项目研究】【ruoyi-gateway模块】Spring Gatewaye和Sentinel实现网关流控

【RuoYi-Cloud项目研究】【ruoyi-gateway模块】Spring Gatewaye和Sentinel实现网关流控

文章目录 1. RuoYi 实现了对服务的限流2. 网关与普通服务的限流区别2.1. 引入的组件有差别2.2. 配置文件有差别 3. 注意事项 备注&#xff1a; 1、RuoYi 网关默认只在 nacos 配置中心的 Sentinel 限流配置中配置了对“服务限流”&#xff0c;而没有详细控制到限流的 URL。 2、各…
阅读更多...
tensorflow中的常见方法

tensorflow中的常见方法

1.tf.argmax(input,axis) tf.argmax(input,axis)根据axis取值的不同返回每行或者每列最大值的索引。 axis 0: 比较每一列的元素&#xff0c;将每一列最大元素所在的索引记录下来&#xff0c;最后输出每一列最大元素所在的索引数组。 test[0] array([1, 2, 3]) test[1] …
阅读更多...
各种业务场景调用API代理的API接口教程

各种业务场景调用API代理的API接口教程

API代理的API接口在各种业务场景中具有广泛的应用&#xff0c;本文将介绍哪些业务场景可以使用API代理的API接口&#xff0c;并提供详细的调用教程和代码演示&#xff0c;同时&#xff0c;我们还将讨论在不同场景下使用API代理的API接口所带来的好处。 哪些业务场景可以使用API…
阅读更多...
42. QT中开发Android配置QFtp功能时遇到的编译问题

42. QT中开发Android配置QFtp功能时遇到的编译问题

1. 说明 此问题仅适用在QT中开发Android程序时&#xff0c;需要适用QFtp功能的情况。一般情况下&#xff0c;如果开发的是Windows或者Linux系统下的程序&#xff0c;可能不会出现该问题。 2. 问题 【Android】在将QFtp的相关代码文件加入到项目中后&#xff0c;编译项目时会…
阅读更多...
PyTorch 入门

PyTorch 入门

一、说明 深度学习是机器学习的一个分支&#xff0c;其中编写的算法模仿人脑的功能。深度学习中最常用的库是 Tensorflow 和 PyTorch。由于有各种可用的深度学习框架&#xff0c;人们可能想知道何时使用 PyTorch。以下是人们更喜欢使用 Pytorch 来完成特定任务的原因。 Pytorch…
阅读更多...
BGP服务器租用腾讯云和阿里云价格对比

BGP服务器租用腾讯云和阿里云价格对比

BGP云服务器像阿里云和腾讯云均是BGP多线网络&#xff0c;速度更快延迟更低&#xff0c;阿里云BGP服务器2核2G3M带宽优惠价格108元一年起&#xff0c;腾讯云BGP服务器2核2G3M带宽95元一年起&#xff0c;阿腾云atengyun.com分享更多云服务器配置如2核4G、4核8G、8核16G等配置价格…
阅读更多...
【编程技巧】用size_t定义数量有什么好处

【编程技巧】用size_t定义数量有什么好处

使用 size_t 来定义数量有几个好处&#xff1a; 平台无关性&#xff1a;size_t 是一个无符号整数类型&#xff0c;其大小适应当前编译环境的体系结构&#xff0c;通常是足够大以容纳目标平台上的最大对象大小。这使得代码在不同平台上更具可移植性。 正确性和安全性&#xff…
阅读更多...
2023版 STM32实战7 通用同步/异步收发器（串口）F103/F407

2023版 STM32实战7 通用同步/异步收发器（串口）F103/F407

串口简介和习惯 -1-通用同步异步收发器 (USART) 能够灵活地与外部设备进行全双工数据交换&#xff0c;满足外部设备对工业标准 NRZ 异步串行数据格式的要求。 -2-硬件流控制一般是关闭的 -3-波特率指单位时间传输bit个数 -4-数据位一般是8位 -5-一般无校验位 编写代码思路 -1-参…
阅读更多...
使用wireshark解析ipsec esp包

使用wireshark解析ipsec esp包

Ipsec esp包就是ipsec通过ike协议协商好后建立的通信隧道使用的加密包&#xff0c;该加密包里面就是用户的数据&#xff0c;比如通过的语音等。 那么如何将抓出来的esp包解析出来看呢&#xff1f; 获取相关的esp的key信息. 打开wireshark -> edit->preferences 找到pr…
阅读更多...
flask捕获@app.errorhandler/@app.after_request全局异常总结

flask捕获@app.errorhandler/@app.after_request全局异常总结

捕获处理全局异常的方法有两种&#xff1a;app.errorhandler、app.after_request1、第一种的使用&#xff0c;需要将flask的debug开关打开才能生效&#xff08;自动捕获异常&#xff09;&#xff0c;在config里面将DEBUG TRUE就可以&#xff08;默认是False&#xff09;。 但是…
阅读更多...
功能测试复习

功能测试复习

一。测试流程 1.需求评审 确保各部门需求理解一致 2.计划编写 测什么&#xff0c;谁来测&#xff0c;怎么测 3.用例设计 验证项目是否符合需求的操作文档 4.用例执行 项目模块开发完成开始执行用例文档实施测试 5.缺陷管理 对缺陷进行…
阅读更多...
最新文章

Copyright @ 2022~2023