精华内容
下载资源
问答
  • JAVA经典算法面试39及答案,算法是不得不看的
  • java算法 面试必备 安卓面试 必备算法
  • Java 算法面试题 判断质数
  • 经典的Java算法面试题

    千次阅读 2017-10-11 17:35:51
    1、新浪面试题:编写一个方法,计算一个字符串中,第一个不重复的字符在当前字符串中的索引。public class JavaTest { //贪心算法 编写一个方法,计算一个字符串中,第一个不重复 的字符在当前字符串中的索引。 ...

    1、新浪面试题:编写一个方法,计算一个字符串中,第一个不重复的字符在当前字符串中的索引。

    public class JavaTest {
    
        public  static String array = "abuacdeaudbdfcefhph";
    
        public static int[] container = new int[128];
    
        public static void main(String[] args) {
    
            for (int i = 0; i <array.length() ; i++) {
                int index = Character.valueOf(array.charAt(i)).hashCode();
                container[index] ++;
            }
    
            for (int i = 0; i <array.length() ; i++) {
                int index = Character.valueOf(array.charAt(i)).hashCode();
                if (container[index] == 1) {
                    System.out.println("index: " + i);
                    System.out.println("char: " + array.charAt(i));
                    break;
                }
            }
        }
    }
    展开全文
  • 面试常见算法题

    2018-05-17 17:20:12
    这是在面试中遇到的一些常见算法题,笔试面试经常遇到,所以总结了一下,方面以后查看,分享给大家。
  • 2021年面试题集合,某培训平台的整理得出,资源集合题目差不多800多,很全面,面试可以靠它了
  • java算法大全_java经典算法_算法面试题大全含答案

    万次阅读 多人点赞 2019-05-16 09:44:18
  • Java笔试面试-算法常用面试题

    万次阅读 多人点赞 2019-11-19 19:18:43
      选择排序(Selection Sort)算法也是比较简单的排序算法,其实现思路是每一轮循环找到最小的值,依次排到数组的最前面,这样就实现了数组的有序排列。   比如,下面是一组数据使用选择排序的执行流程: 初始...

    1.说一下什么是二分法?使用二分法时需要注意什么?如何用代码实现?

      二分法查找(Binary Search)也称折半查找,是指当每次查询时,将数据分为前后两部分,再用中值和待搜索的值进行比较,如果搜索的值大于中值,则使用同样的方式(二分法)向后搜索,反之则向前搜索,直到搜索结束为止。
     二分法使用的时候需要注意:二分法只适用于有序的数据,也就是说,数据必须是从小到大,或是从大到小排序的。

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 二分法查找
            int[] binaryNums = {1, 6, 15, 18, 27, 50};
            int findValue = 27;
            int binaryResult = binarySearch(binaryNums, 0, binaryNums.length - 1, findValue);
            System.out.println("元素第一次出现的位置(从0开始):" + binaryResult);
        }
        /**
         * 二分查找,返回该值第一次出现的位置(下标从 0 开始)
         * @param nums      查询数组
         * @param start     开始下标
         * @param end       结束下标
         * @param findValue 要查找的值
         * @return int
         */
        private static int binarySearch(int[] nums, int start, int end, int findValue) {
            if (start <= end) {
                // 中间位置
                int middle = (start + end) / 2;
                // 中间的值
                int middleValue = nums[middle];
                if (findValue == middleValue) {
                    // 等于中值直接返回
                    return middle;
                } else if (findValue < middleValue) {
                    // 小于中值,在中值之前的数据中查找
                    return binarySearch(nums, start, middle - 1, findValue);
                } else {
                    // 大于中值,在中值之后的数据中查找
                    return binarySearch(nums, middle + 1, end, findValue);
                }
            }
            return -1;
        }
    }
    

    执行结果如下:

    元素第一次出现的位置(从0开始):4
    

    2.什么是斐波那契数列?用代码如何实现?

      斐波那契数列(Fibonacci Sequence),又称黄金分割数列、因数学家列昂纳多·斐波那契(Leonardoda Fibonacci)以兔子繁殖为例子而引入,故又称为“兔子数列”,指的是这样一个数列:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233,377,610,987,1597,2584,4181,6765,10946,17711…… 在数学上,斐波那契数列以如下被以递推的方法定义:
      F(1)=1,F(2)=1, F(n)=F(n-1)+F(n-2)(n>=3,n∈N*)在现代物理、准晶体结构、化学等领域,斐波纳契数列都有直接的应用。

      斐波那契数列之所以又称黄金分割数列,是因为随着数列项数的增加,前一项与后一项之比越来越逼近黄金分割的数值 0.6180339887……

      斐波那契数列指的是这样一个数列:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233,377,610,987,1597,2584,4181,6765,10946,17711……

      斐波那契数列的特征:第三项开始(含第三项)它的值等于前两项之和。

      斐波那契数列代码实现示例,如下所示:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 斐波那契数列
            int fibonacciIndex = 7;
            int fibonacciResult = fibonacci(fibonacciIndex);
            System.out.println("下标(从0开始)" + fibonacciIndex + "的值为:" + fibonacciResult);
        }
        /**
         * 斐波那契数列
         * @param index 斐波那契数列的下标(从0开始)
         * @return int
         */
        private static int fibonacci(int index) {
            if (index == 0 || index == 1) {
                return index;
            } else {
                return fibonacci(index - 1) + fibonacci(index - 2);
            }
        }
    }
    

    执行结果如下:

    下标(0开始)7的值为:13
    

    3.一般而言,兔子在出生两个月后,就有繁殖能力,一对兔子每个月能生出一对小兔子来。如果所有兔子都不死,那么一年以后可以繁殖多少对兔子?请使用代码实现。

      先来分析一下,本题目

    • 第一个月:有 1 对小兔子;
    • 第二个月:小兔子变成大兔子;
    • 第三个月:大兔子下了一对小兔子;
    • 第四个月:大兔子又下了一对小兔子,上个月的一对小兔子变成了大兔子;
      ……
      最后总结的规律如下列表所示:

    在这里插入图片描述
    可以看出,兔子每个月的总对数刚好符合斐波那契数列,第 12 个月的时候,总共有 144 对兔子。 实现代码如下:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 兔子的总对数
            int rabbitNumber = fibonacci(12);
            System.out.println("第 12 个月兔子的总对数是:" + rabbitNumber);
        }
        /**
         * 斐波那契数列
         * @param index 斐波那契数列的下标(从0开始)
         * @return int
         */
        private static int fibonacci(int index) {
            if (index == 0 || index == 1) {
                return index;
            } else {
                return fibonacci(index - 1) + fibonacci(index - 2);
            }
        }
    }
    

    执行结果如下:

    12 个月兔子的总对数是:144
    

    4.什么是冒泡排序?用代码如何实现?

      冒泡排序(Bubble Sort)算法是所有排序算法中最简单、最基础的一个,它的实现思路是通过相邻数据的交换达到排序的目的。

      冒泡排序的执行流程是:

    • 对数组中相邻的数据,依次进行比较;
    • 如果前面的数据大于后面的数据,则把前面的数据交换到后面。经过一轮比较之后,就能把数组中最大的数据排到数组的最后面了;
    • 再用同样的方法,把剩下的数据逐个进行比较排序,最后得到就是从小到大排序好的数据。

      冒泡排序算法代码实现,如下所示:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 冒泡排序调用
            int[] bubbleNums = {132, 110, 122, 90, 50};
            System.out.println("排序前:" + Arrays.toString(bubbleNums));
            bubbleSort(bubbleNums);
            System.out.println("排序后:" + Arrays.toString(bubbleNums));
        }
        /**
         * 冒泡排序
         */
        private static void bubbleSort(int[] nums) {
            int temp;
            for (int i = 1; i < nums.length; i++) {
                for (int j = 0; j < nums.length - i; j++) {
                    if (nums[j] > nums[j + 1]) {
                        temp = nums[j];
                        nums[j] = nums[j + 1];
                        nums[j + 1] = temp;
                    }
                }
                System.out.print("第" + i + "次排序:");
                System.out.println(Arrays.toString(nums));
            }
        }
    }
    

    执行结果如下:

    排序前:[132, 110, 122, 90, 50]1次排序:[110, 122, 90, 50, 132]2次排序:[110, 90, 50, 122, 132]3次排序:[90, 50, 110, 122, 132]4次排序:[50, 90, 110, 122, 132]
    
    排序后:[50, 90, 110, 122, 132]
    

    5.什么是选择排序?用代码如何实现?

      选择排序(Selection Sort)算法也是比较简单的排序算法,其实现思路是每一轮循环找到最小的值,依次排到数组的最前面,这样就实现了数组的有序排列。

      比如,下面是一组数据使用选择排序的执行流程:

    • 初始化数据:18, 1, 6, 27, 15
    • 第一次排序:1, 18, 6, 27, 15
    • 第二次排序:1, 6, 18, 27, 15
    • 第三次排序:1, 6, 15, 27, 18
    • 第四次排序:1, 6, 15, 18, 27

      选择排序算法代码实现,如下所示:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 选择排序调用
            int[] selectNums = {18, 1, 6, 27, 15};
            System.out.println("排序前:" + Arrays.toString(selectNums));
            selectSort(selectNums);
            System.out.println("排序后:" + Arrays.toString(selectNums));
        }
        /**
         * 选择排序
         */
        private static void selectSort(int[] nums) {
            int index;
            int temp;
            for (int i = 0; i < nums.length - 1; i++) {
                index = i;
                for (int j = i + 1; j < nums.length; j++) {
                    if (nums[j] < nums[index]) {
                        index = j;
                    }
                }
                if (index != i) {
                    temp = nums[i];
                    nums[i] = nums[index];
                    nums[index] = temp;
                }
                System.out.print("第" + i + "次排序:");
                System.out.println(Arrays.toString(nums));
            }
        }
    }
    

    执行结果如下:

    排序前:[18, 1, 6, 27, 15]0次排序:[1, 18, 6, 27, 15]1次排序:[1, 6, 18, 27, 15]2次排序:[1, 6, 15, 27, 18]3次排序:[1, 6, 15, 18, 27]
    
    排序后:[1, 6, 15, 18, 27]
    

    6.什么是插入排序?用代码如何实现?

      插入排序(Insertion Sort)算法是指依次把当前循环的元素,通过对比插入到合适位置的排序算法。 比如,下面是一组数据使用插入排序的执行流程:

    • 初始化数据:18, 1, 6, 27, 15
    • 第一次排序:1, 18, 6, 27, 15
    • 第二次排序:1, 6, 18, 27, 15
    • 第三次排序:1, 6, 18, 27, 15
    • 第四次排序:1, 6, 15, 18, 27

      插入排序算法代码实现,如下所示:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 插入排序调用
            int[] insertNums = {18, 1, 6, 27, 15};
            System.out.println("排序前:" + Arrays.toString(insertNums));
            insertSort(insertNums);
            System.out.println("排序后:" + Arrays.toString(insertNums));
        }
        /**
         * 插入排序
         */
        private static void insertSort(int[] nums) {
            int i, j, k;
            for (i = 1; i < nums.length; i++) {
                k = nums[i];
                j = i - 1;
                // 对 i 之前的数据,给当前元素找到合适的位置
                while (j >= 0 && k < nums[j]) {
                    nums[j + 1] = nums[j];
                    // j-- 继续往前寻找
                    j--;
                }
                nums[j + 1] = k;
                System.out.print("第" + i + "次排序:");
                System.out.println(Arrays.toString(nums));
            }
        }
    }
    

    执行结果如下:

    排序前:[18, 1, 6, 27, 15]1次排序:[1, 18, 6, 27, 15]2次排序:[1, 6, 18, 27, 15]3次排序:[1, 6, 18, 27, 15]4次排序:[1, 6, 15, 18, 27]
    
    排序后:[1, 6, 15, 18, 27]
    

    7.什么是快速排序?用代码如何实现?

      快速排序(Quick Sort)算法和冒泡排序算法类似,都是基于交换排序思想实现的,快速排序算法是对冒泡排序算法的改进,从而具有更高的执行效率。

      快速排序是通过多次比较和交换来实现排序的执行流程如下:

    • 首先设定一个分界值,通过该分界值把数组分为左右两个部分;
    • 将大于等于分界值的元素放到分界值的右边,将小于分界值的元素放到分界值的左边;
    • 然后对左右两边的数据进行独立的排序,在左边数据中取一个分界值,把小于分界值的元素放到分界值的左边,大于等于分界值的元素,放到数组的右边;右边的数据也执行同样的操作;
    • 重复上述操作,当左右各数据排序完成后,整个数组也就完成了排序。

      快速排序算法代码实现,如下所示:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 快速排序调用
            int[] quickNums = {18, 1, 6, 27, 15};
            System.out.println("排序前:" + Arrays.toString(quickNums));
            quickSort(quickNums, 0, quickNums.length - 1);
            System.out.println("排序后:" + Arrays.toString(quickNums));
        }
        /**
         * 快速排序
         */
        private static void quickSort(int[] nums, int left, int right) {
            int f, t;
            int ltemp = left;
            int rtemp = right;
            // 分界值
            f = nums[(left + right) / 2];
            while (ltemp < rtemp) {
                while (nums[ltemp] < f) {
                    ++ltemp;
                }
                while (nums[rtemp] > f) {
                    --rtemp;
                }
                if (ltemp <= rtemp) {
                    t = nums[ltemp];
                    nums[ltemp] = nums[rtemp];
                    nums[rtemp] = t;
                    --rtemp;
                    ++ltemp;
                }
            }
            if (ltemp == rtemp) {
                ltemp++;
            }
            if (left < rtemp) {
                // 递归调用
                quickSort(nums, left, ltemp - 1);
            }
            if (right > ltemp) {
                // 递归调用
                quickSort(nums, rtemp + 1, right);
            }
        }
    }
    

    执行结果如下:

    排序前:[18, 1, 6, 27, 15]
    
    排序后:[1, 6, 15, 18, 27]
    

    8.什么是堆排序?用代码如何实现?

      堆排序(Heap Sort)算法是利用堆结构和二叉树的一些特性来完成排序的。 堆结构是一种树结构,准确来说是一个完全二叉树。完全二叉树每个节点应满足以下条件:

    • 如果按照从小到大的顺序排序,要求非叶节点的数据要大于等于,其左、右子节点的数据;
    • 如果按照从大到小的顺序排序,要求非叶节点的数据小于等于,其左、右子节点的数据。

      可以看出,堆结构对左、右子节点的大小没有要求,只规定叶节点要和子节点(左、右)的数据满足大小关系。

      比如,下面是一组数据使用堆排序的执行流程:
    在这里插入图片描述
    堆排序算法代码实现,如下所示:

    public class Lesson7_4 {
        public static void main(String[] args) {
            // 堆排序调用
            int[] heapNums = {18, 1, 6, 27, 15};
            System.out.println("堆排序前:" + Arrays.toString(heapNums));
            heapSort(heapNums, heapNums.length);
            System.out.println("堆排序后:" + Arrays.toString(heapNums));
        }
        /**
         * 堆排序
         * @param nums 待排序数组
         * @param n    堆大小
         */
        private static void heapSort(int[] nums, int n) {
            int i, j, k, temp;
            // 将 nums[0,n-1] 建成大根堆
            for (i = n / 2 - 1; i >= 0; i--) {
                // 第 i 个节点,有右子树
                while (2 * i + 1 < n) {
                    j = 2 * i + 1;
                    if ((j + 1) < n) {
                        // 右左子树小于右子树,则需要比较右子树
                        if (nums[j] < nums[j + 1]) {
                            // 序号增加 1,指向右子树
                            j++;
                        }
                    }
                    if (nums[i] < nums[j]) {
                        // 交换数据
                        temp = nums[i];
                        nums[i] = nums[j];
                        nums[j] = temp;
                        // 堆被破坏,重新调整
                        i = j;
                    } else {
                        // 左右子节点均大,则堆未被破坏,不需要调整
                        break;
                    }
                }
            }
            for (i = n - 1; i > 0; i--) {
                // 与第 i 个记录交换
                temp = nums[0];
                nums[0] = nums[i];
                nums[i] = temp;
                k = 0;
                // 第 i 个节点有右子树
                while (2 * k + 1 < i) {
                    j = 2 * k + 1;
                    if ((j + 1) < i) {
                        // 右左子树小于右子树,则需要比较右子树
                        if (nums[j] < nums[j + 1]) {
                            // 序号增加 1,指向右子树
                            j++;
                        }
                    }
                    if (nums[k] < nums[j]) {
                        // 交换数据
                        temp = nums[k];
                        nums[k] = nums[j];
                        nums[j] = temp;
                        // 堆被破坏,重新调整
                        k = j;
                    } else {
                        // 左右子节点均大,则堆未被破坏,不需要调整
                        break;
                    }
                }
                // 输出每步排序结果
                System.out.print("第" + (n - i) + "次排序:");
                System.out.println(Arrays.toString(nums));
            }
        }
    }
    

    执行结果如下:

    堆排序前:[18, 1, 6, 27, 15]1次排序:[18, 15, 6, 1, 27]2次排序:[15, 1, 6, 18, 27]3次排序:[6, 1, 15, 18, 27]4次排序:[1, 6, 15, 18, 27]
    
    堆排序后:[1, 6, 15, 18, 27]
    
    展开全文
  • java常见算法面试题

    千次阅读 2019-05-15 10:22:45
    java常见算法面试题 Java的冒泡排序,快速排序,归并排序,计数排序,二分查找法 1.斐波那契数列 1.斐波那契数列又叫黄金分割和兔子数列 :1、1、2、3、5、8、13、21、34、…… 在数学上,斐波纳契数列以如下被以...

    java常见算法面试题

    Java的冒泡排序,快速排序,归并排序,计数排序,二分查找法

    1.斐波那契数列

    1.斐波那契数列又叫黄金分割和兔子数列
    :1、1、2、3、5、8、13、21、34、……
    在数学上,斐波纳契数列以如下被以递推的方法定义(规律总结):
    F(1)=1,
    F(2)=1,
    F(n)=F(n-1)+F(n-2)(n>=3,n∈N*)

    2.杨辉三角

    public class TriangleArray
    {
       public static void main(String[] args)
       {
          final int NMAX = 10; 
          // allocate triangular array
          int[][] odds = new int[NMAX + 1][];
          for (int n = 0; n <= NMAX; n++)
             odds[n] = new int[n + 1];  
          // fill triangular array
          for (int n = 0; n < odds.length; n++)
             for (int k = 0; k < odds[n].length; k++)
             {
                /*
                 * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
                 */
                int lotteryOdds = 1;
                for (int i = 1; i <= k; i++)
                   lotteryOdds = lotteryOdds * (n - i + 1) / i;
     
                odds[n][k] = lotteryOdds;
             }
     
          // print triangular array
          for (int[] row : odds)
          {
             for (int odd : row)
                System.out.printf("%4d", odd);
             System.out.println();
          }
       }
    }
    
    展开全文
  • Java 数据结构 算法 Linux 题目 网络通信 tcp/ip 协议 各种小问题
  • Java算法题的常用API一览,适用于准备求职时刷leetcode、lintcode等算法题,或面试白板编程。
  • JAVA经典算法面试 10 及答案 程序 1 目古典 有一 兔子从出生后第 3 个月起每个月都生一 兔子小兔子 到第四个月后每个月又生一 兔子 假如兔子都不死 每个月的兔子 数 多少 1. 程序分析 兔子的 律 数列 1,1,2,3,5,8,...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • JAVA经典面试题附答案(持续更新版)

    万次阅读 多人点赞 2019-01-18 01:31:16
    JAVA基础 JAVA中的几种基本类型,各占用多少字节? 下图单位是bit,非字节 1B=8bit String能被继承吗?为什么? 不可以,因为String类有final修饰符,而final修饰的类是不能被继承的,实现细节不允许改变。平常我们...
  • 华为招聘java工程师面试题附带面试笔记(以及如何写好java简历等) 如何写好java面试简历: 1、看oa总结 2、尽量把熟悉的放在前面 把开发的阶段描述一下: 前期准备,需求分析,2个月时间, 总体设计2,3个星期, ...
  • 本文转载自:Java后端开发算法基础面试题分享,你离大厂也许就差这份面试题! 一、算法基础 1. 重建二叉树 题目: 输入一棵二叉树前序遍历和中序遍历的结果,请重建该二叉树。 注意: 二叉树中每个节点的值都互不...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • JAVA经典算法面试40及答案

    万次阅读 多人点赞 2018-06-23 23:36:12
    现在的招聘他们有时会给你出一套面试题或者智力测试题,也有的直接让你上机操作,写一段程序。算法的计算不乏出现,基于这个原因我自己搜集了一些算法上的题型。希望对于大家有所帮助。 【程序1】题目:古典问题:...
  • Java算法面试题

    万次阅读 热门讨论 2010-12-02 09:19:00
    下面是某些企业常见的算法面试试题,现总结如下,仅供学员参考与学习。1.比较两个字符串如果不等返回True?答案: Java代码 package com.test.kaoshi; public class StringDemo { private static String a ...
  • 主要介绍了Java常见数据结构面试题,带有答案及解释,希望对广大的程序爱好者有所帮助,同时祝大家有一个好成绩,需要的朋友可以参考下。
  • 面试题包含了不同技术层面的面试问题,同时也能对一些没有面试开发经验的小白给予不可估量的包装, 让你的薪水绝对翻倍, 本人亲试有效.Java面试题84集、java面试专属及面试必问课程,所有的面试题有视屏讲解, 解答方案....
  • 2021年最新整合的数据结构与算法面试题,一共100多页的文档,需要的小伙伴可以拿走,里面有按编程语言区分需要学习的算法知识点,很详细很全面。
  • 精心整理的面试题,主要涵盖Java基础,Mysql数据库,数据结构与算法,集合,多线程,Spring,JavaEE以及计算机基础知识等。
  • Java算法面试题(008) 字符串反转

    千次阅读 2017-12-19 16:13:30
    这是一个Java面试中被经常问及的问题,也有很多种实现方式。我在这里一一列出,如果你有更好的解法,也可留言。 解法一:首尾字符调换顺序 由于String对象是只读类型,不能对其进行直接操作,因此需要转换成...
  • 企业面试题 - 算法与编程 此文档包含了算法算法详解
  • 而根据统计,以下这18个问题是面试中最容易遇到的,本文给出了一些基本答案,供算法方向工程师或对此感兴趣的程序员参考。 1)请简单解释算法是什么? 算法是一个定义良好的计算过程,它将一些值作为输入并产生...
  • Java题解】小米算法面试题

    千次阅读 2019-06-07 10:52:13
    小米算法面试题 对于无序数组a,求a[i]-a[j]的最大值,其中i<j. 解决方法 时间复杂度O(n) 1. 首先我们通过一个指针k,从数组nums的第二位至倒数第二位分割此数组。 2. 然后对每次分割开的两个数组,前半段求...
  • 2021最新版数据结构与算法面试题手册,搜集了JAVA、GO等主流编程语言面试常见问题。
  • 12、java算法面试题.pdf。13、程序员面试宝典.pdf。14、代码与编程题.pdf。15、各大公司面试题.pdf。16、数据库设计规范V1.00.pdf。17、线程编程方面.pdf。18、应聘Java笔试时可能出现问题及其答案.pdf。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,473
精华内容 52,189
关键字:

java算法面试题

java 订阅