(day10) 自学Java——常见算法和Lambda

最新推荐文章于 2024-04-23 17:09:00 发布
最新推荐文章于 2024-04-23 17:09:00 发布
阅读量748 收藏 1
点赞数
分类专栏： Java 文章标签： 算法 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62063669/article/details/128793789
版权

目录

1.基本查找

2.二分查找

3.插值查找

4.斐波那契查找

5.分块查找

6.哈希查找

7.冒泡排序

8.选择排序

9.插入排序

10.递归算法

11.快速排序

12.Arrays

13.lambda表达式

14.练习：算法题

1.基本查找

从0索引开始挨个往后查找。

练习1：

需求：定义一个方法利用基本查找，查询某个元素在数组中的索引

要求：不需要考虑数组中的元素是否重复

public class Test {
    public static void main(String[] args){
        int[]arr={131,127,147,81,103,23,7,79,81};
        int num=23;
        int index=getIndex(arr,num);
        System.out.println(index);
    }

    private static int getIndex(int[]arr,int num) {
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==num){
                return i; //存在就返回索引
            }
        }
        return -1;//不存在就返回-1
    }
}

练习2：

需求：定义一个方法利用基本查找，查询某个元素在数组中的索引

要求：需要考虑数组中元素有重复的可能性{131,127,147,81,103,23,7,79,81}

要查找81，返回的是所有索引3 8

import java.util.ArrayList;

public class Test {
    public static void main(String[] args){
        int[]arr={131,127,147,81,103,23,7,79,81};
        int num=81;
        ArrayList index=getIndex(arr,num);
        for (int i = 0; i < index.size(); i++) {
            System.out.println(index.get(i));
        }
    }

    private static ArrayList getIndex(int[]arr,int num) {
        ArrayList<Integer> list=new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==num){
                list.add(i);
            }
        }
        return list;
    }
}

2.二分查找/折半查找

前提：数组中的数据必须是有序的。

核心逻辑：每次排除一半的查找范围。

练习：定义一个方法利用二分查找，查询某个数字在数组的索引 

{7,17,23,35,47,59,60,75,88,96,100}

（当一个元素不存在，min移到max左边就结束循环，相反亦然）

public class Test {
    public static void main(String[] args){
        int[]arr={7,17,23,35,47,59,60,75,87,96,100};
        int index=binarySearc(arr,35);
        System.out.println(index);
        }

    public static int binarySearch(int[]arr,int num) {
        int min=0;
        int max=arr.length-1;
        while (true){
            int mid=(min+max)/2;
                if (min>max){
                    return -1;
                }
                else if (num<arr[mid]){
                    max=mid-1;
                }
                else if (num>arr[mid]){
                    min=mid+1;
                }
                else {
                    return mid;
                }
            }
    }
}

3.插值查找

二分查找改进就是插值查找

缺陷：需要数组里的数字分布均匀。

4.斐波那契查找

利用黄金分割点来计算mid的位置

5.分块查找

核心思想：块内无序，块间有序。

分成了四个板块，需要将这4块存起来，创建4个对象，将对象存到数组中（索引表）。

 练习：

public class Test {
    public static void main(String[] args){
        int[]arr={
                27,22,30,40,36,
                13,19,16,20,
                7,10,
                43,50,48
        };
        Block b1=new Block(22,40,0,4);
        Block b2=new Block(13,20,5,8);
        Block b3=new Block(7,10,9,10);
        Block b4=new Block(43,50,11,13);
        Block[]arrNew={b1,b2,b3,b4};
        int num=50;
        int index=getIndex(arrNew,arr,num);
        System.out.println(index);
    }

    private static int getIndex(Block[]arrNew,int[]arr,int num) {
        int index=getIndexBlock(arrNew,num);
        if (index==-1){
            return -1;
        }
        int start=arrNew[index].startIndex;
        int end=arrNew[index].endIndex;
        for (int i = start; i <=end; i++) {
            if(arr[i]==num){
                return i;
            }
        }
        return -1;
    }

    public static int getIndexBlock(Block[]arrNew,int num) {
        for (int i = 0; i < arrNew.length; i++) {
            int min=arrNew[i].getMin();
            int max=arrNew[i].getMax();
            if (num>=min && num<=max){
                return i;
            }
        }
        return -1;
    }
}

6.哈希查找

块中为空，就将数字放进去；不为空，就挂在后面。

7.冒泡排序

相邻的数据两两比较，小的放前面，大的放后面

练习：{3，5，2，4，1} 将其从小到大排序

public class Test {
    public static void main(String[] args){
        int[]arr={3,5,2,4,1};
        for (int i=0;i<arr.length-1;i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

8.选择排序

练习： {3，5，2，4，1} 将其从小到大排序

外循环：表示需要循环几轮。

内循环：每一轮要干什么

public class Test {
    public static void main(String[] args){
        int[]arr={3,5,2,4,1};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 1+i; j < arr.length; j++) {
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
//输出{1，2，3，4，5}
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

9.插入排序

将无序的数据拿出来，在有序中，从后向前比较，然后插入 。

38拿出来，跟44比较，把38插入到44前面，然后拿38跟3比较，38比3大，所以38就在3后面。

public class Test {
    public static void main(String[] args){
        int[]arr={3,5,2,4,1,24,16,33,45,37,49,70,69,66};
        //找到无序的那一组数据的开始索引
        int startIndex=-1;//索引-1不存在
        for (int i = 0; i < arr.length; i++) {
            if(arr[i+1]<arr[i]){
                startIndex=i+1;
                System.out.println(startIndex);
                break;
            }
        }
        for (int i = startIndex; i < arr.length; i++) {
            //i用来取无序组中的数据
            int j=i;
            //索引j，用来比较前者是否比自己大，比自己大就交换位置，j--是为了跟前面的数据比较
            while (j>0&&arr[j]<arr[j-1]){ 
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
                j--;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

10.递归算法

递归是指方法中调用方法本身的现象。

递归一定要有出口（比如调用几次就不调用了），否则会造成栈内存溢出。

核心：1.找出口  2.找规律

下面图示：会报错，造成栈内存溢出

 练习：计算1~100的和

public class Test {
    public static void main(String[] args){
        System.out.println(getSum(100));
    }

    public static int getSum(int num) {
        if (num==1){
            return 1;
        }
        return num+getSum(num-1);
    }
}

练习：用递归求5的阶乘（5!=5*4*3*2*1） 

public class Test {
    public static void main(String[] args){
        System.out.println(getJC(5));
    }

    public static int getJC(int num) {
        if(num==1){
            return 1;
        }
        return num*getJC(num-1);
    }
}

11.快速排序

public class Test {
    public static void main(String[] args){
        int[]arr={6,1,5,2,7,8,3,4,10,9};
        quickSort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    public static void quickSort(int[]arr,int i,int j) {
       int start=i;
       int end=j;
       //出口
        if (start > end){
            return;
        }
       int basicNum=arr[i];

       while (start!=end){
           //从左往右找，找到比基准数大的就停止
           while (true){
               if (end<=start||arr[end]<basicNum){
                   break;
               }
               end--;
           }
           //从右往左找，找到比基准数小的就停止
           while (true){
               if (end<=start||arr[start]>basicNum){
                   break;
               }
               start++;
           }
           //交换数据
           int temp=arr[start];
           arr[start]=arr[end];
           arr[end]=temp;
       }
       //循环结束，start和end索引相等，与基准数交换
          int temp=arr[i];
            arr[i]=arr[start];
            arr[start]=temp;
            //将基准数两边的数据，分别按照同样的方式排序
        quickSort(arr,i,start-1);
        quickSort(arr,start+1,j);
    }
}

12.Arrays

操作数组的工具类

13.lambda表达式

 

练习：Lambda表达式简化Comparator接口的匿名形式

定义数组并存储一些字符串，利用Arrays中的sort方法进行排序

要求：按照字符串的长度进行排序，短的在前，长的在后（暂时不比较字符串里面的内容）

import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args){
       String[]arr={"aa","aaaa","aaaaa","a","aaa"};


       //匿名内部类
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        //lambda完整格式
        Arrays.sort(arr, (String o1, String o2)-> {
                return o1.length()-o2.length();
            }
        );
        //lambda省略格式
        Arrays.sort(arr, (o1, o2)-> o1.length()-o2.length());

        System.out.println(Arrays.toString(arr));

    }
}

14.练习：算法题

练习：定义数组并存储一些女朋友对象，利用Arrays中的sort方法进行排序
要求1：属性有姓名、年龄、身高。
要求2：按照年龄的大小进行排序，年龄一样，按照身高排序，身高一样按照姓名的字母进行排序。
（姓名中不要有中文或特殊字符，会涉及到后面的知识）

//匿名内部类的方式
import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args){
       grilFriend g1=new  grilFriend("xiaoming",16,1.67);
        grilFriend g2=new  grilFriend("xiaohong",17,1.57);
        grilFriend g3=new  grilFriend("aa",19,1.77);
        grilFriend g4=new  grilFriend("bb",17,1.77);
        grilFriend[]arr={g1,g2,g3,g4};
        Arrays.sort(arr, new Comparator<grilFriend>() {
            @Override
            public int compare(grilFriend o1, grilFriend o2) {
                //按照年龄的大小进行排序，年龄一样，按照身高排序，身高一样按照姓名的字母进行排序。
                double temp=o1.getAge()-o2.getAge();
                temp=temp==0?o1.getHeight()-o2.getHeight():temp;
                temp=temp==0?o1.getName().compareTo(o2.getName()):temp;
                if (temp>0){
                    return 1;
                }else if (temp<0){
                    return -1;
                }else {
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}
//lambda的方式
import java.util.Arrays;

public class Test {
    public static void main(String[] args){
       grilFriend g1=new  grilFriend("xiaoming",16,1.67);
        grilFriend g2=new  grilFriend("xiaohong",17,1.57);
        grilFriend g3=new  grilFriend("aa",19,1.77);
        grilFriend g4=new  grilFriend("bb",17,1.77);
        grilFriend[]arr={g1,g2,g3,g4};
        Arrays.sort(arr, (o1, o2)->{
                //按照年龄的大小进行排序，年龄一样，按照身高排序，身高一样按照姓名的字母进行排序。
                double temp=o1.getAge()-o2.getAge();
                temp=temp==0?o1.getHeight()-o2.getHeight():temp;
                temp=temp==0?o1.getName().compareTo(o2.getName()):temp;
                if (temp>0){
                    return 1;
                }else if (temp<0){
                    return -1;
                }else {
                    return 0;
                }
            }
        );
        System.out.println(Arrays.toString(arr));
    }
}

练习：不死神兔
有一个很有名的数学逻辑题叫做不死神兔问题，有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第十二个月的兔子对数为多少？

//方法1
public class Test {
    public static void main(String[] args){
       int[]arr=new int[12];
       arr[0]=1;
       arr[1]=1;
       int sum=0;
        for (int i = 0; i < arr.length-2; i++) {
            arr[i+2]=arr[i]+arr[i+1];
        }
        System.out.println(arr[11]);
    }
}

//方法2
public class Test {
    public static void main(String[] args){
        System.out.println(getSum(12));
    }
    //Fn(12)=Fn(11)+Fn(10)
    //Fn(11)=Fn(10)+Fn(9)
    //Fn(10)=Fn(9)+Fn(8)
    //......
    //Fn(2)=1
    //Fn(1)=1

    public static int getSum(int month) {
        if (month==1||month==2){
            return 1;
        }
        else {
            return getSum(month-1)+getSum(month-2);
        }
    }
}

练习：一堆桃子，猴子第一天吃了一半，再多吃一个，每天如此，到第十天的时候（还没吃）发现只有一个桃子了。请问，最初是多少个桃子？

public class Test {
    public static void main(String[] args){
        System.out.println(getSum(1));

    }

    public static int getSum(int day) {
        if (day<1||day>11){
            return -1;
        }
        //出口
        if (day==10){
            return 1;
        }
        //规律
        return (getSum(day+1)+1)*2;
    }
}

练习：爬楼梯
可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，有的时候一次爬两个台阶。
如果这个楼梯有20个台阶，小明一共有多少种爬法呢？
运算结果：
1层台阶 1种爬法
2层台阶 2种爬法
7层台阶 21种爬法

public class Test {
    public static void main(String[] args){
        System.out.println(getSum(20));

    }

    public static int getSum(int n) {
        //出口
        if (n==1){
            return 1;
        }

        if (n==2){
            return 2;
        }        //规律
        return getSum(n-1)+getSum(n-2);
    }
}
隐身的菜鸟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8中Lambda表达式之Collection 的常见用法
06-14
在java8中引入了Lambda表达式。其实，他就是一个匿名函数。我们经常会用到一些循环遍历，起始完全就可以通过Lambda来简化我们不必要的操作，下面我们来看一下Lambda常用的方法。
查找元素在数组中的索引 17
qq_41005604的博客
03-29 940
查找元素在数组中的索引 需求分析 已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。并在控制台输出找到的索引值。如果没有查找到，则输出-1 步骤分析 1、定义一个数组。 2、接收用户输入一个数据。 3、定义一个方法接收数组和查询的数据，然后在方法中看是否在数组中存在，存在返回元素的索引值，不存在返回-1。 4、调用方法传入数组和数据，...
Java之ArrayList
qq_44200451的博客
08-09 253
ArrayList
爬楼梯问题（经典递归问题）
qq_34445594的博客
11-23 5583
题目内容：可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，有的时候一次爬两个台阶，有的时候一次爬三个台阶。如果这个楼梯有n个台阶，小明一共有多少种爬法呢？n值从键盘输入。 输入格式：输入一个整数n,(1<=n<46)。 输出格式：输出当楼梯阶数是n时的上楼方式总数。 输入样例：1 输出样例：1 输入样例：4 输出样例：7 输入样例：24 输出1389537 这道题主要目标是找出楼梯为多少阶时会和前面几个不同阶数的楼梯的不同爬法产生关系，因为小明一次能爬1，2，3阶楼梯，.
java常见算法--小练习
m0_73703409的博客
12-16 355
第10天的时候(还没吃)，发现只剩下一个桃子了，请问：最初一共有多少个桃子？，有的时候一次爬三个台阶，如果这个楼梯有20个台阶，小明一共有多少种爬法呢？练习2：可爱的小明特别喜欢爬楼梯，他又的时候一次爬一台阶，有的时候一次爬两个台阶。练习3：可爱的小明特别喜欢爬楼梯，他又的时候一次爬一台阶，有的时候一次爬两个台阶。练习5：输入数组，最大的与第一个交换，最小的与最后一个交换，输出数组。以后每天猴子都吃当前剩下来的一半，然后再多吃一个，练习1：有一堆桃子，猴子第一天吃了其中的一半，并多吃了一个！
Lambda表达式和Java集合框架
08-31
本文主要介绍了Lambda表达式和Java集合框架的相关知识，具有很好的参考价值。下面跟着小编一起来看下吧
Java 8 新特性之Stream 和 Lambda
01-24
Java 8 新特性之Stream 和 Lambda
Java8中Lambda表达式使用和Stream API详解
08-26
主要给大家介绍了关于Java8中Lambda表达式使用和Stream API的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java Lambda表达式和函数式接口实例分析
08-25
主要介绍了Java Lambda表达式和函数式接口,结合实例形式分析了Java8 Lambda表达式和函数式接口相关原理、用法及操作注意事项,需要的朋友可以参考下
FloodFill算法简介（用BFS、DFS算法解决）
2301_76197086的博客
04-18 439
FloodFill算法简介
DFS与回溯专题：路径总和问题
孤舟一叶～的博客
04-19 757
对二叉树进行dfs搜索，递归计算每条路径的节点值之和，当某个节点的左右子节点都为空时，说明已经搜索完成某一条路径，将它与目标值进行比较，若相等，则为true。路径恢复： 向上回溯前，需要将当前节点从路径 list 中删除，即执行list.remove(list.size() - 1)。为什么要写list_all.add(new ArrayList(list))，而不是list_all.add(list)？注意：解释里面的sum.add(path)就是list_all.add(list)
力扣136. 只出现一次的数字
LNsupermali的博客
04-18 564
力扣136. 只出现一次的数字
二分答案算法
2301_79980806的博客
04-21 936
跟二分查找类似，当我们要找某个量的最值的时候，可以在这个两最小可能的取值，和最大可能的取值之间二分，来快速找到答案check函数为了验证中间值是否符合题目要求，根据是否来决定下一轮区间界限是作曲兼缩小，还是右区间缩小。
LeetCode //C - 18. 4Sum
Made in Code
04-22 694
【代码】LeetCode //C - 18. 4Sum。
代码随想录算法训练营day40
最新发布
weixin_43390031的博客
04-23 240
1为头，左子树节点个数为0，右子数节点个数为2，即dp[0]*dp[2]，2为头，dp[1]*dp[1]，3为头dp[2]*dp[0]。故对dp[i]，我们也考虑1到i为头节点的数量相加，dp[i]=dp[0]*dp[i-1]+dp[1]*dp[i-2]+…时间复杂度O(n^2)。(i-2)取最大值，综合讨论一下就是拆成i-j和j，然后比较dp[i-j]*j和(i-j)*j的最大值，这里因为dp[i-j]必须要进行至少拆成两个数，所以没有包含i-j，故我们还需要比较i-j，递推公式就是。
算法：堆（优先队列）
得克特
04-18 385
堆（优先队列）分为最大堆和最小堆。
【Leetcode每日一题】 分治 - 数组中的第K个最大元素（难度⭐⭐）（63）
m0_73150338的博客
04-23 382
分治 - 数组中的第K个最大元素
4.18算法
2302_80283616的博客
04-18 899
而消除一对相邻重复项可能会导致新的相邻重复项出现，如从字符串 abba 中删除 bb 会导致出现新的相邻重复项 aa出现。例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。如果遇到运算符，则将两个操作数出栈，其中先出栈的是右操作数，后出栈的是左操作数，使用运算符对两个操作数进行运算，将运算得到的新操作数入栈。
Java的lambda和python的lambda一样吗
05-04
Java和Python中的Lambda表达式都是用来创建匿名函数的语法，并且都支持函数式编程的特性。 但是Java的Lambda表达式和Python的Lambda表达式在语法和使用上还是有一些不同的地方： 1. 语法：Java的Lambda表达式需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值