y总算法基础课

最新推荐文章于 2024-04-28 20:34:10 发布
最新推荐文章于 2024-04-28 20:34:10 发布
阅读量1.6k 收藏 41
点赞数 4
文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45400340/article/details/127512397
版权

文章目录

第一章：基础算法

1.排序算法

1.1快排算法

//快排算法
    public static void quickSort(int[] arr,int start,int end){
        //递归终止条件:边界判断(只有一个点或者没有点的时候返回，一个点不用在排序)
        if(start>=end)return;
        
        //算法主体
        int stand=arr[start+end>>1];//标准数，即分界点，用来进行比较
        int left=start-1,right=end+1;
        while(left<right){
            //左指针移动
            do{
                left++;
            }while(arr[left]<stand);
            //右指针移动
            do{
                right--;
            }while(arr[right]>stand);
            
            //交换两个数
            if(left<right){
                int temp=arr[left];
                arr[left]=arr[right];
                arr[right]=temp;
            }
            
            
        }
        //递归处理左右两边
          quickSort(arr,start,right);
          quickSort(arr,right+1,end);
            
    }
    
}

1.2归并排序

 //归并排序
    public static void merge_sort(int[]arr,int left,int right){
        //递归终止条件:只有一个数时为有序，停止递归
        if(left>=right)return;
        //分界点，两个指针,临时数组接受排序后的数组
        int mid=left+right>>1;
        //递归处理左右两边
        //位置：处理上层，需要下一层是有序数组，故而如此
        merge_sort(arr,left,mid);
        merge_sort(arr,mid+1,right);
        //i:第一个数组头部，j：第二个数组头部，k：临时数组头部
        int i=left,j=mid+1,k=0;
        int[] temp=new int[right-left+1];
        //排序
        while(i<=mid && j<=right){//两个数组都未排完之时
        //两个数比较大小
        if(arr[i]<=arr[j]){
            //赋完值后两个指针向后移动一位
            temp[k++]=arr[i++];
        }else{
            temp[k++]=arr[j++];
        }
            
        }
        //对未完成的数组继续赋值
        while(i<=mid)temp[k++]=arr[i++];
        while(j<=right)temp[k++]=arr[j++];
        //将数组赋值回去:i指向数组起始位置，j指向temp起始位置
        for(int m=left,n=0;m<=right;i=m++,n++)arr[m]=temp[n];
        
    }

2.二分算法

2.1基本的二分

/*二分算法
*1.保持一个[]闭区间
*2.划分为3个区间  [left,mid-1],[mid,mid],[mid+1,right]
*3.根据不同的情况选择下一步搜索区间
*/

public int search(int[] nums, int target) {
        int left=0,right=nums.length-1;
        while(left<=right){//1.为什么是“<=”:因为维持的是一个[]闭区间，若left==right，则区                            //间中还有一个元素，需要再一次检索
            int mid=left+right>>1;
            if(nums[mid]==target){
                return mid;
            }else if(nums[mid]>target){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return -1;

    }

2.2左边界

//在一个非递减数组中寻找目标值的左侧边界，右侧边界可同理写出 
public static int left_bound(int[] nums,int target){
        int left=0,right=nums.length-1;
        while(left<=right){
            int mid=left+right>>1;
            if(nums[mid]==target){
                right=mid-1;//关键点：当找到目标值时，不急着返回，而是向左缩小区间，进一步向							//左探索
            }else if(nums[mid]>target){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        //判断left是否越界，该值是否存在
        //1.while循环终止时：right=left-1；
        if(left>=nums.length || nums[left]!=target)return -1;
        return left;
    }

3.大数加减

  • A,B:大整数

  • a,b:较小的整数。

  • A+B，A-B，A*a,A/a

  • 大整数的存储：使用数组，由个位开始存

14567798：8存在res[0],以此向后。

3.1大数相加模板

  • 大数相加方法
public static List<Integer> add(List<Integer> A,List<Integer> B){
        //存储结果的数组
        List<Integer> res=new ArrayList<>();
        //存储进位
        int t=0;
        for(int i=0;i<A.size() || i<B.size();i++){
            if(i<A.size())t=t+A.get(i);
            if(i<B.size())t=t+B.get(i);
            
            res.add(t%10);//本位数字
            t=t/10;//进位
            
        }
        //循环完之后，判断是否向更高进一位
        if(t!=0)res.add(1);
        return res;
        
    }
  • 字符串转换方法
 List<Integer>  A=new ArrayList<>(a.length());
 for(int i=a.length()-1;i>=0;i--)A.add(a.charAt(i)-'0');

3.2大数相减

//高精度减法
/*1.比较两个数的大小
*    若A>B,则正常进行，否则，return sub（B,A）
* 2.  
*
*/
    public static List<Integer> sub(List<Integer> A,List<Integer> B){
     if(!cmp(A,B))return sub(B,A);
     //存储结果的列表
     List<Integer> res=new ArrayList<>();
     int t=0;
     for(int i=0;i<A.size();i++){
         t=A.get(i)-t;
         if(i<B.size())t=t-B.get(i);
         res.add((t+10)%10);
         
         if(t<0)t=1;
         else t=0;
         
     }
     //删除指定下标的值
     while(res.size()>1 && res.get(res.size()-1)==0)res.remove(res.size()-1);
     return res;
     
    }
  • 大数比较
//大数比较：先比位数，再从高位逐一比较
public static boolean cmp(List<Integer> A,List<Integer> B){
        //2.1位数比较
        if(A.size()!=B.size())return A.size()>B.size();
        //2.2从高位比起
        for(int i=A.size()-1;i>=0;i--){
            if(A.get(i)!=B.get(i))return A.get(i)>B.get(i);
            }
            return true;
            
        }

3.3大数相乘

  • 一个大数与一个小整数相乘
  • 主要规则：将大整数A的每一位与b整体相乘
//大整数乘法
/*1.初始进位为0
 *2.A的每一位与b整体相乘
 *		答案对应位为  (Ai*b+t)%10
 *      进位更新为t/10
 */ 
public static List<Integer> mul(List<Integer> A,int b){
        List<Integer> res=new ArrayList<>();
        int t=0;
        for(int i=0;i<A.size() || t!=0;i++){//有进位或者存在乘数都要继续进行
         if(i<A.size())t=t+A.get(i)*b;
         res.add(t%10);
         t=t/10;
        }
        //如果b为0，则要清除前导0
        int n=res.size();
        while(res.size()>1){
            if(res.get(n-1)==0){
                res.remove(n-1);
                
            }else{
                break;
                
            } 
            n=res.size();
        }
        return res;
        
    }

3.4大数除法

//大数除法 
public static List<Integer> div(List<Integer> A,int b){
        List<Integer> res=new ArrayList<>();
        int t=0;
        for(int i=A.size()-1;i>=0;i--){
           t=t*10+A.get(i);
           res.add(t/b);
           t=t%b;
        }
        Collections.reverse(res);
        //去除前导0
        while(res.size()>1 && res.get(res.size()-1)==0)res.remove(res.size()-1);
        res.add(t);//最后一位记录余数
        return res;
    }

4.前缀和差分

4.1一维前缀和

  • 数列前缀和
  • 定义S[0]=0:更好的解决边界问题
/*一维数组的前缀和
*1.维护：s[i]=s[i-1]+a[i]
*2.[l,r]区间和：s[r]-s[l-1];
*3.前缀和下标从1开始，避免下标的转换
*4.s[0] = 0
*  s[1] = s[0]+a[1]
*  s[2] = s[1] + a[2]
*/

4.2二维前缀和

  • 0行0列空出
  • Sij 的计算：分行计算
//计算公式
S[i][j]=S[i-1][j]+S[i][j-1]-S[i-1][j-1]+a[i][j]
  • （x1,y1）与(x2,y2)之间的所有数的和。
S[x2][y2]-S[x1-1][y2]-S[x2][y1-1]+S[x1-1][y1-1];

4.3差分数组

  • 下标从1开始计算

  • 前缀和的逆运算：即构造一个前缀和为已知数组A的数组b

  • 作用：让指定区间 [l,r] 内所有的数加上C；

5.双指针算法

核心思想在于，利用数列某种单调性质，将降低算法复杂度

  • 指向两个数列
  • 指向同一个数列
    • 同向
    • 反向

第二章：数据结构

  • 链表
  • 栈与队列
  • KMP

1.链表

1.1单链表

这里我们有用两个数组来模拟单链表的实现，两个数组通过下标关联起来

  • e[i]:存储节点i的val值

  • ne[i]:存储节点的指针

在这里插入图片描述

import java.util.*;
import java.io.*;
//只可向后遍历
class Main{
    public static int N=100010;
    //head:头节点下标
    //e[i]:节点的val
    //ne[i]:节点i的next
    public static int head=-1;
    public static int[] e=new int[N];
    public static int[] ne=new int[N];
    public static int idx=0;//存储当前已经用到的地址（指针）
    public static void main(String[] args)throws IOException{
        //1.将单链表初始化
        init();
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        while(m-->0){
            //因为java中没有输入一个字符，所以用字符串转字符
            String s=sc.next();
            char op=s.charAt(0);
            if(op=='H'){
                int val=sc.nextInt();
                addHead(val);
            }else if(op=='D'){
                int k=sc.nextInt();
                if(k==0)head=ne[head];
                else delete(k-1);//第k个插入数，索引
            }else{
                int k=sc.nextInt();
                int val=sc.nextInt();
                insert(k-1,val);
            }
        }
        //输出
        for(int i = head;i != -1;i = ne[i] ){
            System.out.print(e[i] +  " ");
        }
        
    }
    //方法体
    //1.初始化
   public static void init(){
        head=-1;
        idx=0;
    }
    //2.插入
    public static void addHead(int val){
        e[idx]=val;//先将对应值进行存储
        ne[idx]=head;//新节点指向第一个节点
        head=idx;//head指向新节点
        idx++;//指向下一个使用的位置
    }
    //3.将val插入下标为k的节点后面
   public static void insert(int k,int val){
        e[idx]=val;
        ne[idx]=ne[k];
        ne[k]=idx;
        idx++;
    }
    //4.删除下标为k后面的点删除
    public static void delete(int k){
        ne[k]=ne[ne[k]];
    }
    
}

1.2双链表

我们依旧使用数组进行模拟

  • e[i]:节点i的val
  • l[i]:节点i的左指针
  • r[i]:节点i的右指针
  • idx：指向当前可用区间

1.3邻接表

实际上就是单链表

2.栈与队列

  • 栈：先进后出
  • 队列：先进先出

2.1栈的实现

  • 栈的常见操作
    • Stack():构造方法
    • boolean isEmpty():判空操作
    • int size（）：返回栈中元素数量
    • void push（int x）:压入，
    • int pop():弹出
    • int peek（）：查看栈顶元素
  • 栈的数组模拟实现
/*
*/
import java.util.*;
import java.io.*;
class Main{
    public static int N=100010;
    
    public static int[] st=new int[N];//数据存储
    public static int top=-1;//栈顶指针,指向栈顶元素
    public static int n;
   
    //压入
    public static void push(int val){
        st[++top]=val;
    }
    //弹出
    public static int pop(){
        return st[top--];
    }
    //判空
    public static boolean isEmpty(){
        return top<0;
    }
    //弹出
    public static int peek(){
        if(isEmpty()){
            System.out.println("栈为空");
            return -1;
        }else{
            return st[top];
        }
    }
    
}

 public static void main(String[] args)throws IOException{
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        // System.out.println(m);
        while(m-->0){
            String s=sc.next();
            if(s.equals("push")){
                int val=sc.nextInt();
                push(val);
               
            }else if(s.equals("pop")){
                pop();
                
            }else if(s.equals("empty")){
                if(isEmpty()){
                    System.out.println("YES");
                }else{
                    System.out.println("NO");
                }
                
            }else{
                System.out.println(query());
                
            }
        }
        
    }
  • 使用Deque
Deque<Integer> stack=new Deque<>();
//压入
void push()
//弹出
int   pop()
//判空
boolean isEmpty()
//栈中元素数量
int size()
//查看栈顶
int peek()

2.2单调栈

  • 给定一个序列，求序列中每一个数左边最近的比他小的数，没有则返回-1；
  • 示例

​ 3 4 2 7 5

ans：-1 3 -1 2 -1

//单调栈写法
int[] nextGreaterElement(int[] nums) {
    int n = nums.length;
    // 存放答案的数组
    int[] res = new int[n];
    Deque<Integer> s = new ArrayDeque<>(); 
    // 主体部分
    for (int i =0; i <n; i++) {
        // 判定个子高矮
        while (!s.isEmpty() && s.peek() <= nums[i]) {
            // 矮个起开，反正也被挡着了。。。
            s.pop();
        }
        //对应答案操作
        res[i] = s.isEmpty() ? -1 : s.peek();
       //将所有比自己小的元素弹出后，自己压入
        s.push(nums[i]);
    }
    return res;
}

2.3队列的实现

  • 先进先出
/*1.队列常用方法
*Boolean isEmpty():判空
*int  size()：元素数量
*void offer(val):入队
*int poll():出队
*int  peek():出队
*/
  • 数组模拟
import java.util.*;
import java.io.*;
class Main{
    //一个数组，两个指针，队尾入，对头出
    public static int N=100010;
    public static int[] q=new int[N];
    public static int tt=-1;//队尾
    public static int hh=0;//队头
    
    //插入
    public static void push(int val){
        q[++tt]=val;
    }
    //pop()
    public static int pop(){
        return q[hh++];
    }
    //判空
    public static boolean isEmpty(){
        return hh>tt;
    }
    //查询
    public static int query(){
        if(isEmpty()){
            System.out.println("队列为空");
            return -1;
        }else{
            return q[hh];
        }
    }
}
  • 主方法
public static void main(String[] args)throws IOException{
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        // System.out.println(m);
        while(m-->0){
            String s=sc.next();
            if(s.equals("push")){
                int val=sc.nextInt();
                push(val);
            }else if(s.equals("pop")){
                pop();
            }else if(s.equals("empty")){
                if(isEmpty()){
                    System.out.println("YES");
                }else{
                    System.out.println("NO");
                }
            }else{
                System.out.println(query());
            }
        }
        
    }
  • 用链表实现
Queue<Integer> q=new LinkedList<>();
//入队
void offer(val)
//出队
int poll()
//判空
boolean isEmpty()
 //查看
 int peek()

2.4单调队列

  • 求滑动窗口里的最大值，或最小值

3.KMP算法

3.1基本概念

KMP算法是一个优化后的字符匹配算法。优化的核心要点：在匹配失败是并不是将p向后移动一位进行匹配，二十向后移动多位（next数组决定）

  • s[]:模式串，即比较长的字符串
  • p[]:模板串，即比较短的字符串
  • 部分匹配值：前缀后缀最长共有元素的长度
    • 前缀：不包含最后一个字符的所有以第一个字符开头的连续子串；
    • 后缀：不包含第一个字符的所有以最后一个字符结尾的连续子串
  • next[i]:p[1,j]的部分匹配值；下标从1开始，存储每一个下标对应的部分匹配值,只与模板串有关

3.2next数组

  • 手动求解
pabcab
下标12345
next[]00012

next[1]:一个字母,前缀后缀皆为空，0

next[2]:前缀={a};后缀={b};0

next[3]:前缀={ab,a};后缀={bc,b};0

next[4]:前缀={abc,ab,a};后缀={bca,ca,a};1

next[5]:前缀={abca,abc,ab,a};后缀={bcab,cab,ab,a}:2

  • 代码实现
 /**实质上是自己与自己的匹配
         * ne[]：存储一个字符串以每个位置为结尾的‘可匹配最长前后缀’的长度。
         * 构建ne[]数组：
         *              1,初始化ne[1] = 0,i从2开始。
         *              2,若匹配，s[i]=s[j+1]说明1~j+1是i的可匹配最长后缀,ne[i] = ++j;
         *              3,若不匹配，则从j的最长前缀位置+1的位置继续与i比较
         *              (因为i-1和j拥有相同的最长前后缀，我们拿j的前缀去对齐i-1的后缀),
         *              即令j = ne[j],继续比较j+1与i，若匹配转->>2
         *              4,若一直得不到匹配j最终会降到0，也就是i的‘可匹配最长前后缀’的长度
         *              要从零开始重新计算
         */
//定义一个全局变量用来存储next
public static int N=10010;//根据数值范围确定
public static int[] ne=new int[N];//next数组
  public static void next(char[] chs,int n){
          for(int i = 2,j = 0;i <= n ;i++) {
            while(j!=0&&chp[i]!=chp[j+1]) j = ne[j]; 
            if(chp[i]==chp[j+1]) j++;
            ne[i] = j;
        }
        
    }

3.3匹配过程

  • 两个字符串的匹配过程
  • 当失配时不是向后移动一位而是
 if(next[i]>1){
　　允许跳过的字符数量 = 匹配长度 - 部分匹配表[匹配长度];//适用next数组下标从1开始的情况
  }else　{
　　允许跳过的字符数量 = 部分匹配表[匹配长度];
　}

1.为什么要进行这样移动？

举个例子：

长串：s=bacbababaabcbab

短串：p=abababca

在这里插入图片描述

此时失配：黄框=绿框；蓝框=黄框；——》蓝框=绿框。所以可以进行这样的移动减少匹配次数

2.每次失配时移动的数量如何确定？

每次失配时我们需要移动至：红线前只剩next[部分匹配长度]，所以

移动数量（跳过字符串数量）=匹配长度 - next[匹配长度]

3.这样的过程会造成答案的丢失么？

这里我们选取的是前后缀共有的最长长度，所以移动数量就是最小的，所以不会有答案的丢失。

/**
         * 匹配两个字符串：
         *      1，从i=1的位置开始逐个匹配，利用ne[]数组减少比较次数
         *      2，若i与j+1的位置不匹配（已知1~j匹配i-j~i-1)，
         *      j跳回ne[j]继续比较(因为1~j匹配i-j~i-1,所以1~ne[j]也能匹配到i-ne[j]~i-1)
         *      3，若匹配则j++,直到j==n能确定匹配成功
         *      4，成功后依然j = ne[j],就是把这次成功当成失败，继续匹配下一个位置
         */
public static void match(char[] chp,int n,char[] chs,int m,BufferedWriter bw)throws IOException{
         for(int i = 1,j = 0; i <= m;i++) {
            while(j!=0&&chs[i]!=chp[j+1]) j = ne[j];
            if(chs[i]==chp[j+1]) j++;
            if(j==n) {
                j = ne[j];
                bw.write(i-n+" ");
            }
        }
        
    }

4.Trie树

  • 用来高效的存储和查找字符串集合的数据结构

4.1存储与查找

1.存储方式

假设存储字符串集合{abcdef,abdef,aced,bcdf,bcff,cbaa,bcdc}
在这里插入图片描述

  1. 现在根节点之下查找是否存在第一个字母

    2.若存在，在该节点之下重复1

​ 否则，创捷该字母1，然后在字母1下重复以上操作

  • 存储abcd

1.读取第 i 个（1个）字母 a（对应数字0）

2.查看 son [0] [0] 是否存在（不存在则为0）

​ 不存在，在son[0] [0]存入 本字符的下一行（++idx）

3.令k=son[0] [0],（进入对应的下一行）。

4.重复以上操作

2.查找

  • 查找acbd

1.读取第 i 个（1）字母 a(对应0)

2.查看 son[0] [0] (son[k] [u], u为字母对应的数字，K为当前节点位置，存储的值为下一节点行序号) 是否存在

​ 不存在返回0

​ 存在继续3

3.存在，令k=son[0] [0] ,重复以上操作

4.返回 cnt[k].

在这里插入图片描述

 //成员变量
static int N=200010;
static int idx=0;//指针，指向下一个字母存储的行序号(未存储过字母的行)
static int[][] son=new int[N][26];//最多存储26个字母（节点的宽度）
static int[] cnt=new int[N];


//方法体
//插入
public static void insert(String str){
    char[] ch=str.toCharArray();
    int k=0,i=0;//i指向ch数组
    //遍历ch数组
    while(i<ch.length){
        //读取当前字母后，i向后移动
        int u=ch[i++]-'a';
        if(son[k][u]==0){
            son[k][u]=++idx;
        }
        k=son[k][u];
        
    }
    //存储完一个单词后做标记
    cnt[k]++;
}
//查询
  static int query(String str){
    char[] ch=str.toCharArray();
    int i=0,k=0;
    while(i<ch.length){
        int u=ch[i++]-'a';
        if(son[k][u]==0)return 0;
        k=son[k][u];
    }
    return cnt[k];
    
}

5.并查集

  • 合并集合
  • 查询某一个元素是否在两个集合中

5.1合并集合

  • 基本原理：使用树来表示集合。
    • 树根编号就是节点编号
    • 每个节点存储他的父节点，p[x]表示x的父节点

1.如何判断树根？

if(p[x]==x)

2.如何求x的集合编号？

while(p[x]!=x)x=p[x]

3.如何合并两个集合

px是x的集合编号，py是y的集合编号

p[x]=y:

6.堆

  • 手写堆

1.insert():插入一个数

2.min():求集合最小值

3.deletemin():删除最小值

#间接实现

4.delete（）：删除任一元素

5.change（）：修改任一元素

  • 小根堆：根<=左右儿子
  • 堆的存储：使用一维数组进行存储
    • 1为根节点
    • 左儿子：2x
    • 右儿子：2x+1

6.1堆排序

  • 基本思路：先把数据构造成一个小根堆，每次都输出堆顶元素

7.哈希表

  • 存储结构
    • 开放寻址法
    • 拉链法
  • 字符串哈希方式

7.1Hash函数

  • -10^9 ~10^9 ——》 0<= h(x) <=10^5
  • 冲突解决
    • 拉链法
    • 开放寻址法
  • 常见的hash：x mod 10^5：模尽量选去质数，距离2的整数次方近

拉链法
在这里插入图片描述

将冲突的值，并行存储在同一个hash值下

甚也不会
关注
  • 4
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基础电子中的YMD系列蜂鸣器
11-23
YMD系列蜂鸣器为微型电磁式有源蜂鸣器，只要接通直流电源，便会发出连续或断续的声响。该系列蜂鸣器具有声音清晰、声压高、节奏分明、全密封、可波峰焊等特点。YMD系列蜂鸣器的主要技术特性参数见表1。 　　表1 YMD系列蜂鸣器主要技术特性参数   
递归求数组最大最小元素（分治法）
04-24
递归求数组最大最小元素。
模拟电路中什么是Y电容？
08-21
本文主要简单介绍了模拟电路中什么是Y电容
Y电容容量不能太大的原因
08-06
一、Y电容 Y电容是安规电容的一种，安规电容是指用于这样的场合：即电容器失效后，不会导致电击也不会不危及人身安全。也就是因为这样安规电容与其他普通的电容有着不一样的地方，普通的电容在电源断开之后很长一段时间还会保留一定残留电压，一旦手触碰到就会发生电击，而安规电容却不会。Y电容大多数为蓝色，但是也有黄色的，由于是安全电容，因此Y电容上面一般都会标有相关的认证，例如CQC、VDE、UL等认证。如下图 Y电容通常接于零线与地或者火线与地之间，如下图是I级EMI滤波电路，Y1和Y2是Y电容，通常两个串联一起，根据耐高压分为Y1、Y2、Y4三个等级，其中：Y1电容耐高压值＞8kV；5kV＜Y2电容耐高压值＜小于8kV；2.5kV＜Y4电容耐高压值＜小于5kV 二、漏电流 对于开关电源，Y电容通常接于一次侧（初级）与二次侧（次级）之间，如下图，Y电容器可为一次侧耦合到二次侧的干扰电流提供回流路径 那么Y电容容量为什么不能太大呢？我们知道Y电容对于EMC有很大的帮助，由于是共模电容，因此需要接地，那么就会有一个漏电流，还是以上面的EMI滤波电路为例，Y电容漏电流I=2πfCU
AcWing-算法提高课【合集】
热门推荐
violet的博客
08-29 1万+
先打基础再提高
Acwing《算法基础课》第1章 算法基础
weixin_45769709的博客
10-06 1142
Acwing《算法基础课》第1章 算法基础 文章目录Acwing《算法基础课》第1章 算法基础排序快速排序归并排序二分整数二分浮点数二分高精度计算大整数存储大整数比较高精度加法高精度减法高精度乘法高精度除法前缀和一维前缀和二维前缀和差分一维差分二维差分双指针算法位运算离散化区间合并 排序 快速排序 主要思想： 确定分界点： x = a[l] x = a[r] q = a[(l + r) / 2] 调整范围： 左边<=x 右边>x 递归处理左边和右边 模板： void quick
算法-百度云盘
qq_29257691的博客
10-11 2137
链接：https://pan.baidu.com/s/1DE2wARuiyngPYdW7YPUYGQ 提取码：6doh 复制这段内容后打开百度网盘手机App，操作更方便哦
y总排序算法模板汇总（持续更新）
ll38zz的博客
07-18 1135
1、快速排序 void quick_sort(int q[],int l,int r){ if(l>=r) return; int i=l-1,j=r+1,x=q[l]; while(i<j){ do i++; while(q[i]<x); do j--; while(q[j]>x); if(i<j) swap(q[i],q[j]); } quick_sort(q,l,j); q
[ACWing算法基础课]：第五章 - 动态规划
TBD的博客
02-15 2893
目录==背包问题 ★★★==（1） 0-1 背包问题（2）完全背包问题（3）多重背包问题（4）分组背包问题==线性DP ★★==（1）数字三角形（2）最长上升子序列 - LIS（3）最长公共子序列 - LCS（4）other - 最短编辑距离区间DP石子合并计数DP整数划分记忆化搜索滑雪 背包问题 ★★★ （1） 0-1 背包问题 （2）完全背包问题 （3）多重背包问题 （4）分组背包问题 线性DP ★★ （1）数字三角形 （2）最长上升子序列 - LIS （3）最长公共子序列 - LCS （4）other
快速排序
yshir
11-16 100
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 步骤为： 从数列中挑出一个元素，称为"基准"（pivot）， 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准
CFD_计算y+小程序
06-20
y+是y处漩涡的典型雷诺数（无量纲数），也反映了粘性影响随y的变化。如上面一位知友所述，根据y+的大小，可以将湍流边界层分为好多层，当y+很小时，流体紧贴壁面，在壁面上流体的脉动速度为零，雷诺应力很小，粘性...
500Y触发电路原理图
07-17
500Y触发电路原理图如下（额定电压：500V，触发变压器：斯坦考P6426）：
Y总基础算法课day2
qq_37473792的博客
02-10 537
高精度加法的思想，高精度加法是为了计算长度非常长的数而存在的，比如计算的结果超过int型能表示的变量的时候，这时候就需要进行高精度加法的运算了，算法的思想是基于用数组去拆分原字符串的，从0-N分别从数的低为到高位这样方便低为的进位传入高位。高精度减法的计算和高精度加法的计算其实非常的类似，相比于高精度加法的进位而言，高精度减法就需要进行减法的借位，具体的算法如下。高精度的除法也是大数除上一个整数的，但是相比于人而言，计算机会更加的傻一些，它必须从最高位开始，步骤如下。1.保存当前长数组的最高位到0的位置。
我最爱的yyyyy总基础算法 studying note
xzzj12的博客
03-29 207
基础算法经典排序快速排序快速选择算法归并排序二分查找 经典排序 快速排序 #include<iostream> using namespace std; const int N=1e6+10; void quick_sort(int q[],int l,int r){ int i=l-1,j=r+1; int x=q[l]; if(l>=r)return;//表示左右区间中只有一个数或没有数 while(i<j){ do i++;w
一篇适合大一同学的算法学习建议
QDQE232的博客
09-07 2285
在看这篇文章之前，可能你才刚刚进入大一，你在上大学之前可能听过一些学历不好，绩点不高进大厂的同学分享的经验，在去年21年和21年以前国家经济向好的时候，这，确实是真实的情况。但是随着疫情的加剧，国家经济受到冲击，今年23届各大厂的秋招HC比往年少了许多，几年后的形势未定，一味卷技术卷算法轻绩点意味着一种很高的风险，希望读者在上大一的时候还是以学校的课程绩点为主，学有余力可以试一试算法，打一打比赛，为将来做准备。学习资源的建议学习网站：acwing。
2021-12-29每日刷题打卡
AnubisL的博客
12-29 248
一、今日份—Y总视频 二、LeetCode:72. 编辑距离 (1)问题描述 给你两个单词word1 和word2，请你计算出将word1转换成word2 所使用的最少操作数。 你可以对一个单词进行如下三种操作： 插入一个字符 删除一个字符 替换一个字符 示例1： 输入：word1 = "horse", word2 = "ros" 输出：3 解释： horse -> rorse (将 'h' 替换为 'r') rorse -> rose...
Acwing_算法基础课_1
qq_60955261的博客
06-08 172
y总算法基础课，一些基础算法的板子
C++ stl容器详解(y总算法基础课 stl 容器 笔记记录)
weixin_63534072的博客
03-04 232
STL 容器， y总stl讲解笔记
Rapidly exploring Random Trees(RRT)类算法
最新发布
qq_35635374的博客
04-28 224
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对Rapidly exploring Random Trees(RRT)类算法做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容（1）优点快速随机树算法是一种较为迅捷搜索的方式，增量式的构建树其优点明显，主要体现在针对性的找一条从起点到终点的路径其较强较快的搜索能力，【防盗标记–盒子君hzj】并且运用快速拓展随机树的路径规划对路径运行环境没有限制要求。（2）缺点。
emi基础及无y电容手机充电器设计
07-06
EMI (Electromagnetic Interference) 是指电子设备在操作中产生的电磁干扰。在设计无 y 电容手机充电器时，需要注意如下几个方面来控制EMI基础： 1. 降低开关频率：降低开关频率能减少EMI的产生。通过选择适宜的电感和电容参数，可以降低充电器的共模噪声，减少EMI的辐射。 2. 使用滤波器：在充电器的输入端和输出端加入滤波器来抑制EMI。输入端的滤波器可以防止来自电网的EMI干扰进入充电器电路，输出端的滤波器可以减少充电器输出信号的高频噪声。 3. 地线设计：良好的地线设计有助于消除EMI。保持地线短小直接并且良好连接，减少地线回线循环区域，从而减少EMI的发生。 4. 屏蔽和隔离：充电器电路的关键部分可以采用金属屏蔽罩进行屏蔽，防止EMI的辐射。此外，通过增加隔离距离，可以减少EMI的传播。 5. 合规测试：设计完成后，要进行EMI测试以确保充电器符合相关的国际和地区规范。根据测试结果，可以对设计进行调整和优化，以满足EMI标准的要求。 无 y 电容手机充电器设计是指在手机充电器中去除 y 电容设计。传统手机充电器电路中常采用 y 电容滤波器，用于抑制EMI。但是，去除 y 电容设计可以降低成本和尺寸，同时简化设计，从而提高充电器的可靠性。 去除 y 电容设计可以通过其他控制EMI的方法来实现，如利用适当的磁性元件和电容器组合选择，采用合适的输入和输出端滤波器等。同时，还需要对整个充电器电路进行优化和测试，确保充电器在保证其性能的同时，满足相关的EMI标准和要求。 总之，通过合理的EMI基础设计和无 y 电容设计，可以有效地控制充电器产生的EMI干扰，提高充电器的性能和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值