JAVA——常见算法

已于 2024-10-18 16:22:24 修改
阅读量477 收藏 5
点赞数 5
文章标签： java 算法 开发语言
于 2024-10-09 20:15:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ling_suu/article/details/142766170
版权

查找算法

基本查找

从0索引开始查找

是否找到

package com.itheima.search;

import java.security.KeyStore;

public class BasicSearchDemo1 {
    public static void main(String[] args) {
        int[] arr = {23, 34, 54, 24, 43, 46};
        int number = 43;
        System.out.println(basicSearch(arr, number));
    }

    private static boolean basicSearch(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

返回索引

package com.itheima.search;

import java.util.ArrayList;

public class BasicSearchDemo2 {
    public static void main(String[] args) {
        int[] arr = {23, 34, 54, 24, 43, 46, 34};
        int number = 34;
        int num = findNum(arr, number);
        System.out.println(num);
        ArrayList<Integer> num2 = findNumList(arr, number);
        for (int i = 0; i < num2.size(); i++) {
            if (i == num2.size() - 1) {
                System.out.println(num2.get(i));
            } else {
                System.out.print(num2.get(i) + ", ");
            }
        }
    }

    private static int findNum(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return i;
            }
        }
        return -1;
    }

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

二分查找 / 折半查找

  • 前提条件：数组中的数据有序
  • 核心逻辑：每次排除一般的查找范围
package com.itheima.search;

import javax.sound.midi.MidiChannel;

public class BinarySearchDemo1 {
    public static void main(String[] args) {
        int[] arr = {23, 34, 54, 64, 75, 98};
        int number = 34;
        int search = binarySearch(arr, number);
        System.out.println(search);
    }

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

插值查找

package com.itheima.search;

public class ChaZhiSearchDemo {
    public static void main(String[] args) {
        int[] arr = {12, 23, 45, 56, 76, 89, 98};
        int number = 45;
        int index = getIndex(arr, number);
        System.out.println(index);
    }

    private static int getIndex(int[] arr, int number) {
        int min = 0;
        int max = arr.length - 1;
        while (true) {
            if (min > max) {
                return -1;
            }
            int mid = min + ((number - arr[min]) / (arr[max] - arr[min]) * (max - min));
            if (number < arr[mid]) {
                max = mid - 1;
            } else if (number > arr[mid]) {
                min = mid + 1;
            } else {
                return mid;
            }
        }
    }
}

斐波那契查找

 二分查找、插值查找、斐波那契查找的异同

分块查找

package com.itheima.search;

public class BlockSearchDemo {
    public static void main(String[] args) {
        int[] arr = {16, 5, 9, 12, 21, 18,
                     32, 23, 37, 26, 45, 34,
                     50, 48, 61, 52, 73, 66};
        int number = 37;
        Block b1 = new Block(21, 0, 5);
        Block b2 = new Block(45, 6, 11);
        Block b3 = new Block(73, 12, 17);

        Block[] blocks = {b1, b2, b3};
        int index = getIndex(arr, blocks, number);
        System.out.println(index);
    }

    private static int getIndex(int[] arr, Block[] blocks, int number) {
        int index = getBlockIndex(blocks, number);
        if (index == -1) {
            return -1;
        }
        for (int i = blocks[index].getStartIndex(); i <= blocks[index].getEndIndex(); i++) {
            if (number == arr[i]) {
                return i;
            }
        }
        return -1;
    }

    private static int getBlockIndex(Block[] blocks, int number) {
        for (int i = 0; i < blocks.length; i++) {
            if (number <= blocks[i].getMax()) {
                return i;
            }
        }
        return -1;
    }
}

class Block {
    private int max;
    private int startIndex;
    private int endIndex;

    public Block() {
    }

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

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

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

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

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

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

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

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

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

package com.itheima.search;

public class BlockSearchDemo1 {
    public static void main(String[] args) {
        int[] arr = {27,22,30,40,36,
                     13,19,16,20,
                     7,10,
                     43,50,48};
        int number = 48;
        Block1 b1 = new Block1(22,40,0,4);
        Block1 b2 = new Block1(13,20,5,8);
        Block1 b3 = new Block1(7,10,9,10);
        Block1 b4 = new Block1(43,50,11,13);

        Block1[] block1s = {b1, b2, b3, b4};
        int index = getIndex(arr, block1s, number);
        System.out.println(index);
    }

    private static int getIndex(int[] arr, Block1[] block1s, int number) {
        int index = getBlockIndex(block1s, number);
        if (index == -1) {
            return -1;
        }
        for (int i = block1s[index].getStartIndex(); i <= block1s[index].getEndIndex(); i++) {
            if (number == arr[i]) {
                return i;
            }
        }
        return -1;
    }

    private static int getBlockIndex(Block1[] block1s, int number) {
        for (int i = 0; i < block1s.length; i++) {
            if (number >= block1s[i].getMin() && number <= block1s[i].getMax()) {
                return i;
            }
        }
        return -1;
    }
}

class Block1 {
    private int min;
    private int max;
    private int startIndex;
    private int endIndex;

    public Block1() {
    }

    public Block1(int min, int max, int startIndex, int endIndex) {
        this.min = min;
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     * @return min
     */
    public int getMin() {
        return min;
    }

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

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

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

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

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

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

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

    public String toString() {
        return "Block{min = " + min + ", max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

哈希查找

排序算法

冒泡排序

package com.itheima.sort;

public class BubbleDemo1 {
    public static void main(String[] args) {
        int[] arr = {2, 4, 5, 3, 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] + " ");
        }
    }
}

选择排序

package com.itheima.sort;

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

插入排序

package com.itheima.sort;

public class ChaRuSearchDemo {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        // 首先找到无序的第一个索引即是38的索引
        // 1. 先定义一个变量记录索引
        int startIndex = -1;
        // 2. 遍历数组得到无序索引
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                startIndex = i + 1;
                break;
            }
        }

        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--;
            }
        }

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

递归算法

  • 递归指的是方法中调用方法本身的现象
  • 递归的注意点：递归一定要有出口，否则就会出现内存溢出

package com.itheima.sort;

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

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


package com.itheima.sort;

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

    public static int getJi(int number) {
        if (number == 1) {
            return 1;
        }

        return number * getJi(number - 1);
    }
}

快速排序

 

package com.itheima.sort;

public class QuickSortDemo {
    public static void main(String[] args) {
        int[] arr = {4,10,2,5,36,78,6,3};
        int i = 0;
        int j = arr.length - 1;
        quickSort(arr,i ,j);

        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k] + " ");
        }
    }

    public static void quickSort(int[] arr, int i, int j) {
        int start = i;
        int end = j;

        if (start > end) {
            return;
        }

        while (end != start) {
            while (end > start && arr[end] > arr[i]) {
                end--;
            }
            while (end > start && arr[start] < arr[i]) {
                start++;
            }
            int temp = arr[end];
            arr[end] = arr[start];
            arr[start] = temp;
        }

        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        quickSort(arr, i, start - 1);
        quickSort(arr, start + 1, j);
    }
}

Ling_suu
关注
Java十大常见算法——动态规划算法
警警的博客
01-10 451
打印商品
Java——常见的几种排序算法
热门推荐
Vicky_Tang
08-22 1万+
一、冒泡排序 每次冒泡过程都是从数列的第一个元素开始，然后依次和剩余的元素进行比较, 跟列队一样, 从左到右两两相邻的元素比大小, 高的就和低的换一下位置. 最后最高(值最大)的肯定就排到后面了. 但是这只是把最高的排到后面了, 还得找出第二高的, 于是又从第一个开始两两比较, 高的往后站, 然后第二高的也到后面了. 然后是第三高的再往后排… public class JavaSort { public static void main(String[] args) { .
Java加密与安全 —— 常见哈希算法
weixin_45939128的博客
07-21 2390
常见哈希算法
Java——数据结构与算法
定期分享编程干货~
04-14 4361
一.数据结构： 1.定义：数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。 2.常见类型：数组Array、栈stack、队列queue、链接LinkedList、树Tree、哈希表、堆heap、图graph 3.区别：主要有四个方面，【底层（数组、链表、树）、是否线程安全、是否有序、值是否唯一】 大多数底层都是（数组+链表） 线程安全：vector、hashTable、ConcurrentHashMap 有序：vector、LinkedList...
算法【Java】—— 双指针算法
熵减玩家
08-16 3167
用Java 语言实现双指针算法
常见算法——贪心算法(贪婪算法) Greedy algorithm
weixin_43713707的博客
04-12 1329
假设存在如下表的需要付费的广播台，以及广播台信号可以覆盖的地区。如何选择最少的广播台，让所有 的地区都可以接收到信号。
Java数组常见算法3——排序算法（冒泡排序、快速排序）
Etlevent的博客
04-08 180
Java数组的常见排序算法简介，两种主要的排序算法实现——冒泡排序、快速排序
java常见排序算法_Java常见排序算法详解——希尔排序
weixin_39726379的博客
02-25 85
原标题：Java常见排序算法详解——希尔排序概念：希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了(此时插入排序较快)。希尔排序是基于插入排序的以下两点性质而提出改进方法的：插入排序在对几乎已经排好序的数据操作时， 效率高...
Java并发编程——CAS算法定义和使用案例
weixin_44814196的博客
08-07 1042
CAS( Compare And Swap) 是一种保障变量操作原子性的无锁算法，可以在多个线程之间实现对共享数据的安全更新。
十大经典排序算法——java语言
weixin_56781779的博客
11-11 6510
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
算法可视化系列——排序算法——希尔排序
04-19
希尔排序（Shell Sort）是一种基于插入排序的快速排序方法，由Donald Shell于...`AlgorithmShellSort.java`文件中的代码将具体展示如何在Java中实现这一算法。对于学习和理解排序算法，希尔排序是不可或缺的一部分。
常用加密算法的Java实现总结(二)——对称加密算法DES、3DES和AES.pdf
02-10
对称加密算法包括了多种算法，本文主要介绍DES、3DES和AES这三种常见的对称加密算法，并对它们进行Java实现的总结。 首先，对称加密算法的一个关键优势在于其算法公开、计算量小、加密速度快、加密效率高，但它们也...
Java开发 | 数据结构和算法之——递归算法
mt776333的博客
03-11 2074
著名的Pascal之父——Nicklaus Wirth（沃斯）让他获得图灵奖的一句话就是他提出的著名公式：“程序=数据结构+算法”，这个公式对计算机科学的影响类似于爱因斯坦的质能方程在物理界的影响。 因此可以看出来数据结构和算法在我们开发程序中有多么的重要了，下面我们来简单认识下数据结构和算法… 1. 数据结构和算法介绍 数据结构介绍 数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率，对于程序来说选择一个好
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 115
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 281
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 274
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 468
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 294
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值