Java常见算法(二)

最新推荐文章于 2022-12-08 20:38:30 发布
最新推荐文章于 2022-12-08 20:38:30 发布
阅读量632 收藏 1
点赞数
分类专栏： 算法 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YL3126/article/details/121241766
版权

文章目录

一、数组中找出两数之和为给定值的数组下标

https://www.bilibili.com/video/BV1Jv411A7Ty?p=10
https://www.bilibili.com/video/BV1Jv411A7Ty?p=11
给定一个整数数组 numbers , 从数组中找出两个数满足相加之和等于目标数target。
假设每个输入值对应唯一的答案，而且不可以重复使用相同的元素。
返回两数的下标值，以数组形式返回。

1、暴力算法

  //1.暴力算法
    public static int[] solution(int[] nums,int target){
        for (int i=0;i<nums.length;i++){
            for (int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[0];
    }

2、数组标记算法

    //2.数组标记算法 ，时间复杂度 O（N）
    public static int[] solution1(int[] nums,int target){
        Map<Object, Object> map = new HashMap<>();
        for (int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                return new int[]{(int)map.get(target-nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int[0];
    }

3、二分法

 //3.二分法。（二分法的前提条件必须是有序）,时间复杂度为  O(NlogN)
    public static int[]  twoSearch(int[] nums,int target){
        for (int i = 0; i <nums.length ; i++) {
            int low=i,high=nums.length-1;
            while (low<=high){
                int mid=(high-low)/2+low;
                if(nums[mid]==target-nums[i]){
                    return new int[]{i,mid};
                }else if(nums[mid]>target-nums[i]){
                    //右指针左移
                    high=mid-1;
                }else{
                    low=mid+1;
                }
            }
        }
        return null;
    }

4、双指针

//4.双指针（最优）（前提条件必须是有序）
    public static int[] doublePointer(int[] nums,int target){
        int i=0;//左指针
        int j=nums.length-1;//右指针
        while (i<j) {
            if(nums[i]==target-nums[j]){
                return new int[]{i,j};
            }else if(nums[i]>target-nums[j]){
                j--;
            }else{
                i++;
            }
        }
        return null;
     }

源码实验：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@SpringBootTest
/**
    两数之和
    给定一个整数数组 numbers , 从数组中找出两个数满足相加之和等于目标数target。
    假设每个输入值对应唯一的答案，而且不可以重复使用相同的元素。
    返回两数的下标值，以数组形式返回。
 */
class SuanfaApplicationTests7 {

    //1.暴力算法
    public static int[] solution(int[] nums,int target){
        for (int i=0;i<nums.length;i++){
            for (int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[0];
    }

    //2.数组标记算法 ，时间复杂度 O（N）
    public static int[] solution1(int[] nums,int target){
        Map<Object, Object> map = new HashMap<>();
        for (int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                return new int[]{(int)map.get(target-nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int[0];
    }

    //3.二分法。（二分法的前提条件必须是有序）,时间复杂度为  O(NlogN)
    public static int[]  twoSearch(int[] nums,int target){
        for (int i = 0; i <nums.length ; i++) {
            int low=i,high=nums.length-1;
            while (low<=high){
                int mid=(high-low)/2+low;
                if(nums[mid]==target-nums[i]){
                    return new int[]{i,mid};
                }else if(nums[mid]>target-nums[i]){
                    //右指针左移
                    high=mid-1;
                }else{
                    low=mid+1;
                }
            }
        }
        return null;
    }

    //4.双指针（最优）（前提条件必须是有序）
    public static int[] doublePointer(int[] nums,int target){
        int i=0;//左指针
        int j=nums.length-1;//右指针
        while (i<j) {
            if(nums[i]==target-nums[j]){
                return new int[]{i,j};
            }else if(nums[i]>target-nums[j]){
                j--;
            }else{
                i++;
            }
        }
        return null;
     }

    @Test
    public void sf0(){
        int[] nums=new int[]{2,3,4,6,5,1,2,3};
        System.out.println(Arrays.toString(solution(nums,10)));
        System.out.println(Arrays.toString(solution1(nums,10)));

        Arrays.sort(nums);//二分法、双指针的前提条件就是数组有序
        System.out.println(Arrays.toString(twoSearch(nums,10)));
        System.out.println(Arrays.toString(doublePointer(nums,10)));
    }

}

结果：

//这里注意一下，这里找到的都是数组下标！
[5, 7]
[5, 7]
[2, 3]
[2, 3]

二、斐波那契数列

https://www.bilibili.com/video/BV1Jv411A7Ty?p=12
求取斐波那契数列第 N 位的值
斐波那契数列：每一位的值等于他前两位数字之和。前两位固定： 0，1，1，2，3，5，8，13,21…

1、去重递归

在这里插入图片描述
在这里插入图片描述

//1、去重递归
    public static int fbnq(int n){
        //我们定义一个数组
        int[] arr=new int[n+1];
        return recurse(arr,n);
    }
    //递归函数
    private static int recurse(int[] arr,int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        //去重递归其实关键的就是这个判断，看看之前是否已经有了这个数
        if(arr[n]!=0){
            return arr[n];
        }
        arr[n]=recurse(arr,n-1)+recurse(arr,n-2);
        return arr[n];
    }

2、双指针迭代

//2、双指针迭代(推荐)
    private static int iterate(int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        int low=0,h=1;
        for (int i = 2; i <=n ; i++) {
            int sum=low+h;
            low = h;
            h=sum;
        }
        return h;
    }

实验源码：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@SpringBootTest
/**
    斐波那契数列
    求取斐波那契数列第 N 位的值
    斐波那契数列：每一位的值等于他前两位数字之和。前两位固定： 0，1，1，2，3，5，8，13,21......
 */
class SuanfaApplicationTests8 {

    //1、去重递归
    public static int fbnq(int n){
        //我们定义一个数组
        int[] arr=new int[n+1];
        return recurse(arr,n);
    }
    //递归函数
    private static int recurse(int[] arr,int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        //去重递归其实关键的就是这个判断，看看之前是否已经有了这个数
        if(arr[n]!=0){
            return arr[n];
        }
        arr[n]=recurse(arr,n-1)+recurse(arr,n-2);
        return arr[n];
    }

    //2、双指针迭代(推荐)
    private static int iterate(int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        int low=0,h=1;
        for (int i = 2; i <=n ; i++) {
            int sum=low+h;
            low = h;
            h=sum;
        }
        return h;
    }

    @Test
    public void sf0(){
        System.out.println(fbnq(10));

        System.out.println(iterate(10));
    }

}

实验结果：

55
55

三、硬币排列问题

https://www.bilibili.com/video/BV1Jv411A7Ty?p=13
假设有n枚硬币，阶梯摆放：第一行放1个，第二行放2个；第三行放3个…第m行放m 个；

1、迭代法

  public static int arraangeConins(int n){
        for (int i = 0; i <=n ; i++) {
            n=n-i;
            if(n<i){
                return i;
            }
        }
        return 0;
    }

2、二分查找

public static int arraangeConins2(int n){
        int low=0,high=n;
        while (low<=high){
            int mid=(high-low)/2+low;
            int cost=((mid+1)*mid)/2;
            if(cost==n){
                return mid;
            }else if(cost>n){
                high=mid-1;
            }else {
                low=mid+1;
            }
        }
        return high;
    }

3、牛顿迭代

//3、牛顿迭代
    public static int arraangeConins3(int n){
        if(n==0){
            return 0;
        }
        return (int) sqrt(n,n);
    }
    //迭代
    public static double sqrt(double x,int n){
        double res=(x+(2*n-x)/x)/2;
        if(res==x){
            return x;
        }else {
            return sqrt(res,n);
        }
    }

实验源码：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
/**
    硬币排列问题
    假设有n枚硬币，阶梯摆放：第一行放1个，第二行放2个；第三行放3个.....第m行放m 个；
 */
class SuanfaApplicationTests9 {

    //1.迭代法
    public static int arraangeConins(int n){
        for (int i = 0; i <=n ; i++) {
            n=n-i;
            if(n<i){
                return i;
            }
        }
        return 0;
    }

    //2.二分查找
    public static int arraangeConins2(int n){
        int low=0,high=n;
        while (low<=high){
            int mid=(high-low)/2+low;
            int cost=((mid+1)*mid)/2;
            if(cost==n){
                return mid;
            }else if(cost>n){
                high=mid-1;
            }else {
                low=mid+1;
            }
        }
        return high;
    }

    //3、牛顿迭代
    public static int arraangeConins3(int n){
        if(n==0){
            return 0;
        }
        return (int) sqrt(n,n);
    }
    //迭代
    public static double sqrt(double x,int n){
        double res=(x+(2*n-x)/x)/2;
        if(res==x){
            return x;
        }else {
            return sqrt(res,n);
        }
    }

    @Test
    public void sf0(){
        System.out.println(arraangeConins(10));
        System.out.println(arraangeConins2(10));
        System.out.println(arraangeConins3(10));
    }

}

结果：

4
4
4

四、判断链表中是否有环，有环返回true ，没环返回false；

https://www.bilibili.com/video/BV1Jv411A7Ty?p=14

1、直接遍历判断是否有环

判断一个节点是否出现过两次，可以使用 HashSet 的特性,set中相同元素只能有一个

   public static boolean hasCycle (LinkNode head){
        HashSet<LinkNode> linkNodes = new HashSet<>();
        while (head!=null){
            //根据HashSet的特性，追加不进去证明该节点已经存在，则链表有环，这季节返回true即可
            if(!linkNodes.add(head)){
                return true;
            }
            head = head.next;
        }
        return false;
    }

2、双指针

快指针先进入环，慢指针后进入环，慢指针和快指针一定会在环中相遇

 public static boolean hasCycle2 (LinkNode head){
        if(head==null){
            return false;
        }
        LinkNode slow=head,quick=head.next;

        while (slow!=quick){
            if(quick==null||quick.next==null){
                return false;
            }
            slow=slow.next;
            quick=quick.next.next;
        }
        return true;
    }

实验源码：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashSet;

@SpringBootTest
//判断链表中是否有环，有环返回true ，没环返回false；
class SuanfaApplicationTests10 {

    //模拟链表
    static class LinkNode{
        private Integer v;
        private LinkNode next;
        public LinkNode(Integer v, LinkNode next) {
            this.v = v;
            this.next = next;
        }
    }

    //1、直接遍历判断是否有环： 判断一个节点是否出现过两次，可以使用 HashSet 的特性,set中相同元素只能有一个
    public static boolean hasCycle (LinkNode head){
        HashSet<LinkNode> linkNodes = new HashSet<>();
        while (head!=null){
            //根据HashSet的特性，追加不进去证明该节点已经存在，则链表有环，这季节返回true即可
            if(!linkNodes.add(head)){
                return true;
            }
            head = head.next;
        }
        return false;
    }

    //2、双指针: 快指针先进入环，慢指针后进入环，慢指针和快指针一定会在环中相遇
    public static boolean hasCycle2 (LinkNode head){
        if(head==null){
            return false;
        }
        LinkNode slow=head,quick=head.next;

        while (slow!=quick){
            if(quick==null||quick.next==null){
                return false;
            }
            slow=slow.next;
            quick=quick.next.next;
        }
        return true;
    }

    @Test
    public void sf0(){
        LinkNode linkNode5 = new LinkNode(5, null);
        LinkNode linkNode4 = new LinkNode(4, linkNode5);
        LinkNode linkNode3 = new LinkNode(3, linkNode4);
        LinkNode linkNode2 = new LinkNode(2, linkNode3);
        LinkNode linkNode1 = new LinkNode(1, linkNode2);
        //开启链表中的环
        linkNode5.next=linkNode2;
        System.out.println(hasCycle(linkNode1));
        System.out.println(hasCycle2(linkNode1));

    }

}

结果：

true
true

五、合并两个有序数组

https://www.bilibili.com/video/BV1Jv411A7Ty?p=15

两个有序整数数组nums1和nums2 ，将nums2 合并到 nums1 中，使 nums1 成为一个有序数组，
注：初始化 nums1和nums2 的元素数量分别为 m 和 n 。假设nums1 的空间大小等于 m+n ，
这样他就有足够的空间保存来自 nums2 的元素。

1、最直接的方式

 //1、最直接的方式
    public static int[] merge(int[] nums1,int m,int[] nums2,int n){
        System.arraycopy(nums2,0,nums1,m,n);
        Arrays.sort(nums1);
        return nums1;
    }

2、双指针(多使用一个空数组空间进行存储)

 public static int[] merge1(int[] nums1,int m,int[] nums2,int n){
        int[] nums1_copy=new int[m];
        System.arraycopy(nums1,0,nums1_copy,0,m);
        int p1=0;//指向nums1_copy
        int p2=0;//指向nums2
        int p=0;//指向nums1
        while(p1<m && p2<n){
            nums1[p++]=nums1_copy[p1]<nums2[p2]?nums1_copy[p1++]:nums2[p2++];
        }
        if(p1<m){
            System.arraycopy(nums1_copy,p1,nums1,p1+p2,m+n-p1-p2);
        }
        if(p2<n){
            System.arraycopy(nums2,p2,nums1,p1+p2,m+n-p1-p2);
        }
        return nums1;
    }

3、双指针(不使用额外的数组空间，我们从后往前遍历)

public static int[] merge2(int[] nums1,int m,int[] nums2,int n){
        int p1=m-1;//指向nums1_copy
        int p2=n-1;//指向nums2
        int p=m+n-1;//num1的最hi偶一个下标
        while (p1>=0&&p2>=0){
            nums1[p--]=nums1[p1]<nums2[p2]?nums2[p2--]:nums1[p1--];
        }
        System.arraycopy(nums2,0,nums1,0,p2+1);
        return nums1;
    }

源码实验：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.HashSet;

@SpringBootTest
/*
    合并两个有序数组
    两个有序整数数组nums1和nums2 ，将nums2 合并到 nums1 中，使 nums1 成为一个有序数组，
    注：初始化 nums1和nums2 的元素数量分别为 m 和 n 。假设nums1 的空间大小等于 m+n ，
    这样他就有足够的空间保存来自 nums2 的元素。
 */

class SuanfaApplicationTests11 {

    //1、最直接的方式
    public static int[] merge(int[] nums1,int m,int[] nums2,int n){
        System.arraycopy(nums2,0,nums1,m,n);
        Arrays.sort(nums1);
        return nums1;
    }

    //2、双指针(多使用一个空数组空间进行存储)
    public static int[] merge1(int[] nums1,int m,int[] nums2,int n){
        int[] nums1_copy=new int[m];
        System.arraycopy(nums1,0,nums1_copy,0,m);
        int p1=0;//指向nums1_copy
        int p2=0;//指向nums2
        int p=0;//指向nums1
        while(p1<m && p2<n){
            nums1[p++]=nums1_copy[p1]<nums2[p2]?nums1_copy[p1++]:nums2[p2++];
        }
        if(p1<m){
            System.arraycopy(nums1_copy,p1,nums1,p1+p2,m+n-p1-p2);
        }
        if(p2<n){
            System.arraycopy(nums2,p2,nums1,p1+p2,m+n-p1-p2);
        }
        return nums1;
    }

    //3、双指针(不使用额外的数组空间，我们从后往前遍历)
    public static int[] merge2(int[] nums1,int m,int[] nums2,int n){
        int p1=m-1;//指向nums1_copy
        int p2=n-1;//指向nums2
        int p=m+n-1;//num1的最hi偶一个下标
        while (p1>=0&&p2>=0){
            nums1[p--]=nums1[p1]<nums2[p2]?nums2[p2--]:nums1[p1--];
        }
        System.arraycopy(nums2,0,nums1,0,p2+1);
        return nums1;
    }

    @Test
    public void sf0(){
        int[] nums1=new int[]{1,3,5,7,9,0,0,0,0};
        int[] nums2=new int[]{2,4,6,8,10};
//        System.out.println(Arrays.toString(merge(nums1,5,nums2,4)));//由于数组是引用类型，所以不要多个一起运行
//        System.out.println(Arrays.toString(merge1(nums1,5,nums2,4)));//由于数组是引用类型，所以不要多个一起运行
        System.out.println(Arrays.toString(merge2(nums1,5,nums2,4)));//由于数组是引用类型，所以不要多个一起运行
        System.out.println();

    }

}

结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

六、求子数组最大平均数

https://www.bilibili.com/video/BV1Jv411A7Ty?p=16
给一个整数数组，找出平均数最大且长度为k的下标连续的子数组，并输出该最大平均数。

1、滑动窗口–特殊的双指针

窗口滑动时，窗口内的和等于sum 加上新加进来的值，减去出去的值。
在这里插入图片描述

public static double findMaxAverage(int[] nums,int k){
        int sum=0;
        int n=nums.length;
        //先统计第一个窗口的和
        for (int i = 0; i < k; i++) {
            sum+=nums[i];
        }
        //记录下来他的值
        int max=sum;
        for (int i = k; i < n; i++) {
            sum=sum-nums[i-k]+nums[i];
            max=Math.max(sum,max);
        }
        return (double) max/k;
    }

实验源码：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;

@SpringBootTest
/*
    子数组最大平均数（滑动窗口--特殊的双指针）
    给一个整数数组，找出平均数最大且长度为k的下标连续的子数组，并输出该最大平均数。
 */

class SuanfaApplicationTests12 {


    //1、滑动窗口--特殊的双指针
    // 窗口滑动时，窗口内的和等于sum 加上新加进来的值，减去出去的值。
    public static double findMaxAverage(int[] nums,int k){
        int sum=0;
        int n=nums.length;
        //先统计第一个窗口的和
        for (int i = 0; i < k; i++) {
            sum+=nums[i];
        }
        //记录下来他的值
        int max=sum;
        for (int i = k; i < n; i++) {
            sum=sum-nums[i-k]+nums[i];
            max=Math.max(sum,max);
        }
        return (double) max/k;
    }

    @Test
    public void sf0(){
        int[] nums1=new int[]{1,3,5,7,9,12,7,7,3,4};
        System.out.println(findMaxAverage(nums1,4));//由于数组是引用类型，所以不要多个一起运行

    }

}

结果：

8.75
会飞的小蜗
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
E. Two Teams(模拟双端链表,set)
wangtao的博客
04-17 304
Two Teams 题意: n个人站成一排,有两个教练1号和2号,他们轮流选人 1号教练先选剩下的人中权值最大的,然后选择他左边的k个,右边的k个(空则不选) 再2号,直到所以人都选完 解析: 用数组模拟双向链表 lef[i],i位置左边第一人位置,righ[i],i位置右边第一人位置 每次选完人后,修改空白区间左右连续情况(链表) 用set来求剩下的最大值 ac: #in...
Java常见的排序算法
最新发布
03-27
Java中常见的排序算法有以下几种： 冒泡排序（Bubble Sort）：通过比较相邻元素的大小，将较大的元素逐渐向后移动，直到整个序列有序。 选择排序（Selection Sort）：每次遍历数组，找到最小（或最大）的元素，将其...
Two Teams
无限迭代中......
04-17 435
https://codeforces.com/contest/1154/problem/E 题意：有两个教练来选人，第一个先选。两个人选的策略是：找到还没被选的最大的一个。然后在选择它左边k个和右边k个。他们轮流选直到全部选完。输出他们都被谁选了 C++版本一 题解：链表STL /* *@Author: STZG *@Language: C++ */ #include <bit...
JAVA 两个队列实现栈
TUT0UB0Y的博客
04-15 1521
JAVA两个队列实现栈
双端队列数组版【Java算法（五）】
qq_56402474的博客
04-01 662
掌握了栈与队列后，如何将二者的优势联系起来。这里简单的写了Java代码了解双端队列
E. Two Teams
wangqianqianya的博客
11-19 785
E. Two Teams theme:n个人排成一行，每个人有一个属性值。先两个教练轮流选队员。每次从中选出属性值最大的人，并选出他左右连续的各k个人出来（如果有的话则出队），直至每个人都成为一对。求每个人最终属于哪个队。1<=n,k<=2e5 solution:模拟题。用双向队列模拟。首先预处理出每个位置紧挨着的前后下标，之后按属性从大到小排列，按l=L[l],r=R[r]左右遍...
Java程序设计-常见算法
07-14
本主题“Java程序设计-常见算法”主要涵盖查找算法和排序算法两个大类，下面将详细阐述这两个领域的基本概念、原理以及它们在Java中的实现。 首先，我们来讨论查找算法。查找算法的目标是在数据集合中找到特定元素...
Java常见算法大全
09-25
Java常见算法大全是针对Java程序员的一份宝贵资源，旨在帮助他们深入理解和熟练运用各种算法，提升编程技能。在计算机科学中，算法是解决问题的关键，它是一系列清晰定义的步骤，用于执行特定任务或解决特定问题。...
JAVA近百种算法大全
05-29
Java算法大全是一个包含约100种常见算法的资源库，专为Java程序员设计，用于深入理解和实践编程中的各种算法。这些算法涵盖了数据结构、排序、搜索、图论等多个领域，是提升编程技能和解决问题能力的重要工具。下面...
java常见算法题解析大全。
11-22
在这个“java常见算法题解析大全”中，你将找到一系列涵盖不同难度级别的算法问题，旨在帮助Java开发者提升技能，增强解决问题的能力。 首先，让我们了解一下折半查找（Binary Search）算法。这是一种在有序数组中...
java Brute-Force算法 BF算法 暴力匹配算法
06-24
带简单图形界面的暴力匹配算法的java实现。
Java实现 蓝桥杯 算法训练 Number Challenge（暴力）
12-21
试题 算法训练 Number Challenge 资源限制 时间限制：3.0s 内存限制：512.0MB 问题描述 　　定义d(n)为n的约数个数。现在，你有三个数a,b,c。你的任务是计算下面式子modulo 1073741824 (2^30)的值。 输入格式 　　三个正整数a,b,c。 输出格式 　　一个数，即上面式子modulo 1073741824 (2^30)的值。 样例输入 2 2 2 样例输出 20 数据规模和约定 　　a, b , c (1 ≤ a, b, c ≤ 2000) import java.util.Scanner; public class Main {
java中暴力算法_【Java】我所知道的十大常用算法之字符串匹配问题（KMP、暴力匹配）...
weixin_30095343的博客
02-28 514
前言需求前面讲解了动态规划的思想，今天我们要说的是涉及字符串匹配问题(KMP)现在前来看我们的问题1.字符串 str1 = “BBC ABCDAB ABCDABCDABDE”2.字符串 str2 = “ABCDABD”现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1那么你觉得你会是怎么做的呢？一、小明同学的思路想法小明同学：我先找到符合str2 ...
java实现暴力匹配算法详解
mischen520的博客
12-08 603
从长字符串的第一个字符开始，判断是否和子字符串的第一个字符相等，如果相等，则在比较后面的字符。循环结束后通过判断指向子字符串的索引大小判断是否匹配到，即如果匹配到，则索引大小应该为子字符串长度大小，否则就没有匹配到。如果后边的字符匹配不成功，则重置长字符串索引为当前开始索引的下一个，重置子字符串索引为0，重复前边的步骤。如果第一个字符就不相等，则通过指针后移依次判断长字符串后边的字符是否和第一个字符相等，直到字符串末尾。一旦在长字符串中匹配到子字符串的第一个字符，就依次再比较后边的字符。
字符串暴力匹配算法（Java）
shift_tt的博客
10-11 926
首先介绍一下暴力匹配算法的思路 如果用暴力匹配的思路，并假设现在str1匹配到i的位置，字串str2匹配到j的位置，则有： 如果当前字符匹配成功（即str1[i] == str2[j])，则i++，j++，继续匹配下一个字符。 如果失配（即str1[i] != str2[j]），令i=i-(j-1)，j = 0。相当于每次匹配失败时，i回溯，j被置为0. 用暴力方法解决问题的话会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。（不可行，接着下一篇会介绍KMP算法） 暴力匹
java中暴力算法_Java实现 蓝桥杯 算法训练 My Bad（暴力）
weixin_42495394的博客
02-28 225
试题 算法训练 My Bad问题描述一个逻辑电路将其输入通过不同的门映射到输出，在电路中没有回路。输入和输出是一个逻辑值的有序集合，逻辑值被表示为1和0。我们所考虑的电路由与门(and gate，只有在两个输入都是1的时候，输出才为1)、或门(or gate，只要两个输入中有一个是1，输出就是1)、异或门(exclusive or(xor)gate，在两个输入中仅有一个是1，输出才是1)和非门(n...
Java暴力匹配算法——字符串匹配问题
qq_54836465的博客
07-11 1604
有一个字符串 str1另和一个字符串 str2 ，通过暴力匹配算法判断 str1 是否含有 str2，如果存在，就返回第一次出现位置的下标，如果没有，则返回-1。
java用暴力匹配算法完成字符串的匹配
qq_41006650的博客
06-21 408
此算法需要进行大量的回溯，效率较低。 /** * 用暴力匹配算法完成字符串的匹配 * @author 冷了 * */ public class ViolentMatch { public static void main(String[] args) { /*需求： * 有一个字符串 string1 = "AABBAABBCCBBAA"，和一个子串 string2 = "ABBCC" * 现在要判断string1是否包含string2，如果存在，就返回第一次出现的位置，如果没有，则
算法之暴力枚举（穷举）
i_meteor_shower的博客
07-19 2511
枚举法的基本思想是根据题目的部分条件确定答案的大致范围，并在次范围内对所有可能的情况逐一验证，直到全部情况验证完毕。若某个情况验证符合题目的全部条件，则为本问题的一个解；若全部情况验证后都不符合题目的全部条件，则本题无解。也称为穷举法。 题目：某人有N袋金币，其中第i袋内金币的数量是Ai。现在他决定选出2袋金币送给小Hi，再选2袋金币送给小Ho，同时使得小Hi和小Ho得到的金币总数相等。他想知...
java 常见算法题 2021
10-20
Java常见的算法题有很多，以下是一些常见的算法题目及其解决方法。 1. 求两个整数的最大公约数和最小公倍数。可以使用辗转相除法来求最大公约数，即不断用较大数除以较小数，直到余数为0，则较小数就是最大公约数。最小公倍数等于两数的乘积除以最大公约数。 2. 数组中找出第K大（小）的数。可以使用快速排序的思想，选取一个基准元素，将数组分为大于基准元素和小于基准元素的两部分，递归地在其中一部分中查找第K大（小）的数。 3. 判断一个字符串是否为回文串。可以使用双指针法，分别从字符串的开头和结尾开始遍历，判断对应字符是否相等，直到两指针相遇或交叉。 4. 实现链表的反转。可以使用迭代或递归的方式，将当前节点的下一个节点指向上一个节点，然后继续遍历链表。 5. 实现二分查找算法。对于有序数组，可以使用二分查找法，在数组的中间位置判断目标值与中间值的大小关系，然后缩小查找范围，直到找到目标值或查找范围为空。 6. 实现图的深度优先搜索（DFS）和广度优先搜索（BFS）。DFS使用递归的方式进行搜索，遍历当前节点的邻接节点，直到遍历完所有节点或找到目标节点。BFS使用队列进行搜索，将当前节点的邻接节点加入队列，并依次出队访问，直到找到目标节点或队列为空。 以上只是一些常见的算法题目，掌握这些算法可以帮助我们更好地理解和解决实际问题。当然，还有许多其他的算法题目，不断学习和练习才能更好地掌握。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

会飞的小蜗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值