常见算法和Lambda表达式

最新推荐文章于 2024-07-24 19:35:30 发布
最新推荐文章于 2024-07-24 19:35:30 发布
阅读量559 收藏 16
点赞数 24
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lazy_girl_666/article/details/139423822
版权

常见算法

基本查找：数据无任何顺序

package BasicSearch;

import java.util.ArrayList;

public class BasicSearchDemo1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int target = 8;
        System.out.println(basicSearch(arr,target));

        int[] arr2 = {1,2,3,4,5,6,7,8,9,8};
        int target2 = 8;
        System.out.println(basicSearchIndex(arr2,target2));
    }
    
    public static boolean basicSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return true;
            }
        }
        return false;
    }

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

输出：

二分查找

前提条件：数据必须有序

package BasicSearch;

public class BasicSearchDemo2 {
    public static void main(String[] args) {

        int[] arr = {28,39,289,29023,38942};
        int target = 29023;
        System.out.println(binarySearch(arr, target));
    }

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

输出：

二分查找改进：插值查找

mid = min + (key - arr[min]) / (arr[max] - arr[min]) * (max - min)

要求数据尽可能分布均匀

二分查找改进：斐波那契查询

1 ： 0.618

mid = min + 黄金分割点左半边长度 - 1

分块查找

分块原则1：前一块中的最大数据，小于后一块中所有的数据（块内无需，块间有序）

分块原则2：块数数量一般等于数组的个数开根号。 比如16个数字一般分为4块左右

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

        图来自黑马程序员网课

package BasicSearch;

public class BlockSearchDemo {
    public static void main(String[] args) {


        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        Block block1 = new Block(3,0,3);
        Block block2 = new Block(8,4,7);
        Block block3 = new Block(10,8,9);

        Block[] block = {block1,block2,block3};

        int target = 20;

        int index = getIndex(block,arr,target);
        System.out.println(index);


    }

    public static int getIndex(Block[] block, int[] arr, int target) {
        int indexBlock = findIndexBlock(block,target);
        if (indexBlock == -1){
            return -1;
        }

        int start = block[indexBlock].getStartIndex();
        int end = block[indexBlock].getEndIndex();
        for (int i = start; i <= end; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }

    public static int findIndexBlock(Block[] blocks, int target) {

        for (int i = 0; i < blocks.length; i++) {
            if (blocks[i].getBlockNumber() >= target){
                return i;
            }
        }
        return -1;
    }
}

class Block{

    private int maxValue;
    private int startIndex;
    private int endIndex;

    public Block() {
    }
    public Block(int blockNumber, int startIndex, int endIndex) {
        this.maxValue = blockNumber;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    public int getBlockNumber() {
        return maxValue;
    }

    public void setBlockNumber(int blockNumber) {
        this.maxValue = blockNumber;
    }

    public int getStartIndex() {
        return startIndex;
    }

    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    public int getEndIndex() {
        return endIndex;
    }

    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }
}

输出：

 扩展的分块查找（无规律的数据）

图来自黑马程序员网课

扩展的分块查找（查找的过程中还需要添加数据）

图来自黑马程序员网课

排序算法

冒泡排序：

相邻元素两两比较，大的放右边，小的放左边，第一轮循环结束，最大值找到，在数组的最右边，不停循环。数组中有n个数据，总共执行n-1轮。

package sortDemo;

import java.util.Random;

public class BubbleDemo {
    public static void main(String[] args) {
        Random rand = new Random();
        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        for (int i = 0; i < arr.length; 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;
                }
            }
        }
        for(int arr1 : arr) {
            System.out.print(arr1 + " ");
        }
    }
}

输出：

选择排序

从0索引开始，跟后面的元素一一比较，小的放前面，大的放后面，第一轮循环结束以后，最小的数据已经确定，第二轮循环从1开始以此类推

package sortDemo;

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

输出：

插入排序：

思想：

将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成无序的。遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面

package sortDemo;

public class InsertDEmo {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < arr[i + 1]) {
                startIndex = i + 1;
                break;
            }
        }
        for (int i = startIndex; i < arr.length; i++) {
            for (int j = i; j > 0 && arr[j] > arr[j - 1]; j--){
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
        }
        for (int i:arr){
            System.out.print(i + " ");
        }
    }
}

输出：

递归：

思想：

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

注意点：

        递归一定要有出口，否则就会出现内存溢出

作用：

        把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解

书写递归的两个核心：

        找出口：递归结束条件

        找规则：如何把大问题变成规模较小的问题

        图来自黑马程序员 网课

快速排序：

        第一轮：把0索引的数字作为基准数，确定基准数在数组中正确的位置。比基准数小的全部在左边，比基准数大的全部在右边。

        

package sortDemo;

import java.util.Random;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[100];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt();
        }
        quickSort(arr, 0, arr.length-1);
        for (int i:arr){
            System.out.print(i + " ");
        }

    }
    public static void quickSort(int[] arr, int left, int right) {

        int i = left, j = right;
        if (i > j){
            return;
        }
        int pivot = arr[left];
        while (i < j) {
            while (arr[j] >= pivot && i < j){
                j--;
            }
            while (arr[i] <= pivot && i < j){
                i++;
            }
            if (i < j) {
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
        }
        arr[left] = arr[i];
        arr[i] = pivot;
        quickSort(arr, left, i-1);
        quickSort(arr, i+1, right);

    }
}

Arrays

        操作数组的工具类。

        

package ArraysDemo;

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

public class MyArray {
    public static void main(String[] args) {
        int[] myArray = new int[10];

        Random rand = new Random();
        for (int i = 0; i < myArray.length; i++) {
            myArray[i] = rand.nextInt();
        }

        Arrays.sort(myArray);
        System.out.println(Arrays.toString(myArray));

        //若元素不存在，则返回的是 -插入点-1
        System.out.println(Arrays.binarySearch(myArray,909090909));

        //新数组长度：方法底层会根据第二个参数来创建新的数组
        //如果新数组的长度小于老数组长度，会部分拷贝
        //如果新数组的长度大于老数组长度，会补上默认初始值
        //如果新数组的长度等于老数组长度，会完全拷贝
        int[] newArray = Arrays.copyOf(myArray,3);
        System.out.println(Arrays.toString(newArray));

        int[] newArray2 = Arrays.copyOf(myArray,10);
        System.out.println(Arrays.toString(newArray2));

        int[] newArray3 = Arrays.copyOf(myArray,15);
        System.out.println(Arrays.toString(newArray3));

        //包头不包尾
        System.out.println(Arrays.toString(myArray));
        int[] newArray4 = Arrays.copyOfRange(myArray,0,9);
        System.out.println(Arrays.toString(newArray4));

        Arrays.fill(myArray,0);
        System.out.println(Arrays.toString(myArray));

        Integer[] array = new Integer[10];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(100);
        }
        Arrays.sort(array, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("01:" + o1 + " 02:" + o2);
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(array));

        //若o1 - o2：升序排列
        //若o2 - o1:降序拍列
    }
}

 Lambda表达式

        函数式编程（Functional programming）：

                强调做什么，而不是谁去做

        标准格式：

                Lambda表达式是JDK8开始以后得一种新语法形式

                () ->{

                }

                ()对应着方法的形参，{}对应方法体

        注意点：

        1. Lambda表达式可以用来简化匿名内部类的书写

        2. 只能简化函数式接口的匿名内部类的写法

        3.函数式接口：

                有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FuntionalInterface注解

        省略写法：

                核心：可推导，可省略

                参数类型可以省略不写；如果只有一个参数，参数类型可以省略，同时()也可以省略；

                如果Lambda表达式的方法体只有一行，大括号，分号,return可以省略不写，需要同时省略

package ArraysDemo;

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

public class LambdaDemo2 {
    public static void main(String[] args) {
        String[] arr = {"AA", "BBB", "C", "DDDD", "E", "F"};
        Arrays.sort(arr,(o1,o2) -> o1.length() - o2.length());
        System.out.println(Arrays.toString(arr));
    }
}

输出：

 综合练习：

           第一题：

        

package ArraysDemo;

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

public class Test1 {
    public static void main(String[] args) {
//       String s1 = "a";
//       String s2 = "b";
//       int i = s1.compareTo(s2);
//       System.out.println(i);

       BoyFriend bf1 = new BoyFriend("wyb",29,179);
       BoyFriend bf2 = new BoyFriend("xz",15,180);
       BoyFriend bf3 = new BoyFriend("yy",15,187);

       BoyFriend[] arr = {bf1,bf2,bf3};

//        Arrays.sort(
//                arr,new Comparator<BoyFriend>(){
//                    public int compare(BoyFriend o1, BoyFriend o2) {
//                        double tmp = o1.getAge() - o2.getAge();
//                        tmp = tmp == 0 ? o1.getHeight() - o2.getHeight():tmp;
//                        tmp = tmp == 0 ? o1.getName().compareTo(o2.getName()):tmp;
//
//                        if (tmp == 0){
//                            return 0;
//                        } else if (tmp > 0) {
//                            return 1;
//                        } else if (tmp < 0) {
//                            return -1;
//                        }
//                        return 0;
//                    };
//                }
//        );

        Arrays.sort(
                arr,( o1,  o2)-> {
                        double tmp = o1.getAge() - o2.getAge();
                        tmp = tmp == 0 ? o1.getHeight() - o2.getHeight():tmp;
                        tmp = tmp == 0 ? o1.getName().compareTo(o2.getName()):tmp;

                        if (tmp == 0){
                            return 0;
                        } else if (tmp > 0) {
                            return 1;
                        } else if (tmp < 0) {
                            return -1;
                        }
                        return 0;
                    }
        );

        System.out.println(Arrays.toString(arr));
        System.out.println(arr[0].getHeight());
        System.out.println(arr[1].getHeight());
        System.out.println(arr[2].getHeight());
    }
}

            

lazy_girl_666
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ lambda 表达式深剖
qq_61500888的博客
10-16 2268
带你一命通关C++ lambda 表达式 十分钟手撕语法内涵
一文读懂c++11 Lambda表达式
08-18
Lambda表达式常用于STL算法，如`std::sort`，作为谓词（predicate）来定制比较规则。Lambda可以简化代码，提高可读性，并减少额外的函数定义。例如： ```cpp std::vector<int> numbers = {5, 2, 8, 1, 9}; std::sort...
常见算法&Lambda表达式
qq_58000391的博客
08-19 544
常见算法&Lambda表达式
黑马笔记---常见算法与Lambda表达式
weixin_65440201的博客
06-27 953
目录1.常见算法1.1冒泡排序1.2选择排序1.3二分查找2.Lambda表达式2.1Lambda概述2.2Lambda实战-简化常见函数式接口2.3Lambda表达式的省略规则冒泡排序的思想：每次从数组中找出最大值放在数组的后面去。实现冒泡排序的关键步骤：1.确定总共需要做几轮： 数组的长度-1。2.每轮比较几次:3.当前位置大于后一个位置则交换数据。 代码如下： 1.2选择排序 选择排序的思想：每轮选择当前位置，开始找出后面的较小值与该位置交换。选择排序的关键：确定总共需要选择几轮： 数组的长度-
Lambda表达式详解
唯有努力，方可自信！
06-14 6874
本篇文章将介绍Java中的Lambda表达式，它是Java 8中引入的一项新特性，也是函数式编程的一种风格。我们将深入研究Lambda表达式的语法和用法，讲解如何使用Lambda表达式来写出更加简洁、易读的代码，并介绍Lambda表达式在Java中的应用场景及其优缺点。无论您是初学者还是有一定经验的程序员，本文都将为您提供宝贵的参考和帮助。
【C++11】lambda表达式详解
平淡中造就不平凡
07-18 411
Lambda表达式是现代C++在C ++ 11和更高版本中的一个新的语法糖 ，在C++11、C++14、C++17和C++20中Lambda表达的内容还在不断更新。Lambda表达式（外文名：lambda expression）是一个匿名函数，即没有函数名的函数。
lambda 表达式
04-04
Lambda表达式在实际编程中有着广泛的应用，以下是一些常见的使用场景： 1. **排序算法中的自定义比较**：可以使用lambda表达式来定义复杂的比较逻辑，从而实现灵活的数据排序。 ```cpp std::sort(vec.begin(), ...
结合C++11新特性来学习C++中lambda表达式的用法
01-20
Lambda表达式常用于简化代码，特别是处理算法和异步编程时，可以快速封装并传递小段功能代码。下面将详细解释lambda表达式的各个组成部分和使用方法。 首先，lambda表达式的定义始于一个方括号`[ ]`，这部分叫做...
Java8集合 CompletableFuture lambda表达式 新的TimeAPI 和ForkJoin Demo包
03-19
在集合操作如`stream()`和`forEach()`中，lambda表达式的使用尤为常见。 2. **Java 8集合**： Java 8对集合框架进行了扩展，引入了`Stream API`，提供了丰富的函数式编程操作，如`filter()`, `map()`, `reduce()`...
运用lambda表达式+策略模式实现平台扩展（Extension）
12-22
综上所述，通过结合策略模式、lambda表达式和注解，我们可以构建出一个高度可扩展的平台。这种设计允许业务逻辑与基础架构分离，便于维护和升级，同时也降低了新功能的集成成本。在压缩包文件的`new`目录中，可能...
算法-KMP字符串匹配
xx_xb的博客
07-23 234
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 884
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 281
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
【常微分方程】
qq_74285286的博客
07-24 305
常微分方程笔记
AtCoder Beginner Contest 363(A~D题)
sin1810335764的博客
07-23 229
枚举长度，首先计算出答案回文数的长度。通过枚举和减法可以计算出是当前长度下第k𝑘大的回文数。而前一半就是顺序的，第k𝑘大就是当前长度的数的第k𝑘大，这个很好求。接下来只需要构成回文，直接输出即可。将L𝐿从小往大排序，那么只需要第n−P+1𝑛−𝑃+1大的数满足条件即可，假设这个数是a𝑎。因此，只需要计算T−a𝑇−𝑎即可。注意，如果这个数是负数，意味着初始时就满足条件，此时要输出00。我们只需要找到下一阶段的下限。a / 100 是本阶段+1 变成下一阶段，再 * 100变成下限，再与原来的相减即可。
算法：BFS解决 FloodFill 算法
一名还在努力学习技术的程序员的博客
07-24 1076
本篇博客是关于BFS 解决 FloodFill 算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
三维点云中常用的表面重建算法
Argulo的博客
07-22 1334
表面重建算法起源于计算机视觉和计算几何学领域。早期的研究集中在从二维图像中提取三维信息。然而，随着三维扫描技术的进步，越来越多的研究转向了如何从点云数据中重建表面。三维点云表面重建技术的发展，始于20世纪90年代，主要推动力是激光扫描和结构光扫描的广泛应用。
2024.7.24 作业
最新发布
qq_64434282的博客
07-24 1086
【代码】2024.7.24 作业。
Java实现七大排序（二）
lllsure的博客
07-23 548
冒泡排序、快速排序、归并排序
C++11 lambda表达式详解：匿名函数的魔力
Lambda表达式的一个常见用途是与STL算法结合，例如在`std::sort`或`std::transform`中定义排序或转换规则。它们也可以用作`std::function`或其他接受可调用对象的类型的参数。 现代C++的其他重要特性还包括： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值