Java常见算法(二)

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

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