精华内容
下载资源
问答
  • 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常见算法示例

    千次阅读 2015-09-24 00:44:17
    算法: 排序算法的基本算法(三种)冒泡:(每轮排序获取到一个最大值,所以每轮减去排序的次数,-1是防止越界) 每相邻的两个数据比较,如果第一个比第二个大,就交换public staticvoid bubbleSort(int []datas){ ...

    算法:    排序算法的基本算法(三种)

    冒泡:(每轮排序获取到一个最大值,所以每轮减去排序的次数,-1是防止越界)

        每相邻的两个数据比较,如果第一个比第二个大,就交换


    public staticvoid bubbleSort(int []datas){
           for (int i = 0; i <datas.length-1;i++) {//排序的次数
              for (int j = 0; j<datas.length-i-1; j++) {//每轮的比较
                 if(datas[j]>datas[j+1]){
                     int temp=datas[j];
                     datas[j]=datas[j+1];
                     datas[j+1]=temp;
                 }
              }
           }
        }


    选择 :(中)

    遍历所有数据找到最小数据的下标,遍历到的数据和最小下标数交换


    publicstaticvoid selectSort(int[] datas) {
        for (int i = 0; i < datas.length - 1; i++) {
           int min = i;//内循环获取最小数的下标,第一次默认最小的i
           for (int j = i + 1; j < datas.length; j++) {//忽略比较过的值
              if (datas[min] > datas[j]) {
                  min= j;  
               }
           }//将最小数据和遍历到的数交换位置
           int temp = datas[i];
           datas[i] = datas[min];
            datas[min]= temp;
        }
    }

    插入:(高)

    从第二个数据开始依次向前比较.如果发现比自己大,该大的往后瞬移,将大的数插入到他本身的后面;

    publicstaticvoid insertSort(int datas[]) {
      int i=0;//第二个数开始遍历
      int j=0;
        for (i = 1; i < datas.length; i++) {
           int temp = datas[i];//向前比较
           for (j = i - 1; j >= 0; j--) {
              if (datas[j] > temp) {//比较到大的数据就后移
                  datas[j+ 1] = datas[j];
               }else { 
                 break;
              }                                                                            
           }
           //判断 j == -1或者 就是第一个小于等于temp数据的位置
           datas[j + 1] = temp;
        }
    }

    快速排序算法:


    publicstaticvoid quickSort(int datas[], int start,int end) {
           if (start >= end) {
              return;
           }else {
              int middle =findMiddle(datas, start,end);
              quickSort(datas, start, middle- 1);
              quickSort(datas, middle + 1,end);
           }
        }
        privatestaticint findMiddle(int datas[],int start,int end) {
           int temp = datas[end];//参照物
           int left = start - 1;
           int right = end;
           while (true) {
              // 1.从左边依次找数据,找到第一个比参照大的数据
              while (++left < end && datas[left]<= temp);   
              if (left == end) {
                 //参照物是最大值
                 break;
              }
              // 2.从右边依次找数据,找到第一个比参数小的数据
              while (--right >= start && datas[right]>= temp);
              // 3,比较是否出现交叉(left和 right)
              if (left < right) {
                 // 4,如果没有交叉,交换左右位置的数据
                 int d = datas[left];
                 datas[left] = datas[right];
                 datas[right] = d;
              }else {
                 // 5,如果出现交叉,交换左指针和参照物的值,结束
                 int d = datas[left];
                 datas[left] = datas[end];
                 datas[end] = d;
                 break;
              }
           }
           return left;
        }

    二分查找:


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

    汉诺塔问题:


    public static void move(int panNum, char a,char b,char c) {
           if (panNum == 1) {
              System.out.println("盘:" + panNum +" 从 " + a +"柱移动 " + c +"柱");}else {
              move(panNum - 1, a, c, b);
              System.out.println("盘:" + panNum +" 从 " + a +"柱移动 " + c +"柱");
              move(panNum - 1, b, a, c);}}
    递归:publicstaticint sum(int number) {
           if (number < 1) {
              thrownew RuntimeException("number must > 0"); }
           if (number == 1) {return 1;}else {
              return number +sum(number - 1);
           }}


    展开全文
  • Java常见算法之二分法查找算法详解

    千次阅读 2018-10-19 21:55:43
    目录 一、简介 二、查找思路 三、算法实现 四、总结 一、简介 二分法查找,是在已经排好序的序列中,定义一个起始位置start(即序列第一个元素)和一个终止位置end(即序列最后一个元素),通过mid=(start+end)/2计算出...

    目录

    一、简介

    二、查找思路

    三、算法实现

    四、总结


    一、简介

    二分法查找,是在已经排好序的序列中,定义一个起始位置start(即序列第一个元素)和一个终止位置end(即序列最后一个元素),通过mid=(start+end)/2计算出中间位置,通过待查找元素与mid中间位置的元素进行比较,如果待查找元素比中间位置mid对应的值小,那么将end = mid -1(即将end结束位置移动到mid中间左边一个位置),如果比中间对应的值大,那么将start = mid + 1 (即将start的位置移动到mid右边一个位置),一直循环查找,直到start > end,证明没找到对应的元素,停止循环。

    二、查找思路

    【a】待查找有序数组序列:1, 2, 3, 4, 5, 6, 7  

    起始: 定义start = 0 , end = 6, mid = (start + end ) / 2 = (0 + 6) / 2 = 3,arr[mid] = arr[3] = 4

    【b】假设需要查找"2", 因为2 < arr[mid] = arr[3] = 4; 所以需要将end移动到mid左边一个位置,即end = mid - 1 = 3 - 1 = 2,

    此时重新计算mid = (start +end ) / 2 =  (0 + 2) / 2 = 1; arr[mid] = arr[1] = 2 ,继续将2与arr[mid] = arr[1] = 2进行比较,发现相等,成功找到数字"2"所在的位置。

    【c】假设需要查找"7",因为 7 > arr[mid] = arr[3] = 4,所以需要将start移动到mid右边一个位置,即start = mid + 1 = 4,此时重新计算mid = (start +end) / 2 = (4+ 6)/2 = 5, arr[mid] = arr[5] = 6, 因为7>arr[mid] = arr[5] = 6,所以还是需要将start移动到mid右边一个位置,即start = mid + 1 = 5 + 1 = 6,  此时重新计算mid =  (start +end) / 2 = (6 + 6) / 2 = 6.arr[6] = 7, 此时arr[mid] = arr[6] = 7,刚好等于待查找数字7,说明成功找到数字"7"所在的位置.

     【d】假设查找"0", 因为 0 <  arr[mid] = arr[3] = 4, 所以需要将end移动到mid左边一个位置,即end = mid - 1 = 3 - 1 = 2,此时重新计算mid = (start +end) / 2 = (0 + 2) / 2 = 1,arr[mid] = arr[1] = 2, 因为0 < arr[mid] = arr[1] = 2,所以需要将end移动到mid左边一个位置,即end = mid - 1 = 1 - 1 =  0, 此时mid = (start +end) / 2 = (0 + 0) / 2 = 0,arr[mid] = arr[0] = 1,因为0 < arr[mid] = arr[0] = 1,所以需要将end移动到mid左边一个位置,即end = mid - 1 = 0 - 1 = -1 ,因为此时start = 0, end = -1,start >end,即start 已经大于end结束位置,说明没有找到相应的元素0。

    三、算法实现

    public class BinarySearchUtils {
    
        /**
         * 根据指定值查找在数组中的位置
         *
         * @param arr   待查找有序数组
         * @param value 指定值
         * @return 返回值在数组中对应的下标位置
         */
        public static int binarySearch(int[] arr, int value) {
            //起始位置
            int start = 0;
            //结束位置
            int end = arr.length - 1;
    
            while (true) {
                //计算中间位置下标
                int mid = (start + end) / 2;
                //中间值
                int midValue = arr[mid];
    
                if (value == midValue) {
                    return mid;
                } else {
                    //待查找数值比中间值小,需要将end = mid - 1
                    if (midValue > value) {
                        end = mid - 1;
                    } else {
                        //待查找数值比中间值大,需要将start = mid + 1
                        start = mid + 1;
                    }
                }
    
                if (start > end) {
                    //start > end,说明未找到相应的元素,返回-1
                    return -1;
                }
            }
        }
    
    }
    

    测试:

    public class TestBinarySearchUtils {
    
        public static void main(String[] args) {
            int[] arr = {1, 2, 3, 4, 5, 6, 7};
            int index1 = BinarySearchUtils.binarySearch(arr, 2);
            System.out.println(index1);
            int index2 = BinarySearchUtils.binarySearch(arr, 7);
            System.out.println(index2);
            int index3 = BinarySearchUtils.binarySearch(arr, 0);
            System.out.println(index3);
        }
    
    }
    

    测试结果:

    四、总结

    本文是对二分查找算法的一些总结以及思路,仅供大家参考学习,一起学习一起进步。

    展开全文
  • java面试常见算法总结

    千次阅读 2019-03-05 18:23:27
    java面试常见算法总结 一个int[]数组 如何打印出重复次数前5的元素及重复次数 /** * 排序 * @author v_liuwen * @date 2019/3/5 */ public class SortDemo { public static void main(String[] args) { int[]...

    java面试常见算法总结

    1、 一个int[]数组 如何打印出重复次数前5的元素及重复次数

    /**
     * 排序
     * @author v_liuwen
     * @date 2019/3/5
     */
    public class SortDemo {
    
        public static void main(String[] args) {
            int[] nums = new int[]{1,3,7,4,9,2,3,4,3,4,5,3,6,3,7,5,4,5,6,7,9,4};
            sort(nums);
        }
    
    
        public static void sort(int[] nums){
            Map<Integer,Integer> map = new HashMap<>();
            Arrays.stream(nums).forEach(num ->{
                if(map.get(num)==null){
                    map.put(num,1);
                }else {
                    map.put(num,map.get(num)+1);
                }
            });
    
            map.forEach((k,v) ->{
                System.out.println("key:"+k+"  value:"+v);
            });
    
    
            //按键排序
    //        System.out.println("---------------按键排序--------------------");
    //        Map<Integer,Integer> resultKey = map.entrySet()
    //                .stream().sorted(Map.Entry.comparingByKey())
    //                .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue,(oldValue,newValue) ->oldValue,LinkedHashMap::new));
    //        System.out.println(resultKey);
            //按值排序
            System.out.println("---------------按值排序--------------------");
            Map<Integer,Integer> resultValue = map.entrySet()
                    .stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                    .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue,(oldValue,newValue) ->oldValue,LinkedHashMap::new));
            Integer count = 5;
            for(Integer key:resultValue.keySet()){
                if(count<1){
                    break;
                }
                System.out.println("key:"+key+"   value:"+resultValue.get(key));
                count--;
            }
        }
    }
    
    

    打印结果

    key:1  value:1
    key:2  value:1
    key:3  value:5
    key:4  value:5
    key:5  value:3
    key:6  value:2
    key:7  value:3
    key:9  value:2
    ---------------按值排序--------------------
    key:3   value:5
    key:4   value:5
    key:5   value:3
    key:7   value:3
    key:6   value:2
    

    持续更新中。。。

    展开全文
  • java算法大全源码包 java算法大全,有近100多种常见算法的源代码,是学习JAVA算法的难得资料。
  • 常见几种java排序算法

    万次阅读 多人点赞 2019-02-18 18:08:16
    层层细分 接下来,我们通过示图来展示上述分区算法思路的过程: public class QuickSort { public static void sort(int[] arr,int begin,int end) { //先定义两个参数接收排序起始值和结束值 int a = begin;...
  • java算法大全_java经典算法_算法面试题大全含答案

    万次阅读 多人点赞 2019-05-16 09:44:18
    5、JVM的常见垃圾回收算法 6、《java算法大全》第一期 7、《java算法大全》第三期 8、《java算法大全》第二期 9、《java算法大全》第五期 10、《java算法大全》第四期 11、《java经典算法》之...
  • Java栈、队列、链表常见算法浅析

    千次阅读 2019-01-19 11:01:46
    数据是基础,算法是灵魂...这篇文章我们只谈算法的具体实现思考过程,并没有相关代码实现,代码的实现过程请参见我的另外一篇文章:Java数据结构与算法中级篇之栈、队列、链表 源码下载地址:https://download.csdn...
  • JAVA算法:棋盘走法、方格走法常见算法问题汇总 问题一:方格从左上角走到右下角的走法数 给定一个m*n的方格,机器人只能向右走或向下走,求机器人从方格左上角走到右下角共有多少种走法。 对于2*2的方格有两种走...
  • 这篇文章我们只谈算法的具体实现思考过程,并没有相关代码实现,代码的实现过程请参见我的另外一篇文章:Java数据结构与算法初级篇之数组、集合和散列表 源码下载地址:https://download.cs...
  • JAVA近百种算法大全

    千次下载 热门讨论 2013-05-29 10:25:35
    最近找到的JAVA近百种算法大全 分享一下 java算法大全,有近100多种常见算法的源代码,是学习JAVA算法的难得资料,需要的童鞋来下载吧!
  • Java基础算法详解

    万次阅读 多人点赞 2018-06-20 07:56:13
    因为其实现代码较短,应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗,只要熟悉了思想,灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序,并且经常有面试官要求现场写出...
  • 1.最大子序列和问题的三种算法:O(N^3),O(N^2),O(NlogN) 算法1: public static int Method1(int[] arr)//O(N^3) { int max=0; for(int i=0;i;i++){//子列起始坐标 for(int j=i;j;j++){//子列终坐标 ...
  • 随笔- 385 文章- 0 评论- 14  本文已搬家至【算法实作】各种冒泡算法实现
  • Java常见排序算法-16-选择排序

    千次阅读 2018-04-16 10:35:10
    本篇来学习选择排序,在学习之前,如果你还不能用笔在白纸上写出冒泡排序算法,建议你再写一遍,然后开始本篇的学习。1.选择排序的原理 选择排序的核心思想就是,从一个索引位置上的元素,分别和剩余后面索引对应...
  • Java常见数据结构与算法

    千次阅读 2018-09-16 16:55:00
    AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1,所以它也被称为高度平衡树,n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O(log n)。...
  • 本文已搬家至【算法实现】插入排序算法
  • java6支持了很多的加密算法,各大机构提供了很多的实现。但是大部分收费。 1、这里Bouncy Castle(http://www.bouncycastle.org)提供了一系列的算法实现,可以跻身于JCE的框架下,以提供者的方式纳入java安全实现的...
  • 常见算法-将二叉搜索树转化为排序的双向链表(java版) 本篇博文主要在参考下面这篇总结二叉树常见算法题的博文基础上修改而成,这篇文章总结得非常棒,建议大家都读读-[面试大总结之二:Java搞定面试中的二叉树...
  • java算法大全(含源码包)

    千次下载 热门讨论 2011-08-28 16:19:38
    java算法大全,有近100多种常见算法的源代码,是学习JAVA算法的难得资料。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 213,207
精华内容 85,282
关键字:

java常见算法

java 订阅