Java的常见算法和Lambda表达式

通达的K2025-05-23 16:04

基本查找

java 复制代码 
package search.code;

public class code1 {
    public static void main(String[] args) {
        //基本查找
        //核心
        //从0索引开始，一直往后查找，直到找到为止
        //需求：定义一个方法利用基本查找，查询某个元素是否存在
        //数据如下：{131, 127, 147, 81, 103, 23, 7, 79, 81}
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79, 81};
        int num = 81;
        //调用方法
        System.out.println(basicSearch(arr,num));
    }
    public static boolean basicSearch(int[] arr,int num){
        //利用基本查找，查询某个元素是否存在
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==num){
                return true;
            }
        }
        return false;
    }
}
运行结果：
true

顺序查找：

java 复制代码 
package search.code;

import java.util.ArrayList;
import java.util.List;

public class code2 {
    public static void main(String[] args) {
        //需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
        //不需要考虑数组中元素是否重复
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79, 81, 81};
        int num = 81;
        //调用方法
        System.out.println(returnindex(arr, num));
        //需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
        //需要考虑数组中元素是否重复
    }

    public static List<Integer> returnindex(int[] arr, int num) {
        List<Integer> indexs = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                indexs.add(i);
            }
        }
        return indexs;
    }
}

运行结果：

3, 8, 9

二分查找/折半查找

二分查找/折半查找

二分查找/折半查找的实验代码：

java 复制代码 
package search.code;

public class code3 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        //定义一个要查找的元素
        //调用方法
        int searchnum = search(arr, 10);
        System.out.println(searchnum);
    }

    public static int search(int[] arr, int num) {
        //定义两个变量去找查找要的数据
        int min = 0;
        int max = arr.length - 1;
        while (true) {
            //定义一个中间变量
            //进行判断
            if (min > max) {
                return -1;
            }
            //查找min和max的中间位置值
            int mid = (min + max) / 2;
            //拿着mid和要查找的元素再次进行判断
            //mid在要查找元素的左边
            //mid在要查找元素的右边
            //mid在要查找元素指向一个元素
            if (arr[mid] > num) {
                max = mid - 1;
            } else if (arr[mid] < num) {
                min = mid + 1;
            }
            else {
                return mid;
            }
        }
    }
}

运行结果：

9

二分查找总结：

二分查找改进与提升效率

插值查找

要求（数据分布比较均匀，不然反而会降低效率）

斐波那契查找：

三种查找方式的总结：

分块查找：

核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找

分块查找的模式图：

总结

冒泡排序

冒泡排序

java 复制代码 
package search.code;

public class Bubbledemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {2, 1, 4, 3, 5};
        //利用冒泡排序进行排序
        //外循环
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - j; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //遍历数组
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果：

1 2 3 4 5

选择排序

选择排序：

java 复制代码 
package search.code;

public class Selectiondemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {2, 1, 4, 3, 5};
        //利用选择排序进行排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        printArr(arr);
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果：

1 2 3 4 5

插入排序：

插入排序：

java 复制代码 
package search.code;

public class Insertdemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {2, 3, 4553187, 67, 561, 32, 90, 14, 3, 215, 23, 413131, 9, 5354, 1, 2};
        int startIndex = -1;
        for (int i = startIndex; i < arr.length; i++) {
            //记录当前插入数据的索引
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }
        }
        //遍历数组
        printArr(arr);
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果：

1 2 2 3 3 9 14 23 32 67 90 215 561 5354 413131 4553187

快速算法

递归的作用：

书写递归的两个核心：

求1-100之间的和

java 复制代码 
package search.code;

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

    private static int getSum(int i) {
        if (i == 1){
            return 1;
        }
        return i + getSum(i - 1);
    }
}

运行结果：

5050

递归求阶乘

java 复制代码 
package search.code;

public class Recursiondemo1 {
    public static void main(String[] args) {
        //调用方法
        int result = getFactorialRecursion(5);
        System.out.println(result);
    }
        //递归求阶乘
        //5！ = 5 * 4 * 3 * 2 * 1
    private static int getFactorialRecursion(int i) {
        if (i == 1){
            return 1;
        }
        return i * getFactorialRecursion(i -1);
    }
}

运行结果：

120

递归的内存图

快速排序

java 复制代码 
package search.code;

public class QuickSortdemo1 {
    public static void main(String[] args) {
        int[] arr = {4, 6, 7, 12, 1, 68, 89, 9, 23};
        quickSort(arr, 0, arr.length - 1);
        printArr(arr);
    }

    private static void quickSort(int[] arr, int i, int j) {
        //定义两个变量记录要查找的范围
        int startNum = i;
        int endNum = j;
        if (startNum > endNum){
            return;
        }
        //记录基准数
        int baseNum = arr[i];
        //使用循环找到要交换的数字
        //利用endNum从后往前找，找到比基准数小的数字
        while(startNum != endNum) {
            while (true) {
                if (endNum <= startNum || arr[endNum] < baseNum) {
                    break;
                }
                endNum--;
            }
            //利用startNum从前往后找，找到比基准数小的数字
            while (true) {
                if (endNum <= startNum || arr[startNum] > baseNum) {
                    break;
                }
                startNum++;
            }
            int temp = arr[startNum];
            arr[startNum] = arr[endNum];
            arr[endNum] = temp;
        }
        //当startNum和endNum指向同一个元素时，完成第一轮排序
        //把基准数归位
        int temp = arr[i];
        arr[i] = arr[startNum];
        arr[startNum] = temp;
        quickSort(arr,i,startNum - 1);
        quickSort(arr,startNum + 1,j);
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果：

1 4 6 7 9 12 23 68 89

快速排序的使用时间

java 复制代码 
package search.code;

import java.util.Random;

public class QuickSortdemo1 {
    public static void main(String[] args) {
        printTime();
    }

    private static void getRandomArr() {
        int[] arr = new int[10000];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt();
        }
    }
    private static void printTime() {
        long start = System.currentTimeMillis();
        getRandomArr();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    private static void quickSort(int[] arr, int i, int j) {
        //定义两个变量记录要查找的范围
        int startNum = i;
        int endNum = j;
        if (startNum > endNum){
            return;
        }
        //记录基准数
        int baseNum = arr[i];
        //使用循环找到要交换的数字
        //利用endNum从后往前找，找到比基准数小的数字
        while(startNum != endNum) {
            while (true) {
                if (endNum <= startNum || arr[endNum] < baseNum) {
                    break;
                }
                endNum--;
            }
            //利用startNum从前往后找，找到比基准数小的数字
            while (true) {
                if (endNum <= startNum || arr[startNum] > baseNum) {
                    break;
                }
                startNum++;
            }
            int temp = arr[startNum];
            arr[startNum] = arr[endNum];
            arr[endNum] = temp;
        }
        //当startNum和endNum指向同一个元素时，完成第一轮排序
        //把基准数归位
        int temp = arr[i];
        arr[i] = arr[startNum];
        arr[startNum] = temp;
        quickSort(arr,i,startNum - 1);
        quickSort(arr,startNum + 1,j);
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行时间：

1

Lambda表达式

java 复制代码 
package search.code;

import java.util.Arrays;

public class Lambdademo1 {
    public static void main(String[] args) {
        //初始Lambda表达式
        Integer[] arr = {1,12,32,2,4,3,7};
        Arrays.sort(arr,(a,b)->{
            return a - b;             //升序
            // return b - a;          //降序
        });
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

1, 2, 3, 4, 7, 12, 32

Lambda表达式的标准格式

JDK8以后的一种新的语法形式

注意点：

必须是函数式接口才能用Lambda表达式简写

总结：

省略核心：

可推导可省略

Lambda表达式规则：

Lambda表达式的完全省略式

java 复制代码 
package search.code;

import java.util.Arrays;

public class Lambdademo1 {
    public static void main(String[] args) {
        //初始Lambda表达式
        Integer[] arr = {1,12,32,2,4,3,7};
        Arrays.sort(arr,(a,b)->a-b);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

1, 2, 3, 4, 7, 12, 32

java 复制代码 
package search.code;

import java.util.Arrays;

public class Lambdademo2 {
    public static void main(String[] args) {
        String[] arr = {"aa","a","aaaaaaaaaa","aa","aaa","aaaa"};
        //Lambda表达式
        Arrays.sort(arr,(String o1, String o2) ->o1.length() - o2.length());
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

a, aa, aa, aaa, aaaa, aaaaaaaaaa

练习.按照要求排序

Test

java 复制代码 
package search.code;

import java.util.Arrays;

public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend gf1 = new GirlFriend("xx",18,160);
        GirlFriend gf2 = new GirlFriend("xy",19,165);
        GirlFriend gf3 = new GirlFriend("xss",20,168);
        GirlFriend[] arr = {gf1,gf2,gf3};
        Arrays.sort(arr,(o1,o2)->(o1.getAge()-o2.getAge()));
        System.out.println(Arrays.toString(arr));
    }
}

Javabean：

java 复制代码 
package search.code;

public class GirlFriend {
    private String name;
    private int age;
    private int height;
    public GirlFriend(){

    }
    public GirlFriend(String name,int age ,int height){
        this.name = name;
        this.age = age;
        this.height = height;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return height
     */
    public int getHeight() {
        return height;
    }

    /**
     * 设置
     * @param height
     */
    public void setHeight(int height) {
        this.height = height;
    }

    public String toString() {
        return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";
    }
}

运行结果：

GirlFriend{name = xx, age = 18, height = 160}, GirlFriend{name = xy, age = 19, height = 165}, GirlFriend{name = xss, age = 20, height = 168}


递归的方法：

java 复制代码 
package kl003.Test6;

public class Rabbit1 {
    public static void main(String[] args) {
        int sum = getSum(12);
        System.out.println(sum);
    }

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

赋值法：

java 复制代码 
package kl003.Test6;

public class Rabbit1 {
    public static void main(String[] args) {
        int sum = getSum(12);
        System.out.println(sum);
    }

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

运行结果：

144

递归方法

java 复制代码 
package kl003.Test6;

public class Monkey {
    public static void main(String[] args) {
        int sum = getSum(9);
        System.out.println(sum);
    }

    private static int getSum(int day) {
        if (day < 0 || day > 10){
            return -1;
        }
        if (day == 10){
            return 1;
        }
        else {
            return (getSum(day + 1) + 1) * 2;
        }
    }
}

运行结果：1534

java 复制代码 
package kl003.Test6;

public class Floor {
    public static void main(String[] args) {
        int cnt  = getCnt(20);
        System.out.println(cnt);
    }

    private static int getCnt(int floor) {
        if (floor == 1){
            return 1;
        }
        if (floor == 2){
            return 2;
        }
        return getCnt(floor - 1) + getCnt(floor - 2);
    }
}

运行结果：

10946

谢谢观看！

相关推荐
_安晓5 分钟前
数据结构 -- 树形查找（二）平衡二叉树
数据结构
水蓝烟雨7 分钟前
[每日一题] 3362. 零数组变换 iii
算法·每日一题
项目申报小狂人8 分钟前
完整改进RIME算法，基于修正多项式微分学习算子Rime-ice增长优化器，完整MATLAB代码获取
学习·算法·matlab
Cherl.13 分钟前
探索数据结构的时间与空间复杂度：编程世界的效率密码
c语言·数据结构·算法·时间复杂度·空间复杂度
charlie11451419116 分钟前
Linux内核深入学习（4）——内核常见的数据结构之链表
linux·数据结构·学习·链表·内核
无聊的小坏坏16 分钟前
【数据结构】AVL树的实现
数据结构
Yu_Mao_Cat20 分钟前
数独求解器3.0 增加latex格式读取
开发语言·python·算法
头发那是一根不剩了24 分钟前
Spring Boot 注解 @ConditionalOnMissingBean是什么
java·spring boot·后端
天若有情6731 小时前
探秘 C++ 计数器类：从基础实现到高级应用
java·开发语言·c++
明天不下雨（牛客同名）2 小时前
介绍一下 MVCC
java·服务器·数据库
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06DeepSeek各版本说明与优缺点分析07Android Termux 安装Kali Linux 或 kali Nethunter史诗级详细教程08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09Coze扣子平台完整体验和实践（附国内和国际版对比）10VMware虚拟机安装Win7专业版保姆级教程（附镜像包）