Java必掌握的算法

最新推荐文章于 2024-04-27 07:48:06 发布
最新推荐文章于 2024-04-27 07:48:06 发布
阅读量609 收藏 3
点赞数
文章标签： 算法 排序算法 二分法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44334291/article/details/109851932
版权

在java的世界中，算法也是很重要的，通常情况下，我们的职位对于算法并没有很大的需求，因为一般都是你在未来想做到更高的职位的话，拿个年薪四五十万的时候，算法就是必不可少的。基础阶段掌握一些基本算法还是很有必要的。

在介绍这些必掌握的算法之前，先科普 一下一些基础知识

  1. 算法消耗的时间：一个算法消耗的时间是指算法中所有语句执行的时间的总和，每条语句执行的时间等于语句执行的次数乘以执行一次所需要的时间。

  2. 常用的算法时间复杂度：
    在这里插入图片描述
    怎么计算的呢？有一个粗略的计算方法：
    看该段程序执行了多少次，求和即可。

for(i= 0;i<=n;i++){
for(j=0;j<=i;j++){
s;  //伪代码   (n+1)(n+2)/2  时间复杂度
}
  1. 空间复杂度:定义为该算法所耗费的 存储空间的数量级，比如定义了一个数组大小为n的数组，则它的空间复杂度就是O(n),如果只是需要一个变量则它的空间复杂度就是O(1)

那就介绍一下大学中用到的一些算法吧（当然其中的二分查找，冒泡与快速排序等，面试的时候也是经常会遇到的哟）

二分法查找

定义：
二分法的使用前提就是有序的一串数据，不然无法使用，二分法的核心在于定义两个索引，找到中间值，与我们要找的数值比较，然后再进行求中间值，再进行比较。
代码如下：

public class ceshi01 {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5,6,7,8,9,10};
        int num=8;
        System.out.println("hao");
        int index=getindex(arr,num);
        System.out.println(index);

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

直接插入排序

核心：找到第二个元素为标志，从左到右依次前面的元素比较，直接插到最小的位置，然后标志往后移动，重复上述过程即可。
代码：

public class ceshi05 {
    public static void main(String[] args) {
        int [] arr={48,62,35,77,55,14,35,98};
        for (int i = 1; i < arr.length; i++) {
            int j;
            int temp=arr[i];//存储要进行插入的元素
          for(j=i-1;j>=0&&arr[j]>temp;j--){  //与离它最近的元素开始比较  如果比它大就换位
              arr[j+1]=arr[j];
          }
          arr[j+1]=temp;
          printArray(arr);
        }

    }

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

}

冒泡排序

核心：通过相邻的元素之间比较，大的放右边，小的放左边。
代码：

public class ceshi02 {
    public static void main(String[] args) {
        int [] arr={5,2,1,4,3};
        maoPao(arr);
    }

    /*
    冒泡排序
     */
    private static void maoPao(int[] arr) {
        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;
                }
            }
        }
        printArray(arr);
    }

    /**
     * 打印数组
     * @param arr
     */
    private static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println();
    }
}

归并排序

核心：这个要看你是准备几个为一组，几个为一组就是几路归并排序，比如2-路归并排序就是将待排序列中相邻的两个有序序列合并成一个有序序列。
代码：

public class ceshi06 {
    public static void main(String[] args) {
        int[] arr = {19, 13, 5, 27, 1, 26, 31, 16,45};
        sort(arr,0, arr.length-1);
        printArray(arr);

    }
//递归进行排序
    public static void sort(int[] arr, int left, int right) {
        if (left == right) return;
        //分两半
        int mid = left + (right -left) / 2;
        //左边排序
        sort(arr, left, mid);
        //右边排序
        sort(arr, mid + 1, right);
        merge(arr, left, mid + 1, right);
    }   
//对有序的两个部分进行合拼
    public static void merge(int[] arr, int left, int right, int rightBound) {
        int mid = right - 1;
        int[] temp = new int[rightBound - left + 1];
        int i = left;
        int j = right;
        int k = 0;
        while (i <= mid && j <= rightBound) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= rightBound) {
            temp[k++] = arr[j++];
        }
//        printArray(temp);
//将排好序的新数组赋值为原来的数组
        for (int m = 0; m < temp.length; m++) {
            arr[left+m]= temp[m];
        }

    }

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

    }

}

基数排序

基数排序在本质上是 一种多关键字的一种排序，以三位数为例，它首先按照个位数的大小进行排序，然后再按照十位数进行排序，最后再按照百位排序即可。
这里面有一个很重要的思想 在这个思想就是桶思想，所谓的桶思想就是我们把我们的每个数字我在我们实现建立的数组里面，数组的下标就是元素的值，每一次遇到与数组下标相同的值都让数组对应下标的值加1就可以了

/**
 * @author: 岐神~汤圆
 * @Description:  基数排序
 * @Attention:
 * @date: 2020/12/8 16:56
 * @version:1.0
 */
public class ceshi13 {
    public static void main(String[] args) {
        int [] arr={421,240,115,532,205,430,124};
        int [] result=sort(arr);
        System.out.println(Arrays.toString(result));
    }

    private static int[] sort(int[] arr) {
        int [] result=new int[arr.length];
        int [] count=new int[10];//这个数组就相当于一个桶  里面存放的是0-9之间数字的个数  也就是 是对应的数字就放进去

        //这个循环是为了表示循环的是哪一位数字
        for (int i = 0; i < 3; i++) {
            int division=(int) Math.pow(10,i);
            System.out.println(division);
            for (int j = 0; j < arr.length; j++) {
                //获取每一位数字  第一次进来的是获得数组中所有的个位数字
                int num=arr[j]/division%10;
                System.out.print(num+" ");
                count[num]++;
            }
            System.out.println();
            System.out.println(Arrays.toString(count));
            for (int m = 1; m < count.length; m++) {
                count[m]=count[m]+count[m-1];
            }
            System.out.println("===========");
            System.out.println(Arrays.toString(count));
            System.out.println("===========");
            for (int n = arr.length-1; n>=0;n--) {
                int num=arr[n]/division%10;//比如说最后一个元素为2，那它出现的位置就是count[2]的值-1的位置
                result[--count[num]]=arr[n];
            }
            System.arraycopy(result,0,arr,0,arr.length);
            Arrays.fill(count,0);
        }
        return  result;
    }
}

这个算法的难点在于
在这里插入图片描述
这一部分的操作，怕你们不太明白，我在这里简单解释一下，这里面的count[m]=count[m]+count[m-1]代表的是数组中值代表的是与索引值相等的元素的最后一个排完序之后应该出现的位置。

快速排序

核心：以第一个为基数，分别设置两个标志，分别是第一个元素与最后一个元素，分别于基数比较，左边的标志大于基数，右边的标志小于基数式，两者交换，当两个标识在同一个位置的时候与基数交换，这个时候基数就在最终的位置，左边的元素都比其小，右边的元素都比其大，最后递归执行即可。
代码：

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

    /**
     * 快速排序的核心代码
     * @param arr
     * @param left
     * @param right
     */
    public static void quiteSort(int [] arr,int left,int right) {
        if (left >right) {
            return;
        }
        int left0 = left;
        int right0 = right;
        while (left != right) {
            while (arr[right] >= arr[left0] && left < right) {
                right--;
            }
            while (arr[left] <= arr[left0] && left < right) {
                left++;
            }
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        int temp = arr[left0];
        arr[left0] = arr[left];
        arr[left] = temp;
        quiteSort(arr, left0, left - 1);
        quiteSort(arr, left + 1, right0);
    }
}

简单选择排序

简单排序的定义：我们第一次查出最小的元素，并与第一个位置交换，然后从第一个以外的元素求出最小值在与剩下元素的第一个交换位置，一直到最后。这样就完成了我们的简单排序。

public class ceshi14 {
    public static void main(String[] args) {
        int [] arr={1,4,3,6,9,2,8,7};
        for (int j = 0; j < arr.length; j++) {
            int sum=arr[j];//记录的是最小值
            int flag=0;
            for (int i = j+1; i < arr.length; i++) {
                if(sum>arr[i]){
                    sum=arr[i];
                    flag=i;
                }
            }
            if(flag!=0) {
                int c = arr[j];
                arr[j] = sum;
                arr[flag] = c;
            }
            for (int i : arr) {
                System.out.print(i);
            }
            System.out.println();
        }
    }
}

希尔排序

希尔排序的思想在于：每一次设置一个间隔。让指定间隔的数据进行排序，所用的排序的方法就是插入排序；进行完一轮的排序之后，再进行缩小间隔，接着开始排序，最后的间隔缩小到1为止。
一般间隔越大，一定的次数越少，间隔越小，移动的距离越少
一般都不怎么用这个算法

/**
 * @author: 岐神~汤圆
 * @Description:  希尔排序
 * @Attention: 这个其实就是在插入排序的基础上进行改进的一种算法
 * @date: 2020/12/11 19:05
 * @version:1.0
 */
public class ceshi15 {
    public static void main(String[] args) {
        int [] arr={2,3,21,4,5,15,6,9,10,16,18,13,1,17,11};
        sort(arr);
        print(arr);
    }

    /**
     * 打印数组
     * @param arr
     */
    public  static void print(int[] arr) {
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }

    public static void sort(int[] arr) {
        //这段代码主要是为了为了确定我们的间隔个数，比二分法的间隔次数更加快，  这个序列叫做;Knuth
        int h=1;
        while(h<arr.length/3){
            h=h*3+1;
        }
        for(int grap=h;grap>0;grap=(grap-1)/3){
            for (int i=grap;i<arr.length;i++){
                for (int j=i;j>grap-1;j-=grap){
                    if(arr[j]<arr[j-grap]){
                        change(arr,j,j-grap);
                    }
                }
            }
        }
    }

    public  static void change(int[] arr, int j, int i) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

总结：

知道这些算法的原理是很重要的，具体算法的实现就看个人了，其实刚开始阶段没有掌握也没有问题，但是算法思想一定要有的。
写算法的核心：

  1. 能将大问题转化为一个小问题，最慢慢去向最终的结果靠拢，只是说算法而言，因为算法难，我们直接从整体考虑不容易写出来
  2. 先粗略化，写的差不多再考虑算法的优化
昔年1206
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java demo 算法笔记
10-18
这份"Java demo 算法笔记"集合了Java开发中的多种关键知识点，包括但不限于基础语法、框架源码解析、算法实现以及并发处理等内容，对于学习和提升Java编程技能具有极大的帮助。 首先，我们来探讨Java的基础部分。...
java字符串相似度算法
09-03
Java字符串相似度算法是用于衡量两个字符串之间相似程度的一种计算方法。在文本处理、信息检索、数据清洗等领域中，这种算法具有重要...了解并掌握这些算法，对于进行文本分析、信息匹配和数据清理等任务来说至关重要。
Java 必会10大的经典算法
xmt1139057136的专栏
09-30 1万+
本文来源：https://github.com/hustcc/JS-Sorting-Algorithm排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排...
java 常见算法
漫—流的博客
10-21 656
整理收集java的常见算法
Java语言常用的算法
weixin_46228563的博客
04-27 357
Java语言常用的算法包括：排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序等。查找算法：顺序查找、二分查找、哈希查找等。字符串匹配算法：暴力匹配、KMP算法、Boyer-Moore算法等。图论算法：最短路径算法、最小生成树算法、拓扑排序等。动态规划算法：背包问题、最长公共子序列、最长上升子序列等。贪心算法：最小生成树、单源最短路径等。分治算法：快速排序、归并排序等。网络流算法：最大流问题、最小割问题等。数学算法：欧几里得算法、素数判断、大数计算等。
JAVA 基础算法汇总（持续更新）
dayu199804的博客
04-14 1万+
前言 做一些基础数据结构算法汇总，便于日后复习。 一、查找算法 1.顺序查找（线性查找） 依据数组的下标按顺序进行查找，然后返回数组下标。对于数据量较小的情况，比较适用。但是如果数据量较大，花费的时间就比较多。 2.二分查找 二分查找Binary Search 二分查找的使用，要有一个前提条件：要查找的数必须在一个有序数组里。在这个前提下，取中间位置数作为比较对象： 若要查找的值和中间数相等，则查找成功。 若小于中间数，则在中间位置的左半区继续查找。 若大于中间数，则在中间位置...
LeetCode算法：0~99道
qq_43265673的博客
02-24 374
冒泡排序 定义一个布尔变量 hasChange，用来标记每轮是否进行了交换。在每轮遍历开始时，将 hasChange 设置为 false。 若当轮没有发生交换，说明此时数组已经按照升序排列，hashChange 依然是为 false。此时外层循环直接退出，排序结束。 代码示例 Java import java.util.Arrays; public class BubbleSort { private static void bubbleSort(int[] nums) { b
整理好的java面试八大常用算法
wangyuxi__的博客
04-22 2058
原创不易，如果有转载需要的话，请在首行附上本文地址，谢谢。 文中整理了八大常见的排序算法，冒泡排序、选择排序、快速排序、插入排序、堆排序、希尔排序、归并排序和基数排序的简单思想，每种算法配有动图分析和相应的java代码，为了方便有缘人进一步地了解各种算法，本文也附上了相应算法详细介绍的链接地址。在本文的文末，对这八种排序算法的稳定性，时间复杂度和排序算法的大致选择做了一个简单的总结。（本文的动图...
java算法代码.zip
03-28
Java算法代码.zip是一个包含Java编程语言实现的算法集合的压缩文件。这个压缩包可能包含了各种数据结构和算法的实现，对于学习和理解Java编程以及提升编程能力非常有帮助。Java是一种广泛使用的面向对象的开发语言，...
java语言练习算法.zip
最新发布
06-26
算法是解决问题的精确步骤，是编程的灵魂，对于任何编程语言来说，理解和掌握算法都至关重要。 Java中的算法练习通常涵盖排序、搜索、图论、动态规划等多个方面。例如，"algorithm-questions-master"可能是一个包含...
JAVA经典算法90道
10-17
在编程领域，算法是解决问题的关键，对于Java开发者来说，掌握一系列经典的算法至关重要。"JAVA经典算法90道"这个资源提供了丰富的练习题，旨在帮助Java程序员提升算法思维和编程技巧。下面，我们将深入探讨其中的...
JAVA经典算法大全（都会就算牛逼的了）
03-07
一份很好的java 算法大全，java进阶的必备神器。非常经典的一些小算法。搞java的可以备一份
程序员必知必会经典算法
08-26
实用经典算法，每一个程序员都必知必会的算法
java算法大全
01-21
开发健壮的软件需要高效的算法，然而程序员们往往直至问题发生之时，才会去求助于算法。本书讲解了许多现有的算法，可用于解决各种问题。通过阅读它，你可以学会如何选择和实现正确的算法，来达成自己的目标。另外，书中的数学深浅适中，足够使你了解并分析算法的性能。 通过本书，你可以： · 解决特定代码的问题，或者提升现有解决方案的性能。 · 快速找到与你所解决的问题相关的算法，并决定哪种算法才是最适合的。 · 探索使用C、C++、Java以及Ruby实现的算法解决方案以及开发小贴士。 · 了解算法预期的性能，以及它达到最高性能时所需要的条件。 · 发现不同算法之间相似的设计哲学。 · 学习高级数据结构，来提升算法的性能。 通过本书，你能学到如何提升算法的性能，这将是你的软件应用程序走向成功的关键。
Java开发也需要懂算法吗？
qianfeng_dashuju的博客
05-23 6257
　　很多Java开发同学经常有一个疑惑，搞Java开发也需要懂算法吗?本文咱们就来谈谈这个问题。 　　其实如果你开发一个非常复杂而且有挑战的大型系统，那么必然会在系统中使用算法。同理，如果你可以将算法进行合理的优化，那么也可以将系统性能提升几十倍! 　　空口无凭，下面用真实案例来进行说明。我们一起来看看Hadoop在部署了大规模的集群场景下，大量客户端并发写数据的时候，文件契约监控算法的性能优...
Java中必须要会的几个算法
于歌852的标题
06-29 511
Java中常见的算法 递归 二分查找 快速排序 冒泡排序 选择排序 递归 递归本质：程序调用自身的编程技巧叫做递归。 方法的递归调用指的是一个方法自己调用自己的形式。一般如果要进行方法的递归操作往往都具备有以下的特点： 方法必须有一个递归的结束条件； 方法在每次递归处理的时候一定要做出一些变更； 代码举例如下： public class Algorithm { //递归 public static void main(String[] args) { Scanner
java一些必会算法
NotesChapter
03-10 1152
https://blog.csdn.net/qq_23994787/article/details/77951244#_Toc12190
(java)五大常用算法
热门推荐
qq_39147389的博客
08-31 8万+
算法一：分治法 基本概念 1.把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。 2.分治策略是对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原...
Java经典面试题-算法.docx
05-06
Java经典面试题-算法.docx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值