文章目录
一、数组中找出两数之和为给定值的数组下标
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