算法复习二【二分查找、排序、双指针】

最新推荐文章于 2023-06-12 17:35:46 发布
最新推荐文章于 2023-06-12 17:35:46 发布
阅读量115 收藏
点赞数
分类专栏： 算法 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44593275/article/details/123193361
版权

4、二分查找

在旋转数组中搜索

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

**思路：**有序的可以采用二分法，我们可以通过第一个数和最后一个数与中间数的关系去判断该数属于前面一段，还是后面一段

二分法思路：

while条件：start+1<end

第一个if：num[mid]==target，返回mid

第二个if：判断属于前大半段（num[start]<num[mid]）说明前大半是顺序的

第三个if：判断属于后大半段（num[mid]<num[end]）说明后大半是顺序的

最后两个if：是决定返回start还是end的值

public int search(int[] num, int target) {
        if (num==null || num.length==0) {
            return -1;
        }
		int start=0;
		int end=num.length-1;
		while(start+1<end){
			int mid=start+(end-start)/2;
			if (num[mid]==target) {
				return mid;
			}
			/**
			 * 前半部分占大部分
			 */
			if (num[start]<num[mid]) {
				if (target>=num[start]&&target<=num[mid]) {
					end=mid-1;
				}else{
					start=mid+1;
				}
			/**
			 * 后半部分占大部分
			 */
			}else{
				if (target>=num[mid]&&target<=num[end]) {
					start=mid+1;
				}else{
					end=mid-1;
				}
            }
		}
        if (num[start]==target) {
            return start;
        }
        if (num[end]==target) {
            return end;
        }
		return -1;
    }
在旋转数组中找最小数

输入：nums = [4,5,6,7,0,1,2]
输出：0

思路：上一题一样，顺序用二分法去搜索。首先要确定一个搜索的标准，可以用end最为一个标准数，如果小于middle的数，则说明，最小的在后半段，应该大于，那么说明最小的在前半段

public int findMin(int[] nums) {
        /**
		 * 特殊情况
		 */
		if (nums==null || nums.length==0) {
			return -1;
		}
		int start=0;
		int end=nums.length-1;
		int target=nums[end];
		int mid=0;
		while(start+1<end){
			mid=start+(end-start)/2;
			/**
			 * 后半部分占大部分,小的在前
			 */
			if (nums[mid]<=target) {
				end=mid;
			}else{
				start=mid;
			}
		}
		return Math.min(nums[start],nums[end]);
    }
砍树

题目：将不同长度的木头进行分段，段的大小一样，给定段数，求最大段的值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x3We3U5Z-1646056875844)(C:\Users\76532\Desktop\面试复习\算法\砍树题目.png)]

思路：将最长的木头去二分，得到每个中间值，去求可以分多少段，如果段数大于K，则继续往大的二分，如果段数小于K，则往小的二分，最后得到结果。

public class WoodCut{

	public static void main(String[] args){
		int[] l={232,124,456};
		int k=7;
		System.out.println(woodCut(l,k));
	}
	/**
	 * [woodCut description]
	 * @param  l [description] 各段木头的长度集合
	 * @param  k [description] 需要分成的段数
	 * @return   [description] 返回最长分成的长度
	 */
	public static int woodCut(int[] l,int k){
		/**
		 * 特殊情况
		 */
		if (l==null || l.length==0 || k<0) {
			return 0;
		}
		if (k==0) {
			return 0;
		}
		int left=0;
		int right=0;
		/**
		 * 取出最长的木头进行二分
		 */
		for (int m: l) {
			right= Math.max(right,m);
		}
		while(left+1<right){
			int mid=left+(right-left)/2;
			if (count(l,mid)>=k) {
				left=mid;
			}else{
				right=mid;
			}
		}
		if (count(l,right)>=k) {
			return right;
		}
		if (count(l,left)>=k) {
			return left;
		}
		return 0;

	}
    //求能分多少段
	public static int count(int[] l,int length){
		int count=0;
		for (int k: l) {
			count=count+(k/length);
		}
		return count;
	}
}

5、排序

冒泡排序思路：

双循环

大循环：每个数依次进行，也就是每次能找个最大的，n个数找n个就能排好序。

小循环：遍历，替换大的放后面

public void bubbleSort(int[] array){
    for(int i=0;i<array.length;i++){
        for(int j=1;j<array.length-i;j++){
            if(array[j-1]>array[j]){
                int temp=array[j-1];
                array[j-1]=array[j];
                array[j]=temp;
            }
        }
    }
}
选择排序思路：

双循环

大循环：一个数一个数去找到比它小的数替换

小循环：找出最小的，最后交换

选择是在最后才交换，比起冒泡交换次数少，提高效率

public void selectSort(int[] array){
    for(int i=0;i<array.length;i++){
        int pos=i;
        for(int j=i+1;j<array.length;j++){
            if(array[pos]>array[j]){
                pos=j;
            }
        }
        if(pos!=i){  
            int temp=array[i];
            array[i]=array[pos];
            array[pos]=temp;
        }
    }
}
插入排序思路：

双循环

大循环：逐个进行插入前面的数组

小循环：将插入部分的数组往后挪动

public void insertSort(int[] array){
    //比较的位置
    int j;
    for(int i=1;i<array.length;i++){
        j=i-1;
        while(j>=0 && array[i]<array[j]){
            array[j+1]=array[j];
            j--;
        }
        array[j+1]=array[i];
    }
}
重点：快速排序思路

是一个递归嵌套的结构

将由确定pivot的值，小的分左边，大的分右边，分成两个部分，然后不断嵌套去分，最后分成一个有序的队列。

public void quickSort(int[] array){
    int left=0;
    int right=array.length-1;
    quickSortImpl(left,right,array);
}
public void quickSortImpl(int start,int end,int[] array){
    if(left >right){
        return;
    }
    //不能直接使用start和end，因为他们是传进来的前后位，如果改变，后面就不知道怎么分了。
    int left=start;
    int right=end;
    //最好取中间值
    int pivot=array[left+(right-left)/2];
    while(left<=right){
        //left定位到大于pivot的地方
        while(left<=right && array[left]<pivot){
            left++;
        }
        //right定位到小于pivot的地方
        while(left<=right && array[right]>pivot){
            right--;
        }
        //将两个位置的数交换
        if(left<=right){
            int temp=array[left];
            array[left]=array[right];
            array[right]=temp;
            //交换后需要继续往下走
            left++;
			right--;
        }
    }
    quickSortImpl(start,right,array);
    quickSortImpl(left,end,array);
}

利用快速排序找第K个大的数字，可以通过分完后，left和right的位置去判断需要进入哪个函数，然后找到第K个大的数，不用全部排完

if (k<=left) {
    return QuickSortFind(start,right,nums,k);
}else{
    return QuickSortFind(left,end,nums,k);
}
重点：归并排序思路：

是一个递归嵌套的结构

先将数组进行分割成一个一个，然后再进行逐步合并

public static void mergeSort(int[] nums) {
		int[] temp = new int[nums.length];
		mergeSortImpl(0, nums.length - 1, nums, temp);
	}

	public static void mergeSortImpl(int start, int end, int[] array, int[] temp) {
		if (start >= end) {
			return;
		}
		int mid = start + (end - start) / 2;
		mergeSortImpl(start, mid, array, temp);
		mergeSortImpl(mid + 1, end, array, temp);
		merge(start, mid, end, array, temp);
	}

	public static void merge(int start, int mid, int end, int[] array, int[] temp) {
		int left = start;
		int right = mid + 1;
		int index = start;
        //如果两边都有数，将进行比较，放进结果数组
		while (left <= mid && right <= end) {
			if (array[left] < array[right]) {
				temp[index++] = array[left++];
			}
			if (array[left] > array[right]) {
				temp[index++] = array[right++];
			}
		}
        //如果只剩一边有数则直接放入
		while (left <= mid) {
			temp[index++] = array[left++];
		}
		while (right <= end) {
			temp[index++] = array[right++];
		}
        //将结果数组的值搬到原始数组
		for (int i = start; i <= end; i++) {
			array[i] = temp[i];
		}
	}

6、双指针

两个指针根据结果判断是要前移还是后移

需要的是一个有序的数组，可以减少循环次数

三数之和

思路：暴力法是三个循环

而使用双指针可减少一循环

大循环：取每个数与另外两个指针数的循环

小循环：通过判断相等、大于、小于移动指针

/**
 * 双指针操作
 * 一个在前，一个在后
 * 根据大小，选择调前，调后
 */
public List<List<Integer>> threeSum(int[] nums) {
		/**
		 * 特殊情况
		 */
		List<List<Integer>> result=new ArrayList<List<Integer>>();
		if (nums==null || nums.length<=2) {
			return result;
		}
		//排序
		Arrays.sort(nums);
    	//第一个循环：取每个数与另外两个指针数的循环
		for (int i=0;i<nums.length-2;i++) {
            //如果数相同可以跳过
			if (i>0 && nums[i]==nums[i-1]) {
				continue;
			}
            //两个指针
			int left=i+1;
			int right=nums.length-1;
            //循环：
			while(left<right){
                //判断是否相等结果，相等加入结果集合中
				if (nums[i]+nums[left]+nums[right]==0) {
					List<Integer> List=new ArrayList<Integer>();
					List.add(nums[i]);
					List.add(nums[left]);
					List.add(nums[right]);
					result.add(List);
					left++;
					right--;
                    //排除重复项
					while (left<=right && nums[left]==nums[left-1]) {
						left++;
					}
                    //排除重复项
					while (left<=right && nums[right]==nums[right+1]) {
						right--;
					}
                //如果小了，就left++，大就right--
				}else if (nums[i]+nums[left]+nums[right]<0) {
					left++;
				}else{
					right--;
				}
			}

		}
		return result;

    }
三角形计数

思路：暴力法是三个循环

而使用双指针可减少一循环

大循环：取每个数与另外两个指针数的循环

小循环：通过判断相等、大于、小于移动指针

注意：当三边大于时，left后面的数就都大于了，count只需要直接加right-left，然后把right调小

public class TriangleNumber{
	public int triangleNumber(int[] nums) {
		/**
		 * 特殊情况
		 */
		if (nums==null || nums.length<3) {
			return 0;
		}
        Arrays.sort(nums);
		int end=nums.length-1;
		int count=0;
		for (int i=end; i>=2; i--) {
			int left=0;
			int right=i-1;
			while(left<right){
				if (nums[left]+nums[right]<=nums[i]) {
					left++;
				}
				if (nums[left]+nums[right]>nums[i]) {
                    //后面所有的数都可构成
					count+=(right-left);
					right--;
				}
			}
		}
		return count;

    }
}
积雨问题

关键点：两边的哪个高，因为我们只需要知道操作低的那边

高的不动即可，通过移动低的去取得积水的值

public class Trap{
	public int trap(int[] height) {
		/**
		 * 特殊情况
		 */
		if (height==null || height.length==0) {
			return 0;
		}
        //x轴值
		int left=0;
		int right=height.length-1;
        //y轴值
		int leftHeight=height[left];
		int rightHeight=height[right];
        //积水量
		int sum=0;
		while(left<right){
            //因为右边比左边高，所以不用关心右边，先挪左边
			if (leftHeight<rightHeight) {
                //不可装水，往左诺，最高值变化
				if (leftHeight<height[left+1]) {
					leftHeight=height[left+1];
					left++;
                //可装水，往左诺，最高值不变
				}else{
					sum+=leftHeight-height[left+1];
					left++;
				}
			}else{
				if (rightHeight<height[right-1]) {
					rightHeight=height[right-1];
					right--;
				}else{
					sum+=rightHeight-height[right-1];
					right--;
				}
			}
		}
		return sum;

    }
}
Steady Ben
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode算法刷题——二分查找+双指针
qq_38958912的博客
11-01 4246
LeetCode算法刷题by Python——二分查找 + 双指针一、二分查找1. 二分查找2. 第一个错误的版本3. 搜索插入位置二、双指针1. 有序数组的平方2. 旋转数组3. 移动零4. 两数之和5. 反转字符串6. 反转字符串中的单词7. 链表的中间结点8. 删除链表的倒数第N个结点 虽然lz目前还是一名实验室搬砖硕士，但是怀揣着成为一名优秀程序猿的宏图大志，本着笨鸟先飞的古代贤人理念，我决定开启我的LeetCode之旅 (撒花★,°:.☆(￣▽￣)/$:.°★ 。) 理性的衡量了自己的水平，经过一
冒泡排序，快速排序，堆排序，滑动窗口，双指针
weixin_42819084的博客
08-01 353
冒泡排序 这个算法的核心之处就是在每个相邻的元素都进行比较，如果不是按顺序的形式，就彼此交换。这个算法不适合用于大数据量的排序，因为它的平均时间复杂度和最差时间复杂度都是o（n^2）。 写代码时，N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。 n=len(arrList) for i in range(n-1): for j in range(n-1-i)： if arrList[i+1] < ar
用双指针和冒泡排序法处理数组重复数(删除并返回新数组长度)-------c语言
scfvlog的博客
10-17 395
(1)冒泡排序法: ​ #include<stdio.h> #define max_size 100 int main() { int nums[max_size]; int e,n; for(int i=0;i<n;i++) { scanf("%d",&nums[i]); } for(int j=0;j<n;j++) { for(int m=0;m<n;m++) { if(nums[j]==nums[j+1]) { for(
冒泡排序（笔记）
m0_52403880的博客
03-06 189
冒泡排序 原理是：内循环： 使用相邻双指针 j , j + 1 从左至右遍历，依次比较相邻元素大小，若左元素大于右元素则将它们交换；遍历完成时，最大元素会被交换至数组最右边 。外循环： 不断重复「内循环」，每轮将当前最大元素交换至剩余未排序数组最右边 ，直至所有元素都被交换至正确位置时结束。 冒泡排序是稳定的排序方法。 时间复杂度为 ：O(n^2) 空间复杂度为 ：O(1) public static void bubbleSort(int[] arr){ for (int i = 0; i
算法-排序与双指针
weixin_51225684的博客
06-12 897
具体实现时，需要先确定待排序数组中最大元素的值max，然后创建一个长度为max+1的计数数组count，遍历待排序数组，统计每个元素出现的次数，最后根据计数数组将元素放入相应的位置。具体实现时，需要先确定桶的数量和每个桶的范围，然后遍历待排序数组，将每个元素放入相应的桶中，最后对每个桶内部使用其他排序算法进行排序，最后将所有桶中的元素按照顺序依次放入待排序数组中。归并排序是一种基于分治思想的排序算法，其基本思想是将数组分成两个子数组，递归地对子数组进行排序，然后将两个有序的子数组合并成一个有序的数组。
二分查找算法PPT课件
04-11
二分查找算法，二分查找算法课件，二分查找算法PPT
C语言快速排序与二分查找算法示例
08-28
主要介绍了C语言快速排序与二分查找算法,涉及C语言随机数生成、快速排序及二分查找等算法相关实现技巧,需要的朋友可以参考下
二分查找算法代码+二分查找算法思想
最新发布
05-13
二分算法，也称为二分查找或折半查找，是一种在有序数据集中查找特定元素的算法。其基本思想是： 起始时，将数据集视为一个区间，区间包含所有待搜索的元素。 计算区间的中间元素，并将待查找的元素与中间元素进行...
Python搜索算法-二分查找算法详解
04-10
Python搜索算法——二分查找算法详解
Java实现二分查找算法实例分析
09-03
主要介绍了Java实现二分查找算法,实例分析了二分查找算法的原理与相关实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
简单的二分查找
chenlang02的博客
03-01 240
1.简介     这里所讲解的简单的二分查找指的是在一个有序无重复元素的int类型的数组中查找需要的元素。 2.代码 public int binarySearch(int[] a ,int value){ int low = 0, hi = a.length - 1; while(low <= hi){ int mi...
新手入门之二分查找双指针题解思路（java）
m0_64887345的博客
05-03 247
【详解排序算法】冒泡排序
程序员乌拉的博客！
04-01 2102
大家好🙌我是你们的好朋友，大数据老虾😀。相遇是缘，既然来了就拎着小板凳坐下来一起唠会儿😎，如果在文中有所收获，请别忘了一键三连，动动你发财的小手👍，你的鼓励，是我创作的动力😁！废话不多说，直接😎 开干吧！ PS：文末干货，记得拎着小板凳离开的时候也给它顺走 🤣 座右铭：“懒”对一个人的毁灭性有多大，早起的重要性就多大。 冒泡排序【排序算法】冒泡排序算法解析流程图进行解析案列详解算法实现算法特性算法优化文末彩蛋🤩 【排序算法】冒泡排序 算法解析 冒泡排序是最基础的排序算法，由于它的直观性，经常被作为首个介
经典算法：双指针问题--二分查找
My apologize的博客
07-24 3025
算法—程序的灵魂，没错就是灵魂 ！ 今天我们来聊聊关于双指针问题中的二分查找的问题 内容参考：《你也能看得懂的Python算法书》 转载请标注： https://blog.csdn.net/qq_43582207 python版本：Python3.7 IDE：Jupyter notebook 作者:My apologize 文章目录双指针问题二分查找猜数字小程序 双指针问题 二分查找 <<关于有序数组，还有一个经典问题，如何在一个有序数组中精确找到一个元素的位置。>> 第一种笨办
二分查找的实现、特性及 力扣实战题目解析
青柠小甜味
05-06 792
二分查找的前提： 1.目标函数单调性（单调递增或递减） 2.存在上下界（bounded） 3.能够通过索引访问（index accessible） 代码模版 left , right = 0,len(array) - 1 while left <= right: mid = (left+right) / 2 if array[mid] == target: # find the target...
LeetCode: Sort Colors 三种颜色排序 多排序算法
心之所向
03-15 591
试题： Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue. Here, we will use the...
常见排序及算法实现(四)快速排序双指针法(一)
persistence_Y的博客
09-15 1901
快速排序是Hoare于1962年提出的一种具有二叉树结构的交换排序方法. 基本思想: 在一组待排序元素序列中,任取一个元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中的所有元素均小于基准值,右子序列中的所有元素均大于基准值,然后就是左右子序列重复该过程,一直到所有的元素都排列在相应的位置上位置. 实现快速排序的方法常见的有双指针法,挖坑法,Hoare法. 来看示例. 假如有一组待...
排序算法系列：冒泡排序与双向冒泡排序
weixin_30603633的博客
01-29 2888
概述 排序算法应该算是一个比较热门的话题，在各个技术博客平台上也都有一些博文进行了一定程度的讲解。但还是希望能从自我完善的角度出发，可以更详细、全面、形象地表达这些算法的精髓。本文就先从最简单的冒泡排序开始说起，别说你已经彻底了解了冒泡排序算法（虽然一开始我也是这样以为的）。 版权说明 本文链接：http://blog.csdn.net/lemon_tree121...
二分查找的两种方法（详细图解）
qq_52253798的博客
01-19 5683
一、什么是二分查找 假设给定的数组中的元素是一个有序的状态，比如是单调不递减或者是单调不递增的状态，对于这种情况可以使用二分查找来完成。即二分查找需要满足两个条件： （1）数组存储 （2）元素有序，单调性 二、时间复杂度 比如：总共有n个元素，每次查找的区间大小就是n，n/2，n/4，…，n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数。 由于n/2^k取整后>=1，即令n/2^k=1， 可得k=log2n,（是以2为底，n的对数），所以时间复杂度可以表示O()=O(logn)
二分查找排序算法份文件编写
07-11
以下是一个使用二分查找算法进行排序的示例： ```python def binary_search_sort(arr n = len(arr) for i in(1, n): # 使用二分查找到插入位置 left, right 0, i - 1 while mid = (left + right) // 2 if ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值