程序员经验分享-hwhale

算法 | 二分查找及其变种

2023-05-16

文章目录

  • 前言
  • 一、二分查找
  • 二、数组完全有序且不重复
    • 1.第一题
    • 2.第二题
  • 三、数组完全有序且重复
    • 1.第一题
    • 2.第二题
  • 四、数组部分有序且不重复
    • 1.第一题
    • 2.第二题
  • 五、数组部分有序且重复
    • 1.第一题
    • 2.第二题
    • 3.第三题
  • 六、二维数组
  • 总结

前言

刷题时对于二分查找法的一些总结

提示：以下是本篇文章正文内容，下面案例可供参考

一、二分查找

二分查找也称折半查找（Binary Search），是一种在有序数组中查找某一特定元素的搜索算法。我们可以从定义可知，运用二分搜索的前提是数组必须是有序的，这里需要注意的是，我们的输入不一定是数组，也可以是数组中某一区间的起始位置和终止位置
在这里插入图片描述

二、数组完全有序且不重复

1.第一题

题目描述：给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例：
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

int search(vector<int>&nums,int target)
{
	if(nums.size()==0)
	{
		return -1;
	}
	int left=0;
	int right==nums.size()-1;
	while(left<=right)
	{
		int mid=left+((right-left)>>1);
		if(nums[mid]==target)
		{
			return mid;
		}
		else if(target<nums[mid])
		{
			right=mid-1;
		}
		else
		{
			left=mid+1;
		}
	}
	return -1;
}

2.第二题

题目描述：给定一个排序的整数数组 nums 和一个整数目标值 target ，请在数组中找到 target ，并返回其下标。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
示例 :
输入: nums = [1,3,5,6], target = 5
输出: 2
输入: nums = [1,3,5,6], target = 2
输出: 1

int searchInsert(vector<int>& nums, int target) 
    {
        if(nums.size()==0)
        {
            return 0;
        }
        int left=0;int right=nums.size()-1;
        while(left<=right)
        {
            int mid=left+((right-left)>>1);
            if(target<=nums[mid])
            {
                right=mid-1;
            }
            else
            {
                left=mid+1;
            }
        }
        return left;
    }

三、数组完全有序且重复

1.第一题

题目描述：给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
示例：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

class Solution 
{
public:
    vector<int> searchRange(vector<int>& nums, int target)
    {
    	if(nums.size()==0)
    	{
    		return {-1,-1};
    	}
    	else if(FindFirstPos(nums,target)<FindLastPos(nums,target))
    	{
    		return {-1,-1};//证明没有找到
    	}
    	else
    	{
    		return {FindFirstPos(nums,target),FindLastPos(nums,target)};
    		//组建返回数组
    	}	
    }
private:
int FindFirstPos(vector<int>& nums, int target)//找出目标值出现的第一个位置
{
	int left=0;
	int right=nums.size()-1;
	while(left<=right)
	{
		int mid=left+((right-left)>>1);
		if(target<=nums[mid])
		{
			right=mid-1;
		}
		else if(target>nums[mid])//这里为了方便观看写了else if可以直接写成else
		{
			left=mid+1;
		}
	}
	return left;
} 
int FindLastPos(vector<int>& nums, int target)//找出目标值出现的最有一个位置
{
	int left=0;
	int right=nums.size()-1;
	while(left<=right)
	{
		int mid=left+((right-left)>>1);
		if(target<nums[mid])
		{
			right=mid-1;
		}
		else if(target>=nums[mid])//这里为了方便观看写了else if可以直接写成else
		{
			left=mid+1;
		}
	}
	return right;
}
};

2.第二题

题目描述：从数组或区间中找出第一个大于或最后一个小于目标元素的数的索引，例 nums = {1,3,5,5,6,6,8,9,11} 我们希望找出第一个大于 5的元素的索引，那我们需要返回 4 ，因为 5 的后面为 6，第一个 6 的索引为 4，如果希望找出最后一个小于 6 的元素，那我们则会返回 3 ，因为 6 的前面为 5 最后一个 5 的索引为 3。
输入：{1,3,5,5,6,6,8,9,11} target=5
输出：4
解释：比5大的第一个数是6，输出下标4；

int firstBigNum(vector<int>& nums, int target)//找出比目标值大的第一个数
{
	if(nums.size()==0)
	{
		return -1;
	}
	int left=0;int right=nums.size()-1;
	while(left<=right)
	{
		int mid=left+((right-left)>>1);
		if(target<nums[mid])
		{
			if(mid==0||target>=nums[mid-1])//比当前位置小，大于等于下一个位置，证明当前位置是第一个大于target的位置，返回其下标
			{
				return mid;
			}
			else
			{
				right=mid-1;
			}
		}
		if(target>=nums[mid])
		{
			left=mid+1;
		}
	}
	return -1;//未找到
}
int lastSmallNum(vector<int>& nums, int target)//找出比目标值小的最后一个数
{
	if(nums.size()==0)
	{
		return -1;
	}
	int left=0;
	int right=nums.size()-1;
	while(left<=right)
	{
		int mid=left+((right-left)>>1);
		if(target<=nums[mid])
		{
			right=mid-1;
		}
		else if(target>nums[mid])
		{
			if(mid==nums.size()-1||target<=nums[mid+1])//比当前位置大，等于或小于下一个位置，证明当前位置为最后一个小于targrt的数，返回其下标
			{
				return mid;
			}
			else
			{
				left=mid+1;
			}
		}
	}
	return -1;
}

四、数组部分有序且不重复

1.第一题

题目描述：整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 ：
输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

int search(vector<int>& nums, int target)
{
	if(nums.size()==0)
	{
		return -1;
	}
	if(nums.size()==1)
	{
		return target==nums[0]?0:-1;
	}
	int left=0;int right=nums.size()-1;
	while(left<=right)
	{
		if(target==nums[mid])
		{
			return mid;
		}
		else if(nums[left]<=nums[mid])
		{
			if(nums[left]<=target&&target<nums[mid])
			{
				right=mid-1;
			}
			else
			{
				left=mid+1;
			}
		}
		else
		{
			if(nums[mid]<target&&target<=nums[right])
			{
				left=mid+1;
			}
			else
			{
				right=mid-1;
			}
		}
	}
	return -1;
}

2.第二题

题目描述：已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。
给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 1：
输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：
输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

//重点比较nums[mid]与nums[right]的大小
//如果前者大于后者，则证明最小值在mid-right中
//如果前者小于后者，则证明最小值在left-mid中

int findMin(vector<int>& nums) 
    {
        if(nums.size()==1)
        {
            return nums[0];
        }
        int left=0;
        int right=nums.size()-1;
        while(left<=right)
        {
            int mid=left+((right-left)>>1);
            if(nums[mid]>=nums[right])
            {
                left=mid+1;
            }
            else
            {
                right=mid;
            }
        }
        return nums[right];
    }

五、数组部分有序且重复

1.第一题

题目描述：假设按照升序排序的数组在预先未知的某个点上进行了旋转。(与第四部分第一题对比)
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例
输入：nums = [1，3，1，1，1], target = 3 输出：true
示例 2：
输入：nums = [2,5,6,0,0,1,2], target = 3 输出：false

bool search(vector<int>& nums, int target)
{
	if(nums.size()==0)
	{
		return false;
	}
	if(nums.size()==1)
	{
		return nums[0]==target?true:false;
	}
	int right=nums.size()-1;
	int left=0;
	while(left<=right)
	{
		int mid=left+((right-left)>>1);
		if(nums[mid]==target)
		{
			return true;
		}
		else if(nums[left]==nums[mid])//刨除重复值
		{
			++left;
			continue;
		}
		else if(nums[left]<nums[mid])
		{
			if(nums[left]<=target&&target<nums[mid])
			{
				right=mid-1;
			}
			else
			{
				left=mid+1;
			}
		}
		else
		{
			if(nums[mid]<target&&target<=nums[right])
			{
				left=mid+1;
			}
			else
			{
				right=mid-1;
			}
		}
	}
	return false;
}

2.第二题

题目描述：(与第四部分第二题对比)已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。
给你一个可能存在 重复 元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须尽可能减少整个过程的操作步骤。
示例 1：
输入：nums = [1,3,5]
输出：1
示例 2：
输入：nums = [2,2,2,0,1]
输出：0

//重点比较nums[mid]与nums[right]的大小
//如果前者大于后者，则证明最小值在mid-right中
//如果前者小于后者，则证明最小值在left-mid中
//如果前者等于后者，则证明存在重复值，执行--right
//具体可参考https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/solution/er-fen-cha-zhao-wei-shi-yao-zuo-you-bu-dui-cheng-z/，这位老哥说的很详细

int findMin(vector<int>& nums) 
    {
        if(nums.size()==1)
        {
            return nums[0];
        }
        int left=0;
        int right=nums.size()-1;
        while(left<=right)
        {
            int mid=left+((right-left)>>1);
            if(nums[mid]==nums[right])
            {
                --right;
            }
            else if(nums[mid]>nums[right])
            {
                left=mid+1;
            }
            else
            {
                right=mid;
            }
        }
        return nums[left];
    }

3.第三题

搜索旋转数组。给定一个排序后的数组，包含n个整数，但这个数组已被旋转过很多次了，次数不详。请编写代码找出数组中的某个元素，假设数组元素原先是按升序排列的。若有多个相同元素，返回索引值最小的一个。

示例1:

输入: arr = [15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], target = 5
输出: 8（元素5在该数组中的索引）
示例2:

输入：arr = [15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], target = 11
输出：-1 （没有找到）

int search(vector<int>& arr, int target) 
    {
        int n=arr.size();
        if(n==0)  return -1;
        else if(n==1)
        {
            if(arr[0]==target)
            {
                return 0;
            }
            return -1;
        }
        int left=0,right=n-1;
        while(left<=right)
        {
            //细节点1
            if(arr[left]==target)
            {
                return left;
            }
            int mid=left+(right-left)/2;
            //细节点2 左边可能还有与target相等的元素
            if(arr[mid]==target)
            {
                right=mid;
            }
            else if(arr[left]==arr[mid])
            {
                left++;
                continue;
            }
            else if(arr[left]<arr[mid])
            {
                if(arr[left]<=target&&target<arr[mid])
                {
                    right=mid-1;
                }
                else
                {
                    left=mid+1;
                }
            }
            else
            {
                if(arr[mid]<target&&target<=arr[right])
                {
                    left=mid+1;
                }
                else
                {
                    right=mid-1;
                }
            }
        }
        return -1;
    }

六、二维数组

有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。

数据范围：1 \le n \le 100001≤n≤10000，数组中任意元素的值: 0 \le val \le 100000≤val≤10000
要求：空间复杂度：O(1)O(1) ，时间复杂度：O(logn)O(logn)
示例1
输入：
[3,4,5,1,2]
复制
返回值：
1

//第一种方法：每一行进行二分查找
bool myfind(int target,vector<int>&nums)
    {
        int left=0,right=nums.size()-1;
        while(left<=right)
        {
            int mid=left+(right-left)/2;
            if(nums[mid]==target)
            {
                return true;
            }
            if(nums[mid]<target)
            {
                left=mid+1;
            }
            else
            {
                right=mid-1;
            }
        }
        return false;
    }
    bool Find(int target, vector<vector<int> > array) 
    {
        int flag=false;
        if(array.size()==0)  return flag;
        int n=array.size();
        for(int i=0;i<n;++i)
        {
            int tag=myfind(target, array[i]);
            if(tag)
            {
                flag=true;
                break;
            }
        }
        return flag;
    }

//第二种方法：根据二维数组特性从右上角开始找
bool Find(int target, vector<vector<int> > array) 
    {
        int m=array.size();//行
        int n=array[0].size();//列
        int row=0;
        int col=n-1;
        //int tag=array[row][col];
        while(row<m&&col>=0)
        {
            if(array[row][col]==target)
            {
                return true;
            }
            else if(array[row][col]<target)
            {
                ++row;
            }
            else
            {
                --col;
            }
        }
        return false;
    }

总结

二分查找真他妈的是个细节怪！！！

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

二分查找及其变种

算法 | 二分查找及其变种 的相关文章

  • CRNN-libtorch模型推理的时候报错std:runtime_error

    使用libtorch模型推理的时候出现报错std runtime error 这里报错的情况一般是数据不同步的问题 xff0c 也就是说我们的模型是在gpu上 xff0c 而数据是在cpu上 xff0c 那么要做的一件事就是检查forwar

  • 数据集txt格式划分为多个txt文件夹

    简单记录一下数据标签txt格式划分为多个文件 xff0c 通常我们标注号的标签 xff0c 都是在一个txt文件夹中 xff0c 我们训练的时候需要把txt中的标签按照一定的比例划分为多个文件 xff0c 这里贴出划分为三个文件的代码 xf

  • 租用终端训练网络遇到的一些坑

    最近由于电脑配置和经济的问题 xff0c 想训练模型 xff0c 无奈只能选择在平台上训练了 xff0c 我使用的是AutoDL这个平台 xff0c 感觉还行 xff0c 还是挺划算 感兴趣或者需要的老铁可以点击蓝色字体进去尝试一下 接下来

  • CRNN-pytorch模型转libtorch模型踩坑记录

    这段时间一直在做CRNN文字识别的问题 xff0c 从pytorch中训练好的模型然后转到libtorch中去 xff0c 但是CRNN提供的代码没有转libtorch模型的部分 xff0c 于是就在网上到处乱找 xff0c 其中找到了这篇

  • 如何升级gcc版本

    下面将整个过程更新的过程写下来 xff0c 希望对有需要的人提供一些帮助 首先需要准备需要材料 xff1a gcc4 4 2版需要安装gmp4 2 0 43 和mpfr2 3 0 43 xff0c 到GMP的网站 xff08 http gm

  • 召回率与精确率的理解

    写在前面 识别精度主要由召回率 xff08 recall xff09 和精确率 xff08 precision xff09 两个指标决定 xff0c 在训练结束时可以通过re pre曲线来表示模型的准确度 xff0c 也可以根据二者之间的关

  • vs常见的错误集锦-error C4996: ‘wcstombs‘: This function or variable may be unsafe

    问题所在 xff1a 缺少宏定义 在使用wcstombs这个函数时遇到了题目所说的这个情况 xff0c 查找得知是缺少宏定义 xff0c 按照网上查找的问题 xff0c 在vs的配置中添加宏定义就行了 xff1b 在以下的位置 xff1a

  • Keil左侧Function列表无法显示（已解决）

    左侧的Functions框框会显示所有的库函数 xff0c 方便查找 查找的来源是工程所在的目录 如果把目录放得太深 xff0c 就会导致扫描不出来 在工程文件里面并列新建一个LIB文件夹用来存放 xff0c 把Inc和Src放进去 打开F

  • Linux服务器配置ulimit的常用参数介绍

    最近在小鸟云配置了一个Linux服务器 xff0c 实例是debian 7 5 系统 xff0c 在进行系统优化的过程中遇到一些有关Ulimit的事项 xff0c 整理了相关的参数介绍和配置介绍 xff0c 有需要可以简单看看 Ulimit

  • 【视觉检测C++接口实现】vs2019使用动态链接库yolo_cpp_dll调用yolov3

    目录 0 前言 1 准备工作 1 1 yolo cpp dll dll和yolo cpp dll lib的获取 1 2 pthreadGC2 dll和pthreadVC2 dll的获取 1 3 yolo v2 class hpp的获取 1

  • 【jetson nano】在ubuntu18.04下，c++调用链接库实现yolov3

    目录 0 前言 1 下载安装opencv 3 4 0 1 1 配置相应的以来库 1 2 下载opencv 3 4 0 xff08 源码 xff09 1 3 编译 xff08 时间较长 xff09 1 4 安装 1 5 配置opencv路径

  • 51单片机寄存器篇

    以下依次为IE IP TMOD TCON SCON寄存器结构 xff1a B7B6B5B4B3B2B1B0EA ET2ESET1EX1ET0EX0 B7B6B5B4B3B2B1B0 PT2PSPT1PX1PT0PX0 B7B6B5B4B3B

  • 单片机蓝桥杯——串口通信

    1 什么是串行 并行 单工 全双工 半双工 同步 异步 通讯的方式分类 xff1a 并行通信 串行通信 并行通信 xff1a 数据的各位同时在多根数据线上发送或接收 串行通信 xff1a 数据的各位在同一根数据线上逐位发送和接收7 并行通信

  • 串口、UART、USART、COM、USB、TTL、RS232、RS485、RS422简介

    串口 COM口 USB口是指的物理接口形式 xff08 硬件 xff09 xff1b TTL RS 232 RS 485 USB电平是指的电平标准 xff08 电信号 xff09 串口 UART口 USART口 COM口 USB口 xff0

  • 无线收发模块——NRF24L01

    1 什么是nRF24L01 nRF24L01是由NORDIC生产的工作在2 4GHz 2 5GHz的ISM 频段的单片无线收发器芯片 有着极低的电流消耗 nRF24L01与5V单片机的连接通过SPI接口进行通讯 xff0c 输出功率频道选择

  • 使用 monitor command 监控 QEMU 运行状态

    使用 monitor command 监控 QEMU 运行状态 在虚拟化的研究领域 xff0c QEMU 有着举足轻重的地位 2007 年 2 月发布的 Linux 2 6 20 内核中 xff0c 集成了 KVM 作为其虚拟化的具体实现

  • 基于STM32的多普勒雷达测速

    基于多普勒雷达传感器 xff0c 以STM32单片机为主控芯片 xff0c 根据不同模块检测距离的不同 xff0c 使用不同多普勒雷达传感器实现对远近距离车辆行驶速度及方向的测量 1 基础知识 雷达 雷达英文为Radar xff0c Rad

  • 语音合成芯片——SYN6658

    一 SYN6658 SYN6658是中文语音合成芯片 xff0c 通过UART 接口或SPI 接口通讯方式 xff0c 接收待合成的文本数据 xff0c 实现文本到语音的转换 可以采用GB2312 GBK BIG5 和Unicode 四种编

  • c++学习笔记（一）新手区分C语言、C++、VC++

    我认为第一件事需要跟各位说清楚的就是C语言和C 43 43 以及VC 43 43 之间的区别 特别是许多朋友一开始就喜欢下载使用VS xff08 Visual Studio xff09 xff0c 所以我认为这很有必要跟大家说清楚 xff0

随机推荐

  • Spring Secuirty 密码加密认证讲解

    目录 一 密码加密介绍 1 1 常见加密的策略 1 Hash 算法 2 单向自适应函数 二 Security加密结构 2 1 PasswordEncoder 2 2 密码认证流程 2 3 DeletaingPasswordEncoder 1

  • Gazebo添加动态障碍物插件及插件配置过程

    1 运行空白环境 43 添加动态障碍物 参考https blog csdn net zyh821351004 article details 128203687 actor标签范围内的模型配置 人会在多点间运动 span class tok

  • Linux多线程 | 线程同步

    文章目录 前言主要介绍四种常用的线程同步方式以及相关的函数接口 一 线程同步二 同步方法1 互斥锁2 信号量3 条件变量4 读写锁 总结 前言 主要介绍四种常用的线程同步方式以及相关的函数接口 提示 xff1a 以下是本篇文章正文内容 xf

  • Linux多线程 | 线程安全、多线程中执行fork()

    文章目录 前言一 线程安全二 线程安全函数1 以strtok为例子2 输出结果 三 多线程执行fork 1 主函数中执行fork 2 线程函数中执行fork 总结 前言 本篇文章主要讲述怎么保证线程安全 提示 xff1a 以下是本篇文章正文

  • Linux网络编程 | TCP详解

    文章目录 前言一 TCP是什么二 TCP粘包问题三 TCP怎么保证可靠性四 TCP三次握手 xff0c 四次挥手五 TCP状态转移图总结 前言 总结TCP相关问题 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一

  • Linux网络编程 | UDP编程

    文章目录 前言一 UDP是什么二 UDP 数据报服务特点二 UDP 编程流程1 服务器2 客户端3 输出结果 总结 前言 浅谈UDP 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一 UDP是什么 UDP是一种不可

  • Linux网络编程 | HTTP、Web服务器

    提示 xff1a 写完文章后 xff0c 目录可以自动生成 xff0c 如何生成可参考右边的帮助文档 文章目录 前言一 http协议二 请求报文三 应答报文四 实现简单的Web服务器1 代码如下2 输出结果 xff1a 总结 前言 介绍ht

  • Multipath多路径冗余全解

    一 什么是multipath 普通的电脑主机都是一个硬盘挂接到一个总线上 xff0c 这里是一对一的关系 而到了有光纤组成的SAN环境 xff0c 由于主机和存储通过了光纤交换机连接 xff0c 这样的话 xff0c 就构成了多对多的关系

  • Linux网络编程 | I/O复用之select

    文章目录 前言一 select二 API接口 xff1a 三 使用步骤1 服务器端2 客户端 总结 前言 select的原理以及使用 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一 select select系统

  • Linux网络编程 | I/O复用之poll

    文章目录 前言一 poll二 API接口三 使用步骤1 服务器端2 客户端 总结 前言 poll的原理以及使用 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一 poll poll 系统调用和 select 类似

  • Linux网络编程 | I/O复用之epoll(LT模式)

    文章目录 前言一 epoll二 常用API xff1a 三 使用步骤1 服务器端 xff08 LT模式 xff09 2 客户端 总结 前言 epoll原理以及使用 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一

  • Linux网络编程 | I/O复用之epoll(ET模式)

    文章目录 前言一 epoll的LT模式与ET模式二 使用步骤1 服务器端 xff08 ET xff09 2 客户端 总结 前言 epoll xff08 ET模式 xff09 以及使用方法 提示 xff1a 以下是本篇文章正文内容 xff0c

  • Linux网络编程 | Libevent库

    文章目录 前言一 libevent二 Libevent模型1 模型图2 结构图 三 支持事件类型四 使用libevent完成TCP服务器端1 服务器端 总结 前言 简单介绍libevent库以及使用 提示 xff1a 以下是本篇文章正文内容

  • Linux基础 | 守护进程

    文章目录 前言一 守护进程是什么 xff1f 二 编程流程三 使用步骤1 后台运行 xff0c 每隔五秒输出一次时间2 输出结果 总结 前言 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一 守护进程是什么 xff

  • C++ | shared_ptr与weak_ptr

    文章目录 前言一 shared ptr与weak ptr是什么 xff1f 1 shared ptr的内存模型2 weak ptr的内存模型 二 仿写系统的shared ptr与weak ptr1 mdeletor2 Ref con3 sh

  • C++ | lambda表达式

    文章目录 前言一 lambda是什么二 使用步骤总结 前言 简单介绍lambda表达式以及使用方法 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一 lambda是什么 lambda表达式是C 43 43 11最重

  • Linux基础 | 内存管理

    96 文章目录 前言一 准备工作1 存储器结构2 进程运行原理3 内存扩充技术 二 内存管理1 连续分配管理方式a 单一连续分配b 固定分区分配c 动态分区分配d 动态分区的分配策略 2 非连续分配管理方式 三 虚拟内存管理1 虚拟内存概念

  • C++ | C++中二维数组创建与初始化

    文章目录 前言一 使用步骤1 创建数组2 初始化 总结 前言 刷题时碰到需要用vector创建二维数组的情况 xff0c 简单记录一下 提示 xff1a 以下是本篇文章正文内容 xff0c 下面案例可供参考 一 使用步骤 1 创建数组 代码

  • group by与partition by用法

    本文采用Oracle数据库测试 xff0c 前4个查询为一组 xff0c 后2个查询为一组 xff0c 每组前面的查询是为了推出最后的查询 创建表 xff0c 为了简化处理 xff0c 字段类型都采用varchar create table

  • 算法 | 二分查找及其变种

    文章目录 前言一 二分查找二 数组完全有序且不重复1 第一题2 第二题 三 数组完全有序且重复1 第一题2 第二题 四 数组部分有序且不重复1 第一题2 第二题 五 数组部分有序且重复1 第一题2 第二题3 第三题 六 二维数组总结 前言

热门标签