当前位置:首页 > Java >
《Java常用算法手册(第3版)》电子书封面

Java常用算法手册(第3版)

  • 发布时间:2019年04月12日 15:22:25
  • 作者:宋娟
  • 大小:171.5 MB
  • 类别:Java算法电子书
  • 格式:PDF
  • 版本:超清版
  • 评分:8.5

    Java常用算法手册(第3版) PDF 超清版

      给大家带来的一篇关于Java算法相关的电子书资源,介绍了关于Java、算法方面的内容,本书是由中国铁道出版社出版,格式为PDF,资源大小171.5 MB,宋娟编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.3分

      Tags:java 算法 

      内容介绍

      晚上买的书,第二天早上就到了。我们学校发的教材是清华大学出版社出版的java程序设计教程,从数据结构到算法再到面向结构与多线程。而这本书侧重算法和一些实际应用,实用性强而且对我学习算法很有帮助。

      初步看了一下,感觉不错,不过需要较多的java知识才能吃透,待把java基础知识学完再学习它。

      有例子和问题思考概念与模型,而不是相反。理论文字一大坨,其实代码就那几行。 数据结构――逻辑结构(建模)存储结构(数组和链表)数据运算(插入,删除,更新,排序) 读国外翻译版总会遇到翻译过于书面表达,国内的简化版多了些口语形式,增强了理解。

      程序应该说明应用范围的,比如排序算法能支持多少数据排序;并且程序质量很是一般;再就是重复、罗列代码

      编辑推荐

      算法是一切程序设计的基础和灵魂,更是一位程序员编程水平高低的集中体现。
      涵盖广泛:精炼的理论讲述嵌入经典算法示例,学习查询兼而有之。
      阐述到位:算法思想、算法实现和经典面试题合理搭配,相辅相成。
      实例完善:分析精准,注释精确,保证每段代码皆可通过编译执行。
      超过600分钟讲解视频和案例源代码倾囊相送。
      附赠5本电子书教程铺就Java程序员成长之路。 

      内容节选

      Java常用8大排序算法

      这篇文章主要介绍了Java如何实现八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,分享给大家一起学习。

      分类
      1)插入排序(直接插入排序、希尔排序)
      2)交换排序(冒泡排序、快速排序)
      3)选择排序(直接选择排序、堆排序)
      4)归并排序
      5)分配排序(基数排序)

      所需辅助空间最多:归并排序
      所需辅助空间最少:堆排序
      平均速度最快:快速排序

      不稳定:快速排序,希尔排序,堆排序。

      先来看看8种排序之间的关系:

      1.直接插入排序

      (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排

      好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数

      也是排好顺序的。如此反复循环,直到全部排好顺序。

      (2)实例

      (3)用java实现

      package com.njue; 
       
      publicclass insertSort { 
       
      public insertSort(){ 
       inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
       int temp=0; 
       for(int i=1;i<a.length;i++){ 
       int j=i-1; 
       temp=a[i]; 
       for(;j>=0&&temp<a[j];j--){ 
        a[j+1]=a[j]; //将大于temp的值整体后移一个单位 
       } 
       a[j+1]=temp; 
       } 
       
       for(int i=0;i<a.length;i++){ 
       System.out.println(a[i]); 
       } 
      }
      

       

      2. 希尔排序(最小增量排序)

      (1)基本思想:算法先将要排序的一组数按某个增量d(n/2,n为要排序数的个数)分成若干组,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。当增量减到1时,进行直接插入排序后,排序完成。

      (2)实例:

      (3)用java实现

      publicclass shellSort { 
       
      publicshellSort(){ 
       
       int a[]={1,54,6,3,78,34,12,45,56,100}; 
       double d1=a.length; 
       int temp=0; 
       
       while(true){ 
       d1= Math.ceil(d1/2); 
       int d=(int) d1; 
       for(int x=0;x<d;x++){ 
       
        for(int i=x+d;i<a.length;i+=d){ 
        int j=i-d; 
        temp=a[i]; 
        for(;j>=0&&temp<a[j];j-=d){ 
         a[j+d]=a[j]; 
        } 
        a[j+d]=temp; 
        } 
       } 
       
       if(d==1){ 
        break; 
       } 
       
       for(int i=0;i<a.length;i++){ 
       System.out.println(a[i]); 
       } 
      }
      

       

      3.简单选择排序

      (1)基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;

      然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。

      (2)实例:

      (3)用java实现

      public class selectSort { 
       
       public selectSort(){ 
       int a[]={1,54,6,3,78,34,12,45}; 
       int position=0; 
       for(int i=0;i<a.length;i++){ 
        int j=i+1; 
        position=i; 
        int temp=a[i]; 
        for(;j<a.length;j++){ 
        if(a[j]<temp){ 
         temp=a[j]; 
         position=j; 
        } 
        } 
        a[position]=a[i]; 
        a[i]=temp; 
       } 
       
       for(int i=0;i<a.length;i++) 
        System.out.println(a[i]); 
       } 
      }
      

       

      4.堆排序

      (1)基本思想:堆排序是一种树形选择排序,是对直接选择排序的有效改进。

      堆的定义如下:具有n个元素的序列(h1,h2,…,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1)(i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项(大顶堆)。完全二叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。

      (2)实例:

      初始序列:46,79,56,38,40,84

      建堆:

      交换,从堆中踢出最大数

      剩余结点再建堆,再交换踢出最大数

      依次类推:最后堆中剩余的最后两个结点交换,踢出一个,排序完成。

      (3)用java实现

      import java.util.Arrays; 
       
      publicclass HeapSort { 
       inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
       public HeapSort(){ 
       heapSort(a); 
       } 
       
       public void heapSort(int[] a){ 
       System.out.println("开始排序"); 
       int arrayLength=a.length; 
       //循环建堆 
       for(int i=0;i<arrayLength-1;i++){ 
        //建堆 
        buildMaxHeap(a,arrayLength-1-i); 
        //交换堆顶和最后一个元素 
        swap(a,0,arrayLength-1-i); 
        System.out.println(Arrays.toString(a)); 
       } 
       } 
       
       
       
       private void swap(int[] data, int i, int j) { 
       // TODO Auto-generated method stub 
       int tmp=data[i]; 
       data[i]=data[j]; 
       data[j]=tmp; 
       } 
       
       //对data数组从0到lastIndex建大顶堆 
       privatevoid buildMaxHeap(int[] data, int lastIndex) { 
       // TODO Auto-generated method stub 
       //从lastIndex处节点(最后一个节点)的父节点开始 
       
       for(int i=(lastIndex-1)/2;i>=0;i--){ 
        //k保存正在判断的节点 
        int k=i; 
        //如果当前k节点的子节点存在 
        while(k*2+1<=lastIndex){ 
        //k节点的左子节点的索引 
        int biggerIndex=2*k+1; 
        //如果biggerIndex小于lastIndex,即biggerIndex+1代表的k节点的右子节点存在 
        if(biggerIndex<lastIndex){ 
         //若果右子节点的值较大 
         if(data[biggerIndex]<data[biggerIndex+1]){ 
         //biggerIndex总是记录较大子节点的索引 
         biggerIndex++; 
         } 
        } 
       
        //如果k节点的值小于其较大的子节点的值 
        if(data[k]<data[biggerIndex]){ 
         //交换他们 
         swap(data,k,biggerIndex); 
         //将biggerIndex赋予k,开始while循环的下一次循环,重新保证k节点的值大于其左右子节点的值 
         k=biggerIndex; 
        }else{ 
         break; 
        } 
        } 
       } 
       } 
      }

       

      5.冒泡排序

      (1)基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

      (2)实例:

      (3)用java实现

      public class bubbleSort { 
       
      publicbubbleSort(){ 
       inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
       int temp=0; 
       for(int i=0;i<a.length-1;i++){ 
       for(int j=0;j<a.length-1-i;j++){ 
        if(a[j]>a[j+1]){ 
        temp=a[j]; 
        a[j]=a[j+1]; 
        a[j+1]=temp; 
        } 
       } 
       } 
       
       for(int i=0;i<a.length;i++){ 
       System.out.println(a[i]); 
       } 
      }
      

       

      6.快速排序

      (1)基本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

      (2)实例:

      (3)用java实现

      publicclass quickSort { 
       
       inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
      publicquickSort(){ 
       quick(a); 
       for(int i=0;i<a.length;i++){ 
       System.out.println(a[i]); 
       } 
      } 
      publicint getMiddle(int[] list, int low, int high) { 
        int tmp =list[low]; //数组的第一个作为中轴 
        while (low < high){ 
        while (low < high&& list[high] >= tmp) { 
         high--; 
        } 
       
        list[low] =list[high]; //比中轴小的记录移到低端 
        while (low < high&& list[low] <= tmp) { 
         low++; 
        } 
       
        list[high] =list[low]; //比中轴大的记录移到高端 
        } 
        list[low] = tmp;  //中轴记录到尾 
        return low;   //返回中轴的位置 
      } 
       
      publicvoid _quickSort(int[] list, int low, int high) { 
        if (low < high){ 
        int middle =getMiddle(list, low, high); //将list数组进行一分为二 
        _quickSort(list, low, middle - 1); //对低字表进行递归排序 
        _quickSort(list,middle + 1, high); //对高字表进行递归排序 
        } 
      } 
       
      publicvoid quick(int[] a2) { 
        if (a2.length > 0) { //查看数组是否为空 
        _quickSort(a2,0, a2.length - 1); 
        } 
      } 
      }
      

       

      7、归并排序

      (1)基本排序:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

      (2)实例:

      (3)用java实现

      import java.util.Arrays; 
       
      publicclass mergingSort { 
       
      inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
       
      publicmergingSort(){ 
       sort(a,0,a.length-1); 
       for(int i=0;i<a.length;i++) 
       System.out.println(a[i]); 
      } 
       
      publicvoid sort(int[] data, int left, int right) { 
       // TODO Auto-generatedmethod stub 
       if(left<right){ 
       //找出中间索引 
       int center=(left+right)/2; 
       //对左边数组进行递归 
       sort(data,left,center); 
       //对右边数组进行递归 
       sort(data,center+1,right); 
       //合并 
       merge(data,left,center,right); 
       } 
       
      } 
       
      publicvoid merge(int[] data, int left, int center, int right) { 
       // TODO Auto-generatedmethod stub 
       int [] tmpArr=newint[data.length]; 
       int mid=center+1; 
       //third记录中间数组的索引 
       int third=left; 
       int tmp=left; 
       while(left<=center&&mid<=right){ 
       //从两个数组中取出最小的放入中间数组 
       if(data[left]<=data[mid]){ 
        tmpArr[third++]=data[left++]; 
       }else{ 
        tmpArr[third++]=data[mid++]; 
       } 
       
       } 
       
       //剩余部分依次放入中间数组 
       while(mid<=right){ 
       tmpArr[third++]=data[mid++]; 
       } 
       
       while(left<=center){ 
       tmpArr[third++]=data[left++]; 
       } 
       
       //将中间数组中的内容复制回原数组 
       while(tmp<=right){ 
       data[tmp]=tmpArr[tmp++]; 
       } 
       System.out.println(Arrays.toString(data)); 
      } 
      }
      

       

      8、基数排序

      (1)基本思想:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

      (2)实例:

      (3)用java实现

      import java.util.ArrayList; 
      import java.util.List; 
       
      public class radixSort { 
       inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51}; 
       public radixSort(){ 
       sort(a); 
       for(inti=0;i<a.length;i++){ 
        System.out.println(a[i]); 
       } 
       } 
       public void sort(int[] array){ 
       //首先确定排序的趟数; 
       int max=array[0]; 
       for(inti=1;i<array.length;i++){ 
        if(array[i]>max){ 
        max=array[i]; 
        } 
       } 
       int time=0; 
       //判断位数; 
       while(max>0){ 
        max/=10; 
        time++; 
       } 
       
       //建立10个队列; 
       List<ArrayList> queue=newArrayList<ArrayList>(); 
       for(int i=0;i<10;i++){ 
        ArrayList<Integer>queue1=new ArrayList<Integer>(); 
        queue.add(queue1); 
       } 
       
       //进行time次分配和收集; 
       for(int i=0;i<time;i++){ 
        //分配数组元素; 
        for(intj=0;j<array.length;j++){ 
        //得到数字的第time+1位数; 
         int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i); 
         ArrayList<Integer>queue2=queue.get(x); 
         queue2.add(array[j]); 
         queue.set(x, queue2); 
        } 
        int count=0;//元素计数器; 
        //收集队列元素; 
        for(int k=0;k<10;k++){ 
        while(queue.get(k).size()>0){ 
         ArrayList<Integer>queue3=queue.get(k); 
         array[count]=queue3.get(0); 
         queue3.remove(0); 
         count++; 
        } 
        } 
       }  
       } 
      }
      
      

      以上就是本文的全部内容,希望对大家的学习有所帮助。

      内容简介

      本书分三篇,共14章,分别介绍了算法基础、算法应用和算法面试题。首先介绍了算法概述,然后重点分析了数据结构和基本算法思想;接着详细讲解了算法在排序、查找、数学计算、数论、历史趣题、游戏等领域中的应用;后梳理和精选了一些经典的算法面试题,供读者开拓思维之用。

      目录

      • 第1章 算法和实现算法的Java语法
      • 1.1 建立算法初步概念 1
      • 1.1.1 什么是算法 1
      • 1.1.2 算法的发展历史 3
      • 1.1.3 算法的分类 3
      • 1.2 算法相关概念的区别 3
      • 1.2.1 算法与公式的关系 4
      • 1.2.2 算法与程序的关系 4
      • 1.2.3 算法与数据结构的关系 4
      • 1.3 算法的表示 4
      • 1.3.1 自然语言表示 5
      • 1.3.2 流程图表示 5
      • 1.3.3 N-S图表示 6
      • 1.3.4 伪代码表示 7
      • 1.4 算法的性能评价 7
      • 1.4.1 时间复杂度 8
      • 1.4.2 空间复杂度 8
      • 1.5 一个算法实例 8
      • 1.5.1 查找数字 8
      • 1.5.2 创建项目 10
      • 1.5.3 编译执行 11
      • 1.6 Java程序的基本结构 13
      • 1.6.1 类是一个基本单元 13
      • 1.6.2 main方法 14
      • 1.6.3 自定义方法 14
      • 1.6.4 System.out.println的使用 15
      • 1.6.5 一个简单而完整的程序 15
      • 1.7 顺序结构 16
      • 1.8 分支结构 17
      • 1.8.1 if...else分支结构 17
      • 1.8.2 if...else嵌套 18
      • 1.8.3 switch语句 19
      • 1.8.4 编程实例 20
      • 1.9 循环结构 21
      • 1.9.1 while循环 22
      • 1.9.2 do…while循环 22
      • 1.9.3 for循环 23
      • 1.9.4 编程实例 23
      • 1.10 跳转结构 27
      • 1.10.1 break 27
      • 1.10.2 continue 27
      • 1.10.3 编程实例 27
      • 1.11 小结 29
      • 第2章 数据结构
      • 2.1 数据结构概述 30
      • 2.1.1 什么是数据结构 30
      • 2.1.2 数据结构中的基本概念 31
      • 2.1.3 数据结构的内容 31
      • 2.1.4 数据结构的分类 33
      • 2.1.5 数据结构的几种存储方式 33
      • 2.1.6 数据类型 34
      • 2.1.7 常用的数据结构 35
      • 2.1.8 选择合适的数据结构解决实际问题 36
      • 2.2 线性表 36
      • 2.2.1 什么是线性表 36
      • 2.2.2 线性表的基本运算 37
      • 2.3 顺序表结构 37
      • 2.3.1 准备数据 38
      • 2.3.2 初始化顺序表 38
      • 2.3.3 计算顺序表长度 38
      • 2.3.4 插入结点 39
      • 2.3.5 追加结点 39
      • 2.3.6 删除结点 40
      • 2.3.7 查找结点 40
      • 2.3.8 显示所有结点 41
      • 2.3.9 顺序表操作实例 41
      • 2.4 链表结构 45
      • 2.4.1 什么是链表结构 45
      • 2.4.2 准备数据 46
      • 2.4.3 追加结点 46
      • 2.4.4 插入头结点 47
      • 2.4.5 查找结点 48
      • 2.4.6 插入结点 49
      • 2.4.7 删除结点 50
      • 2.4.8 计算链表长度 51
      • 2.4.9 显示所有结点 51
      • 2.4.10 链表操作实例 51
      • 2.5 栈结构 56
      • 2.5.1 什么是栈结构 56
      • 2.5.2 准备数据 57
      • 2.5.3 初始化栈结构 57
      • 2.5.4 判断空栈 58
      • 2.5.5 判断满栈 58
      • 2.5.6 清空栈 58
      • 2.5.7 释放空间 59
      • 2.5.8 入栈 59
      • 2.5.9 出栈 59
      • 2.5.10 读结点数据 60
      • 2.5.11 栈结构操作实例 60
      • 2.6 队列结构 63
      • 2.6.1 什么是队列结构 63
      • 2.6.2 准备数据 64
      • 2.6.3 初始化队列结构 64
      • 2.6.4 判断空队列 65
      • 2.6.5 判断满队列 65
      • 2.6.6 清空队列 65
      • 2.6.7 释放空间 66
      • 2.6.8 入队列 66
      • 2.6.9 出队列 66
      • 2.6.10 读结点数据 67
      • 2.6.11 计算队列长度 67
      • 2.6.12 队列结构操作实例 68
      • 2.7 树结构 71
      • 2.7.1 什么是树结构 71
      • 2.7.2 树的基本概念 72
      • 2.7.3 二叉树 73
      • 2.7.4 准备数据 76
      • 2.7.5 初始化二叉树 76
      • 2.7.6 添加结点 77
      • 2.7.7 查找结点 78
      • 2.7.8 获取左子树 79
      • 2.7.9 获取右子树 79
      • 2.7.10 判断空树 80
      • 2.7.11 计算二叉树深度 80
      • 2.7.12 清空二叉树 81
      • 2.7.13 显示结点数据 81
      • 2.7.14 遍历二叉树 81
      • 2.7.15 树结构操作实例 83
      • 2.8 图结构 91
      • 2.8.1 什么是图结构 91
      • 2.8.2 图的基本概念 91
      • 2.8.3 准备数据 95
      • 2.8.4 创建图 97
      • 2.8.5 清空图 98
      • 2.8.6 显示图 98
      • 2.8.7 遍历图 99
      • 2.8.8 图结构操作实例 100
      • 2.9 小结 103
      • 第3章 基本算法思想
      • 3.1 常用算法思想概述 104
      • 3.2 穷举算法思想 104
      • 3.2.1 穷举算法基本思想 105
      • 3.2.2 穷举算法实例 105
      • 3.3 递推算法思想 107
      • 3.3.1 递推算法基本思想 107
      • 3.3.2 递推算法实例 107
      • 3.4 递归算法思想 109
      • 3.4.1 递归算法基本思想 109
      • 3.4.2 递归算法实例 109
      • 3.5 分治算法思想 110
      • 3.5.1 分治算法基本思想 111
      • 3.5.2 分治算法实例 111
      • 3.6 概率算法思想 115
      • 3.6.1 概率算法基本思想 115
      • 3.6.2 概率算法实例 115
      • 3.7 小结 117
      • 第4章 排序算法
      • 4.1 排序算法概述 118
      • 4.2 冒泡排序算法 119
      • 4.2.1 冒泡排序算法 119
      • 4.2.2 冒泡排序算法实例 120
      • 4.3 选择排序算法 122
      • 4.3.1 选择排序算法 122
      • 4.3.2 选择排序算法实例 123
      • 4.4 插入排序算法 125
      • 4.4.1 插入排序算法 125
      • 4.4.2 插入排序算法实例 126
      • 4.5 Shell排序算法 127
      • 4.5.1 Shell排序算法 128
      • 4.5.2 Shell排序算法实例 129
      • 4.6 快速排序算法 130
      • 4.6.1 快速排序算法 131
      • 4.6.2 快速排序算法实例 132
      • 4.7 堆排序算法 134
      • 4.7.1 堆排序算法 134
      • 4.7.2 堆排序算法实例 138
      • 4.8 合并排序算法 141
      • 4.8.1 合并排序算法 141
      • 4.8.2 合并排序算法实例 144
      • 4.9 排序算法的效率 147
      • 4.10 排序算法的其他应用 147
      • 4.10.1 反序排序 147
      • 4.10.2 字符串数组的排序 150
      • 4.10.3 字符串的排序 153
      • 4.11 小结 155
      • 第5章 查找算法
      • 5.1 查找算法概述 156
      • 5.2 顺序查找 157
      • 5.2.1 顺序查找算法 157
      • 5.2.2 顺序查找操作实例 157
      • 5.3 折半查找 159
      • 5.3.1 折半查找算法 159
      • 5.3.2 折半查找操作实例 161
      • 5.4 数据结构中的查找算法 163
      • 5.4.1 顺序表结构中的查找算法 164
      • 5.4.2 链表结构中的查找算法 167
      • 5.4.3 树结构中的查找算法 171
      • 5.4.4 图结构中的查找算法 171
      • 5.5 小结 172
      • 第6章 基本数学问题
      • 6.1 判断闰年 173
      • 6.2 多项式计算 175
      • 6.2.1 一维多项式求值 175
      • 6.2.2 二维多项式求值 177
      • 6.2.3 多项式乘法 179
      • 6.2.4 多项式除法 181
      • 6.3 随机数生成算法 183
      • 6.3.1 Java语言中的随机方法 183
      • 6.3.2 [0,1]之间均匀分布的随机数算法 185
      • 6.3.3 产生任意范围的随机数 187
      • 6.3.4 [m,n]之间均匀分布的随机整数算法 188
      • 6.3.5 正态分布的随机数生成算法 189
      • 6.4 复数运算 191
      • 6.4.1 简单的复数运算 191
      • 6.4.2 复数的幂运算 194
      • 6.4.3 复指数运算 195
      • 6.4.4 复对数运算 196
      • 6.4.5 复正弦运算 198
      • 6.4.6 复余弦运算 199
      • 6.5 阶乘 200
      • 6.5.1 使用循环来计算阶乘 200
      • 6.5.2 使用递归来计算阶乘 201
      • 6.6 计算π的近似值 202
      • 6.6.1 割圆术 203
      • 6.6.2 蒙特卡罗算法 206
      • 6.6.3 级数公式 208
      • 6.7 矩阵运算 210
      • 6.7.1 矩阵加法 210
      • 6.7.2 矩阵减法 211
      • 6.7.3 矩阵乘法 213
      • 6.8 方程求解 215
      • 6.8.1 线性方程求解——高斯消元法 215
      • 6.8.2 非线性方程求解——二分法 220
      • 6.8.3 非线性方程求解——牛顿迭代法 222
      • 6.9 小结 225
      • 第7章 数据结构问题
      • 7.1 动态数组排序 226
      • 7.1.1 动态数组的存储和排序 226
      • 7.1.2 动态数组排序实例 227
      • 7.2 约瑟夫环 230
      • 7.2.1 简单约瑟夫环算法 230
      • 7.2.2 简单约瑟夫环求解 232
      • 7.2.3 复杂约瑟夫环算法 233
      • 7.2.4 复杂约瑟夫环求解 234
      • 7.3 城市之间的最短总距离 237
      • 7.3.1 最短总距离算法 237
      • 7.3.2 最短总距离求解 240
      • 7.4 最短路径 244
      • 7.4.1 最短路径算法 245
      • 7.4.2 最短路径求解 247
      • 7.5 括号匹配 252
      • 7.5.1 括号匹配算法 252
      • 7.5.2 括号匹配求解 254
      • 7.6 小结 257
      • 第8章 数论问题
      • 8.1 数论概述 258
      • 8.1.1 数论概述 258
      • 8.1.2 数论的分类 259
      • 8.1.3 初等数论 260
      • 8.1.4 本章用到的基本概念 260
      • 8.2 完全数 261
      • 8.2.1 什么是完全数 261
      • 8.2.2 计算完全数算法 262
      • 8.3 亲密数 264
      • 8.3.1 什么是亲密数 264
      • 8.3.2 计算亲密数算法 264
      • 8.4 水仙花数 267
      • 8.4.1 什么是水仙花数 267
      • 8.4.2 计算水仙花数算法 268
      • 8.5 自守数 270
      • 8.5.1 什么是自守数 270
      • 8.5.2 计算自守数算法 271
      • 8.6 最大公约数 274
      • 8.6.1 计算最大公约数算法——辗转相除法 275
      • 8.6.2 计算最大公约数算法——Stein算法 275
      • 8.6.3 计算最大公约数示例 277
      • 8.7 最小公倍数 278
      • 8.8 素数 280
      • 8.8.1 什么是素数 280
      • 8.8.2 计算素数算法 280
      • 8.9 回文素数 282
      • 8.9.1 什么是回文素数 282
      • 8.9.2 计算回文素数算法 282
      • 8.10 平方回文数 285
      • 8.10.1 什么是平方回文数 285
      • 8.10.2 计算平方回文数算法 285
      • 8.11 分解质因数 287
      • 8.12 小结 289
      • 第9章 算法经典趣题
      • 9.1 百钱买百鸡 290
      • 9.1.1 百钱买百鸡算法 290
      • 9.1.2 百钱买百鸡求解 291
      • 9.2 五家共井 292
      • 9.2.1 五家共井算法 292
      • 9.2.2 五家共井求解 293
      • 9.3 鸡兔同笼 295
      • 9.3.1 鸡兔同笼算法 295
      • 9.3.2 鸡兔同笼求解 295
      • 9.4 猴子吃桃 296
      • 9.4.1 猴子吃桃算法 296
      • 9.4.2 猴子吃桃求解 297
      • 9.5 舍罕王赏麦 298
      • 9.5.1 舍罕王赏麦问题 298
      • 9.5.2 舍罕王赏麦求解 299
      • 9.6 汉诺塔 300
      • 9.6.1 汉诺塔算法 301
      • 9.6.2 汉诺塔求解 302
      • 9.7 窃贼问题 303
      • 9.7.1 窃贼问题算法 303
      • 9.7.2 窃贼问题求解 305
      • 9.8 马踏棋盘 308
      • 9.8.1 马踏棋盘算法 308
      • 9.8.2 马踏棋盘求解 310
      • 9.9 八皇后问题 312
      • 9.9.1 八皇后问题算法 312
      • 9.9.2 八皇后问题求解 314
      • 9.10 寻找假银币 315
      • 9.10.1 寻找假银币算法 316
      • 9.10.2 寻找假银币求解 318
      • 9.11 青蛙过河 320
      • 9.11.1 青蛙过河算法 320
      • 9.11.2 青蛙过河求解 321
      • 9.12 三色旗 325
      • 9.12.1 三色旗算法 325
      • 9.12.2 三色旗求解 326
      • 9.13 渔夫捕鱼 328
      • 9.13.1 渔夫捕鱼算法 328
      • 9.13.2 渔夫捕鱼求解 329
      • 9.14 爱因斯坦的阶梯 330
      • 9.14.1 爱因斯坦的阶梯算法 330
      • 9.14.2 爱因斯坦的阶梯求解 331
      • 9.15 兔子产仔 332
      • 9.15.1 兔子产仔算法 332
      • 9.15.2 兔子产仔求解 333
      • 9.16 常胜将军 334
      • 9.16.1 常胜将军算法 334
      • 9.16.2 常胜将军求解 335
      • 9.17 新郎和新娘 336
      • 9.17.1 新郎和新娘算法 337
      • 9.17.2 新郎和新娘求解 337
      • 9.18 三色球 339
      • 9.18.1 三色球算法 339
      • 9.18.2 三色球求解 340
      • 9.19 小结 341
      • 第10章 游戏中的算法
      • 10.1 洗扑克牌算法 342
      • 10.1.1 洗扑克牌算法 342
      • 10.1.2 洗扑克牌实例 343
      • 10.2 取火柴游戏算法 346
      • 10.2.1 取火柴游戏算法 346
      • 10.2.2 取火柴游戏实例 347
      • 10.3 十点半算法 349
      • 10.3.1 十点半算法 349
      • 10.3.2 十点半游戏实例 355
      • 10.4 生命游戏 361
      • 10.4.1 生命游戏的原理 362
      • 10.4.2 生命游戏的算法 363
      • 10.4.3 生命游戏实例 364
      • 10.5 小结 369
      • 第11章 简单Java上机面试题
      • 11.1 打印九九乘法口诀表 370
      • 11.2 获得任意一个时间的下一天的时间 371
      • 11.3 将某个时间以固定格式转化成字符串 373
      • 11.4 怎样截取字符串 374
      • 11.5 怎样实现元素互换 375
      • 11.6 怎样实现元素排序 377
      • 11.7 怎样实现Singleton模式编程 379
      • 11.8 怎样实现金额转换 380
      • 11.9 如何判断回文数字 383
      • 11.10 小结 384
      • 第12章 逻辑推理类面试题
      • 12.1 脑筋急转弯 385
      • 12.1.1 中国有多少辆汽车 385
      • 12.1.2 下水道的盖子为什么是圆形的 386
      • 12.1.3 分蛋糕 387
      • 12.2 逻辑推理 387
      • 12.2.1 哪个开关控制哪盏灯 388
      • 12.2.2 戴帽子 388
      • 12.2.3 海盗分金 389
      • 12.2.4 罪犯认罪 390
      • 12.2.5 找出质量不相同的球 391
      • 12.2.6 有多少人及格 391
      • 12.2.7 他说的是真话吗 392
      • 12.3 计算推理 393
      • 12.3.1 倒水问题 393
      • 12.3.2 骗子购物 394
      • 12.3.3 求最大的连续组合值(华为校园招聘笔试题) 395
      • 12.3.4 洗扑克牌(乱数排列) 396
      • 12.3.5 字符移动(金山笔试题) 398
      • 12.4 小结 399
      • 第13章 数学能力测试
      • 13.1 100盏灯 400
      • 13.2 用一笔画出经过9个点的4条直线 401
      • 13.3 时针、分针和秒针重合问题 402
      • 13.4 怎样拿到第100号球 405
      • 13.5 烧绳计时 406
      • (注:以下内容读者可在附赠光盘中阅读学习。)
      • 第14章 算法面试题
      • 14.1 基础算法 408
      • 14.1.1 字符串匹配 408
      • 14.1.2 哥德巴赫猜想的近似证明 411
      • 14.1.3 将一个正整数分解质因数 413
      • 14.1.4 怎样实现金额转换 415
      • 14.1.5 数字排列 419
      • 14.1.6 数字拆解 421
      • 14.1.7 数字组合 423
      • 14.2 思维扩展算法 426
      • 14.2.1 蛇形打印 426
      • 14.2.2 24点算法 428
      • 14.2.3 双色球随机摇号 432
      • 14.2.4 巧妙过桥 435
      • 14.2.5 猴子吃桃 439
      • 14.2.6 天

      读书笔记

      Java操作word文档替换文字并指定位置插入图片方法

      Java 替换word文档文字并指定位置插入图片

      先说下 需要的依赖包

      <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-excelant</artifactId>
            <version>3.12</version>
          </dependency>
          <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-scratchpad</artifactId>
            <version>3.12</version>
          </dependency>
          <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.8</version>
          </dependency>
          <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>3.8</version>
          </dependency>
      <!-- 生成图片-->
       <dependency>
          <groupId>org.jfree</groupId>
          <artifactId>jfreechart</artifactId>
          <version>1.0.19</version>
        </dependency>
        <dependency>
      <!--支持插入图片-->
          <groupId>org.docx4j</groupId>
          <artifactId>docx4j</artifactId>
          <version>3.3.1</version>
        </dependency>

      示例,下图

      如上图,需要替换的字符串地方“$1”为“1231”,在指定位置插入书签,并命名“test”    ,插入的图片如下

      本人也没太过多去研究,亲测通过有效,在这分享下

      1.demo

      import java.awt.Font;
      import java.io.File;
      import java.io.FileInputStream;
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.io.InputStream;
      import java.math.BigInteger;
      import java.text.DecimalFormat;
      import java.text.NumberFormat;
      import java.util.Iterator;
      import java.util.List;
      import java.util.Map;
      import java.util.Set;
      import org.apache.poi.POIXMLDocument;
      import org.apache.poi.openxml4j.opc.OPCPackage;
      import org.apache.poi.util.IOUtils;
      import org.apache.poi.xwpf.usermodel.XWPFDocument;
      import org.apache.poi.xwpf.usermodel.XWPFParagraph;
      import org.apache.poi.xwpf.usermodel.XWPFRun;
      import org.docx4j.TraversalUtil;
      import org.docx4j.dml.wordprocessingDrawing.Inline;
      import org.docx4j.finders.RangeFinder;
      import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
      import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
      import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
      import org.docx4j.wml.Body;
      import org.docx4j.wml.BooleanDefaultTrue;
      import org.docx4j.wml.CTBookmark;
      import org.docx4j.wml.Color;
      import org.docx4j.wml.Document;
      import org.docx4j.wml.Drawing;
      import org.docx4j.wml.HpsMeasure;
      import org.docx4j.wml.ObjectFactory;
      import org.docx4j.wml.P;
      import org.docx4j.wml.R;
      import org.docx4j.wml.RPr;
      import org.jfree.chart.ChartFactory;
      import org.jfree.chart.ChartUtilities;
      import org.jfree.chart.JFreeChart;
      import org.jfree.chart.labels.StandardPieSectionLabelGenerator;
      import org.jfree.chart.plot.PiePlot;
      import org.jfree.chart.title.TextTitle;
      import org.jfree.data.general.DefaultPieDataset;import com.aisino.qysds.common.constant.ERRORConstants;
      import com.aisino.qysds.common.exception.SysException;
      import com.aisino.qysds.service.IExportBgService;
      import com.google.common.collect.Maps;
      public class ExportBgServiceImpl {
      public static void main(String[] args) throws Exception {
          Map<String, String> map = Maps.newHashMap();
          map.put("$1", "1231");
          XWPFDocument document = new XWPFDocument(POIXMLDocument.openPackage("D:\\tp\\test.docx"));
          Iterator<XWPFParagraph> itPara = document.getParagraphsIterator();
          while (itPara.hasNext()) {
            XWPFParagraph paragraph = (XWPFParagraph) itPara.next();
            List<XWPFRun> runs = paragraph.getRuns();
            for (int i = 0; i < runs.size(); i++) {
              String oneparaString = runs.get(i).getText(runs.get(i).getTextPosition());
              for (Map.Entry<String, String> entry : map.entrySet()) {
                if (oneparaString.equals(entry.getKey())) {
                  oneparaString = oneparaString.replace(entry.getKey(), entry.getValue());
                }
              }
              runs.get(i).setText(oneparaString, 0);
            }
          }
          FileOutputStream outStream = null;
          outStream = new FileOutputStream("D:\\tp\\test1.docx");
          document.write(outStream);
          outStream.close();
      //-----------------------------------这块为生成图片 和 插入图片
          DefaultPieDataset dataset = new DefaultPieDataset();
          dataset.setValue("修改类", 1);
          dataset.setValue("提示类", 1);
          dataset.setValue("校验不通过", 3);
          dataset.setValue("正常类", 3);
          JFreeChart chart = ChartFactory.createPieChart3D(null, dataset, true, false, false);
          chart.getLegend().setItemFont(new Font("黑体", Font.BOLD, 15)); // 设置图例类别字体
          // TextTitle title = new TextTitle(titleString);
          // title.setFont(new Font("黑体", Font.ITALIC, 20));//设置标题字体
          // chart.setTitle(title);
          PiePlot piePlot = (PiePlot) chart.getPlot();
          DecimalFormat df = new DecimalFormat("0.00%");
          NumberFormat nf = NumberFormat.getInstance();
          StandardPieSectionLabelGenerator generator = new StandardPieSectionLabelGenerator("{0} {2}", nf, df);// 获得StandardPieSectionLabelGenerator对象,生成的格式,
          // {0}表示section名,{1}表示section的值,{2}表示百分比。可以自定义
          piePlot.setLabelGenerator(generator);// 设置百分比
          piePlot.setLabelFont(new Font("黑体", Font.ITALIC, 15));// 设置饼图中类别字体
          piePlot.setNoDataMessage("此时并没有任何数据可用");
          piePlot.setCircular(false);
          piePlot.setLabelGap(0.02D);
          piePlot.setIgnoreNullValues(true);// 设置不显示空位
          piePlot.setIgnoreZeroValues(true);// 设置不显示负值或零值
          String fName = "pie.png";
          File file = new File("D:\\tp", fName);
          if (file.exists()) {
            file.delete();
          }
          try {
            ChartUtilities.saveChartAsPNG(file, chart, 800, 500);
            File file2 = new File("D:\\tp\\test1.docx");
            WordprocessingMLPackage wPackage = WordprocessingMLPackage.load(new FileInputStream(file2));
            MainDocumentPart mainDocumentPart = wPackage.getMainDocumentPart();
            Document wmlDoc = (Document) mainDocumentPart.getJaxbElement();
            Body body = wmlDoc.getBody();
            // 提取正文中所有段落
            List<Object> paragraphs = body.getContent();
            // 提取书签并创建书签的游标
            RangeFinder rt = new RangeFinder("CTBookmark", "CTMarkupRange");
            new TraversalUtil(paragraphs, rt);
            for (CTBookmark bm : rt.getStarts()) {
              if (bm.getName().equals("test")) {// 这里的test为 word文档中预设的 书签名
                InputStream inputStream = new FileInputStream(file);
                byte[] bytes = IOUtils.toByteArray(inputStream);
                BinaryPartAbstractImage imagePart = BinaryPartAbstractImage.createImagePart(wPackage, bytes);
                Inline inline = imagePart.createImageInline(null, null, 0, 1, false, 10000);//这里的100000不是正常屏幕大小,用于设置插入图片的大小
                P p = (P) (bm.getParent());
                ObjectFactory factory = new ObjectFactory();
                // R对象是匿名的复杂类型,然而我并不知道具体啥意思,估计这个要好好去看看ooxml才知道
                R run = factory.createR();
                // drawing理解为画布?
                Drawing drawing = factory.createDrawing();
                drawing.getAnchorOrInline().add(inline);
                run.getContent().add(drawing);
                p.getContent().add(run);
              }
            }
            wPackage.save(new FileOutputStream(new File("D:\\tp\\test1.docx")));
          } catch (IOException e) {
          }
        }
      }

      最后效果图如下:

      java简单操作word实例

      本文为大家分享了java简单操作word例子,供大家参考,具体内容如下

      package apache.poi;
      
      import java.io.ByteArrayInputStream;
      import java.io.ByteArrayOutputStream;
      import java.io.File;
      import java.io.FileInputStream;
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.io.OutputStream;
      import java.util.HashMap;
      import java.util.Map;
      
      import org.apache.poi.hwpf.HWPFDocument;
      import org.apache.poi.hwpf.usermodel.Range;
      import org.apache.poi.poifs.filesystem.DirectoryEntry;
      import org.apache.poi.poifs.filesystem.POIFSFileSystem;
      
      
      public class ExportDocTest {
        
        public static void main(String[] args) {
          String destFile="D:\\11.doc";
          //#####################根据自定义内容导出Word文档#################################################
          StringBuffer fileCon=new StringBuffer();
          fileCon.append("        张大炮      男       317258963215223\n" +
              "2011   09    2013   07    3\n" +
              "  二炮研究       成人\n" +
              "2013000001               2013   07   08");
          fileCon.append("\n\r\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
          
          new ExportDocTest().exportDoc(destFile, fileCon.toString());
          
          //##################根据Word模板导出单个Word文档###################################################
          Map<String, String> map=new HashMap<String, String>();
          
          map.put("name", "Zues");
          map.put("sex", "男");
          map.put("idCard", "200010");
          map.put("year1", "2000");
          map.put("month1", "07");
          map.put("year2", "2008");
          map.put("month2", "07");
          map.put("gap", "2");
          map.put("zhuanye", "计算机科学与技术");
          map.put("type", "研究生");
          map.put("bianhao", "2011020301");
          map.put("nowy", "2011");
          map.put("nowm", "01");
          map.put("nowd", "20220301");
          //注意biyezheng_moban.doc文档位置,此例中为应用根目录
          HWPFDocument document=new ExportDocTest().replaceDoc("biyezheng_moban.doc", map);
          ByteArrayOutputStream ostream = new ByteArrayOutputStream();
          try {
            document.write(ostream);
            //输出word文件
            OutputStream outs=new FileOutputStream(destFile);
            outs.write(ostream.toByteArray());
            outs.close();
          } catch (IOException e) {
            e.printStackTrace();
          }
          
        }
        
        
        /**
         * 
         * @param destFile
         * @param fileCon
         */
        public void exportDoc(String destFile,String fileCon){
          try {
            //doc content
            ByteArrayInputStream bais = new ByteArrayInputStream(fileCon.getBytes());
            POIFSFileSystem fs = new POIFSFileSystem();
            DirectoryEntry directory = fs.getRoot(); 
            directory.createDocument("WordDocument", bais);
            FileOutputStream ostream = new FileOutputStream(destFile);
            fs.writeFilesystem(ostream);
            bais.close();
            ostream.close();
            
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
        
        
        /**
         * 读取word模板并替换变量
         * @param srcPath
         * @param map
         * @return
         */
        public HWPFDocument replaceDoc(String srcPath, Map<String, String> map) {
          try {
            // 读取word模板
            FileInputStream fis = new FileInputStream(new File(srcPath));
            HWPFDocument doc = new HWPFDocument(fis);
            // 读取word文本内容
            Range bodyRange = doc.getRange();
            // 替换文本内容
            for (Map.Entry<String, String> entry : map.entrySet()) {
              bodyRange.replaceText("${" + entry.getKey() + "}", entry
                  .getValue());
            }
            return doc;
          } catch (Exception e) {
            e.printStackTrace();
            return null;
          }
        }
      
      }
      

      以上就是本文的全部内容,希望对大家的学习有所帮助。

      以上就是本次介绍的Java算法电子书的全部相关内容,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:Raspberry Pi机器人制作实例

      下一篇:第一行代码[Java]视频讲解版

      展开 +

      收起 -

      下载地址:百度网盘下载
      Java算法 相关电子书
      读者心得
      51小时9分钟前回答

      java搜索无向图中两点之间所有路径的算法

      参考java查找无向连通图中两点间所有路径的算法,对代码进行了部分修改,并编写了测试用例。 算法要求: 1. 在一个无向连通图中求出两个给定点之间的所有路径; 2. 在所得路径上不能含有环路或重复的点; 算法思想描述: 1. 整理节点间的关系,为每个节点建立一个集合,该集合中保存所有与该节点直接相连的节点(不包括该节点自身); 2. 定义两点一个为起始节点,另一个为终点,求解两者之间的所有路径的问题可以被分解为如下所述的子问题:对每一个与起始节点直接相连的节点,求解它到终点的所有路径(路径上不包括起始节点)得到一个路径集合,将这些路径集合相加就可以得到起始节……

      8小时17分钟前回答

      JavaScript树的深度优先遍历和广度优先遍历算法示例

      本文实例讲述了JavaScript树的深度优先遍历和广度优先遍历算法。分享给大家供大家参考,具体如下: 1、深度优先遍历的递归写法 function deepTraversal(node) { var nodes = []; if (node != null) { nodes.push(node); var children = node.children; for (var i = 0; i children.length; i++) deepTraversal(children[i]); } return nodes;} 2、深度优先遍历的非递归写法 function deepTraversal(node) { var nodes = []; if (node != null) { var stack = []; stack.push(node); while (stack.length != 0) { var item = stack.pop(); nodes.push(item); var children = item.children; for (var i = children.length - 1; i = 0; i--) stack.push(children[i]); } } return nodes;} 3、广度优先遍历的递归写法: 报错: Maximum call stack size exceeded(…) functio……

      码农之家

      利韵宁 提供上传

      资源
      20
      粉丝
      9
      喜欢
      314
      评论
      6

      Copyright 2018-2021 www.xz577.com 码农之家

      版权投诉 / 书籍推广:520161757@qq.com