Java最经典最基础十大算法《内含算法思想-算法步骤-程序实现》（你一定会用到）

最新推荐文章于 2024-07-01 09:58:40 发布

2301_82243626

最新推荐文章于 2024-07-01 09:58:40 发布

阅读量794

点赞数 22

分类专栏： 2024年程序员学习文章标签：算法 java 深度优先

本文链接：https://blog.csdn.net/2301_82243626/article/details/138015067

版权

2024年程序员学习专栏收录该内容

31 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

深度优先遍历图算法步骤：

1. 访问顶点v；

2. 依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；

3. 若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。

上述描述可能比较抽象，举个实例：

DFS 在访问图中某一起始顶点 v 后，由 v 出发，访问它的任一邻接顶点 w1；再从 w1 出发，访问与 w1邻接但还没有访问过的顶点 w2；然后再从 w2 出发，进行类似的访问，… 如此进行下去，直至到达所有的邻接顶点都被访问过的顶点 u 为止。

接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问的邻接顶点。如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问；如果没有，就再退回一步进行搜索。重复上述过程，直到连通图中所有顶点都被访问过为止。

代码实现：

import java.util.Stack;

public class DFSTest {

// 存储节点信息

private char[] vertices;

// 存储边信息（邻接矩阵）

private int[][] arcs;

// 图的节点数

private int vexnum;

// 记录节点是否已被遍历

private boolean[] visited;

// 初始化

public DFSTest(int n) {

vexnum = n;

vertices = new char[n];

arcs = new int[n][n];

visited = new boolean[n];

for (int i = 0; i < vexnum; i++) {

for (int j = 0; j < vexnum; j++) {

arcs[i][j] = 0;

}

// 添加边(无向图)

public void addEdge(int i, int j) {

// 边的头尾不能为同一节点

if (i == j)return;

arcs[i][j] = 1;

arcs[j][i] = 1;

}

// 设置节点集

public void setVertices(char[] vertices) {

this.vertices = vertices;

}

// 设置节点访问标记

public void setVisited(boolean[] visited) {

this.visited = visited;

}

// 打印遍历节点

public void visit(int i){

System.out.print(vertices[i] + " ");

}

// 从第i个节点开始深度优先遍历

private void traverse(int i){

// 标记第i个节点已遍历

visited[i] = true;

// 打印当前遍历的节点

visit(i);

// 遍历邻接矩阵中第i个节点的直接联通关系

for(int j=0;j<vexnum;j++){

// 目标节点与当前节点直接联通，并且该节点还没有被访问，递归

if(arcs[i][j]==1 && visited[j]==false){

traverse(j);

}

// 图的深度优先遍历（递归）

public void DFSTraverse(){

// 初始化节点遍历标记

for (int i = 0; i < vexnum; i++) {

visited[i] = false;

}

// 从没有被遍历的节点开始深度遍历

for(int i=0;i<vexnum;i++){

if(visited[i]==false){

// 若是连通图，只会执行一次

traverse(i);

}

// 图的深度优先遍历（非递归）

public void DFSTraverse2(){

// 初始化节点遍历标记

for (int i = 0; i < vexnum; i++) {

visited[i] = false;

}

Stack s = new Stack();

for(int i=0;i<vexnum;i++){

if(!visited[i]){

//连通子图起始节点

s.add(i);

do{

// 出栈

int curr = s.pop();

// 如果该节点还没有被遍历，则遍历该节点并将子节点入栈

if(visited[curr]==false){

// 遍历并打印

visit(curr);

visited[curr] = true;

// 没遍历的子节点入栈

for(int j=vexnum-1; j>=0 ; j-- ){

if(arcs[curr][j]==1 && visited[j]==false){

s.add(j);

}

}while(!s.isEmpty());

}

public static void main(String[] args) {

DFSTest g = new DFSTest(9);

char[] vertices = {‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’,‘I’};

g.setVertices(vertices);

g.addEdge(0, 1);

g.addEdge(0, 5);

g.addEdge(1, 0);

g.addEdge(1, 2);

g.addEdge(1, 6);

g.addEdge(1, 8);

g.addEdge(2, 1);

g.addEdge(2, 3);

g.addEdge(2, 8);

g.addEdge(3, 2);

g.addEdge(3, 4);

g.addEdge(3, 6);

g.addEdge(3, 7);

g.addEdge(3, 8);

g.addEdge(4, 3);

g.addEdge(4, 5);

g.addEdge(4, 7);

g.addEdge(5, 0);

g.addEdge(5, 4);

g.addEdge(5, 6);

g.addEdge(6, 1);

g.addEdge(6, 3);

g.addEdge(6, 5);

g.addEdge(6, 7);

g.addEdge(7, 3);

g.addEdge(7, 4);

g.addEdge(7, 6);

g.addEdge(8, 1);

g.addEdge(8, 2);

g.addEdge(8, 3);

System.out.print(“深度优先遍历（递归）：”);

g.DFSTraverse();

System.out.println();

System.out.print(“深度优先遍历（非递归）：”);

g.DFSTraverse2();

}

算法七：BFS（广度优先搜索）

===========================================

广度优先搜索算法（Breadth-First-Search），是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中止。BFS同样属于盲目搜索。一般用队列数据结构来辅助实现BFS算法。

算法步骤：

1. 首先将根节点放入队列中。

2. 从队列中取出第一个节点，并检验它是否为目标。

如果找到目标，则结束搜寻并回传结果。
否则将它所有尚未检验过的直接子节点加入队列中。

3. 若队列为空，表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传“找不到目标”。

4. 重复步骤2。

代码实现：

package com.liuzhen.chapterThree;

public class BreadthFirstSearch {

public int count = 0; //计算广度优先遍历总次数，初始化为0

adjMatrix是待遍历图的邻接矩阵
value是待遍历图顶点用于是否被遍历的判断依据，0代表未遍历，非0代表已被遍历，其最终具体结果代表该顶点在最终遍历顺序中的位置
result用于存放广度优先遍历的顶点顺序

public void bfs(int[][] adjMatrix,int[] value,char[] result){

for(int i = 0;i < value.length;i++){

if(value[i] == 0){ //当该顶点未被遍历时

char temp = (char) (‘a’ + i);

result[count] = temp;

System.out.println();

System.out.println(“出发点：”+temp+“地”);

bfsVisit(adjMatrix,value,result,i); //使用迭代遍历该顶点周边所有邻接顶点

}

adjMatrix是待遍历图的邻接矩阵
value是待遍历图顶点用于是否被遍历的判断依据，0代表未遍历，非0代表已被遍历，其最终具体结果代表该顶点在最终遍历顺序中的位置
result用于存放广度优先遍历的顶点顺序
number是当前正在遍历的顶点在邻接矩阵中的数组下标编号

public void bfsVisit(int[][] adjMatrix,int[] value,char[] result,int number){

value[number] = ++count; //出发顶点已被遍历，其在遍历结果中最终位置为++count

for(int i = 0;i < value.length;i++){

if(adjMatrix[number][i] == 1 && value[i] == 0){ //当改顶点与出发顶点相邻且未被遍历时

char temp = (char) (‘a’ + i);

result[count] = temp;

System.out.print(“到达”+temp+“地”+“\t”);

value[i] = ++count; //当前被遍历顶点，其在遍历结果中最终位置为++count

}

public static void main(String[] args){

int[] value = new int[10]; //初始化后，各元素均为0

char[] result = new char[10];

char[] result1 = new char[10];

int[][] adjMatrix = {{0,0,1,1,1,0,0,0,0,0},

{0,0,0,0,1,1,0,0,0,0},

{1,0,0,1,0,1,0,0,0,0},

{1,0,1,0,0,0,0,0,0,0},

{1,1,0,0,0,1,0,0,0,0},

{0,1,1,0,1,0,0,0,0,0},

{0,0,0,0,0,0,0,1,0,1},

{0,0,0,0,0,0,1,0,1,0},

{0,0,0,0,0,0,0,1,0,1},

{0,0,0,0,0,0,1,0,1,0}};

BreadthFirstSearch test = new BreadthFirstSearch();

test.bfs(adjMatrix, value, result);

System.out.println();

System.out.println(“判断节点是否被遍历结果（0代表未遍历，非0代表已被遍历）：”);

for(int i = 0;i < value.length;i++)

System.out.print(" "+value[i]);

//依据具体顶点在遍历结果顺序中最终位置，计算其具体遍历顺序为result1数组序列

for(int i = 0;i < value.length;i++){

result1[value[i]-1] = (char) (‘a’ + i);

}

System.out.println();

System.out.println(“判断节点是否被遍历结果（0代表未遍历，非0代表已被遍历，其具体数字代表其原地点在被遍历结果中所处位置：）：”);

for(int i = 0;i < value.length;i++)

System.out.print(" "+result1[i]);

System.out.println();

System.out.println(“广度优先查找遍历顺序如下：”);

for(int i = 0;i < result.length;i++)

System.out.print(" "+result[i]);

}

算法八：Dijkstra算法

==========================================

戴克斯特拉算法（Dijkstra’s algorithm）是由荷兰计算机科学家艾兹赫尔·戴克斯特拉提出。迪科斯彻算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

该算法的输入包含了一个有权重的有向图 G，以及G中的一个来源顶点 S。我们以 V 表示 G 中所有顶点的集合。每一个图中的边，都是两个顶点所形成的有序元素对。(u, v) 表示从顶点 u 到 v 有路径相连。我们以 E 表示G中所有边的集合，而边的权重则由权重函数 w: E → [0, ∞] 定义。因此，w(u, v) 就是从顶点 u 到顶点 v 的非负权重（weight）。边的权重可以想像成两个顶点之间的距离。任两点间路径的权重，就是该路径上所有边的权重总和。已知有 V 中有顶点 s 及 t，Dijkstra 算法可以找到 s 到 t的最低权重路径(例如，最短路径)。这个算法也可以在一个图中，找到从一个顶点 s 到任何其他顶点的最短路径。对于不含负权的有向图，Dijkstra算法是目前已知的最快的单源最短路径算法。

算法步骤：

1. 初始时令 S={V0},T={其余顶点}，T中顶点对应的距离值

若存在<V0,Vi>，d(V0,Vi)为<V0,Vi>弧上的权值

若不存在<V0,Vi>，d(V0,Vi)为∞

2. 从T中选取一个其距离值为最小的顶点W且不在S中，加入S

3. 对其余T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的距离值缩短，则修改此距离值

重复上述步骤2、3，直到S中包含所有顶点，即W=Vi为止

代码实现：

package com.liuzhen.chapter9;

public class Dijkstra {

参数adjMatrix:为图的权重矩阵，权值为-1的两个顶点表示不能直接相连
函数功能：返回顶点0到其它所有顶点的最短距离，其中顶点0到顶点0的最短距离为0

public int[] getShortestPaths(int[][] adjMatrix) {

int[] result = new int[adjMatrix.length]; //用于存放顶点0到其它顶点的最短距离

boolean[] used = new boolean[adjMatrix.length]; //用于判断顶点是否被遍历

used[0] = true; //表示顶点0已被遍历

for(int i = 1;i < adjMatrix.length;i++) {

result[i] = adjMatrix[0][i];

used[i] = false;

}

for(int i = 1;i < adjMatrix.length;i++) {

int min = Integer.MAX_VALUE; //用于暂时存放顶点0到i的最短距离，初始化为Integer型最大值

int k = 0;

for(int j = 1;j < adjMatrix.length;j++) { //找到顶点0到其它顶点中距离最小的一个顶点

if(!used[j] && result[j] != -1 && min > result[j]) {

min = result[j];

k = j;

}

used[k] = true; //将距离最小的顶点，记为已遍历

for(int j = 1;j < adjMatrix.length;j++) { //然后，将顶点0到其它顶点的距离与加入中间顶点k之后的距离进行比较，更新最短距离

if(!used[j]) { //当顶点j未被遍历时

//首先，顶点k到顶点j要能通行；这时，当顶点0到顶点j的距离大于顶点0到k再到j的距离或者顶点0无法直接到达顶点j时，更新顶点0到顶点j的最短距离

if(adjMatrix[k][j] != -1 && (result[j] > min + adjMatrix[k][j] || result[j] == -1))

result[j] = min + adjMatrix[k][j];

}

return result;

}

public static void main(String[] args) {

Dijkstra test = new Dijkstra();

int[][] adjMatrix = {{0,6,3,-1,-1,-1},

{6,0,2,5,-1,-1},

{3,2,0,3,4,-1},

{-1,5,3,0,2,3},

{-1,-1,4,2,0,5},

{-1,-1,-1,3,5,0}};

int[] result = test.getShortestPaths(adjMatrix);

System.out.println(“顶点0到图中所有顶点之间的最短距离为：”);

for(int i = 0;i < result.length;i++)

System.out.print(result[i]+" ");

}

结果：

顶点0到图中所有顶点之间的最短距离为：

0 5 3 6 7 9

算法九：动态规划算法

======================================

动态规划（Dynamic programming）是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。

动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量：一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

关于动态规划最经典的问题当属背包问题。

算法步骤：

1. 最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索。

2. 子问题重叠性质。子问题重叠性质是指在用递归算法自顶向下对问题进行求解时，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，当再次需要计算已经计算过的子问题时，只是在表格中简单地查看一下结果，从而获得较高的效率。

代码实现：

package com.hust0328;

import java.util.Scanner;

/**

Created by huststl on 2018/3/28 14:24
动态规划题01

public class Dp01 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int n = scan.nextInt();

long max = 0;

int[][] dp = new int[n][n];

dp[0][0] = scan.nextInt();

for(int i=1;i<n;i++){

for(int j=0;j<=i;j++){

int num = scan.nextInt();

if(j==0){

dp[i][j] = dp[i-1][j] + num;

}else {

dp[i][j] = Math.max(dp[i-1][j-1],dp[i - 1][j])+num;

}

max = Math.max(dp[i][j],max);

}

System.out.println(max);

}

算法十：朴素贝叶斯分类算法

=========================================

朴素贝叶斯分类算法是一种基于贝叶斯定理的简单概率分类算法。贝叶斯分类的基础是概率推理，就是在各种条件的存在不确定，仅知其出现概率的情况下，如何完成推理和决策任务。概率推理是与确定性推理相对应的。而朴素贝叶斯分类器是基于独立假设的，即假设样本每个特征与其他特征都不相关。

朴素贝叶斯分类器依靠精确的自然概率模型，在有监督学**的样本集中能获取得非常好的分类效果。在许多实际应用中，朴素贝叶斯模型参数估计使用最大似然估计方法，换言之朴素贝叶斯模型能工作并没有用到贝叶斯概率或者任何贝叶斯模型。

代码实现：

package com.example.psbys;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.math.BigDecimal;

import java.net.URL;

import java.util.ArrayList;

import java.util.Scanner;

import java.util.Vector;

/**

朴素贝叶斯
@author Dyl

public class PSbys {

Vector vector;

int testTotal = 0;// 训练样本数量

int predictTotal = 0;// 测试样本的数据

int predictSucess = 0;// 预测成功的数量

String[] ClassValueName = { “unacc”, “acc”, “good”, “vgood” };

// 数量

int[] ClassValueTotal = new int[4];// unacc-0 acc-1 good-2 vgood-3

int[][] buying_Vlaue = new int[4][4]; // 前面是自己的属性，后面是value的属性

int[][] maint_Value = new int[4][4];

int[][] doors_Value = new int[4][4];

int[][] persons_Value = new int[3][4];

int[][] lugboot_Value = new int[3][4];

int[][] safety_Value = new int[3][4];

// 概率///节约空间

float[] ClassValueTotal_gl = new float[4];// unacc-0 acc-1 good-2 vgood-3

float[][] buying_Vlaue_gl = new float[4][4]; // 前面是自己的属性，后面是value的属性

float[][] maint_Value_gl = new float[4][4];

float[][] doors_Value_gl = new float[4][4];

float[][] persons_Value_gl = new float[3][4];

float[][] lugboot_Value_gl = new float[3][4];

float[][] safety_Value_gl = new float[3][4];

public PSbys() {

vector = new Vector();

}

public static void main(String[] args) throws Exception {

PSbys pSbys = new PSbys();

pSbys.getData();// 获取训练样本

pSbys.dataTest();// 传入准备测试的样本数据，检测其分类器的性能

pSbys.showGL();// 展示结果

}

/**

获取训练样本,统计个数，计算概率
@param url

private void getData() throws Exception {

InputStreamReader in = new InputStreamReader(getClass()

.getResourceAsStream(“/data/test.txt”));

Scanner scanner = new Scanner(in);

while (scanner.hasNext()) {

testTotal++;

String[] temp = scanner.nextLine().split(“,”);

Car car = new Car();

car.buying = temp[0];

car.maint = temp[1];

car.doors = temp[2];

car.persons = temp[3];

car.lug_boot = temp[4];

car.safety = temp[5];

car.ClassValues = temp[6];

vector.add(car);

dataTongJi(car);// 统计数据的个数

}

gailvTongJi();// 统计概率

}

/**

统计数量，为计算概率做准备

private void dataTongJi(Car car) {

// unacc下的东西

if (car.ClassValues.equals(“unacc”)) {

ClassValueTotal[0]++;// 统计unacc的个数

// buying: vhigh,high,med,low

if (car.buying.equals(“vhigh”)) {

buying_Vlaue[0][0]++;

} else if (car.buying.equals(“high”)) {

buying_Vlaue[1][0]++;

} else if (car.buying.equals(“med”)) {

buying_Vlaue[2][0]++;

} else {

buying_Vlaue[3][0]++;

}

// maint

if (car.maint.equals(“vhigh”)) {

maint_Value[0][0]++;

} else if (car.maint.equals(“high”)) {

maint_Value[1][0]++;

} else if (car.maint.equals(“med”)) {

maint_Value[2][0]++;

} else {

maint_Value[3][0]++;

}

// doors

if (car.doors.equals(“2”)) {

doors_Value[0][0]++;

} else if (car.doors.equals(“3”)) {

doors_Value[1][0]++;

} else if (car.doors.equals(“4”)) {

doors_Value[2][0]++;

} else {

doors_Value[3][0]++;

}

// persons

if (car.persons.equals(“2”)) {

persons_Value[0][0]++;

} else if (car.persons.equals(“4”)) {

persons_Value[1][0]++;

} else {

persons_Value[2][0]++;

}

// lug_boot

if (car.lug_boot.equals(“small”)) {

lugboot_Value[0][0]++;

} else if (car.lug_boot.equals(“med”)) {

lugboot_Value[1][0]++;

} else {

lugboot_Value[2][0]++;

}

// safety

if (car.safety.equals(“low”)) {

safety_Value[0][0]++;

} else if (car.safety.equals(“med”)) {

safety_Value[1][0]++;

} else {

safety_Value[2][0]++;

}

// acc下的东西

if (car.ClassValues.equals(“acc”)) {

ClassValueTotal[1]++;// 统计unacc的个数

// buying: vhigh,high,med,low

if (car.buying.equals(“vhigh”)) {

buying_Vlaue[0][1]++;

} else if (car.buying.equals(“high”)) {

buying_Vlaue[1][1]++;

} else if (car.buying.equals(“med”)) {

buying_Vlaue[2][1]++;

} else {

buying_Vlaue[3][1]++;

}

// maint

if (car.maint.equals(“vhigh”)) {

maint_Value[0][1]++;

} else if (car.maint.equals(“high”)) {

maint_Value[1][1]++;

} else if (car.maint.equals(“med”)) {

maint_Value[2][1]++;

} else {

maint_Value[3][1]++;

}

// doors

if (car.doors.equals(“2”)) {

doors_Value[0][1]++;

} else if (car.doors.equals(“3”)) {

doors_Value[1][1]++;

} else if (car.doors.equals(“4”)) {

doors_Value[2][1]++;

} else {

doors_Value[3][1]++;

}

// persons

if (car.persons.equals(“2”)) {

persons_Value[0][1]++;

} else if (car.persons.equals(“4”)) {

persons_Value[1][1]++;

} else {

persons_Value[2][1]++;

}

// lug_boot

if (car.lug_boot.equals(“small”)) {

lugboot_Value[0][1]++;

} else if (car.lug_boot.equals(“med”)) {

lugboot_Value[1][1]++;

} else {

lugboot_Value[2][1]++;

}

// safety

if (car.safety.equals(“low”)) {

safety_Value[0][1]++;

} else if (car.safety.equals(“med”)) {

safety_Value[1][1]++;

} else {

safety_Value[2][1]++;

}

// good下的东西

if (car.ClassValues.equals(“good”)) {

ClassValueTotal[2]++;// 统计unacc的个数

// buying: vhigh,high,med,low

if (car.buying.equals(“vhigh”)) {

buying_Vlaue[0][2]++;

} else if (car.buying.equals(“high”)) {

buying_Vlaue[1][2]++;

} else if (car.buying.equals(“med”)) {

buying_Vlaue[2][2]++;

} else {

buying_Vlaue[3][2]++;

}

// maint

if (car.maint.equals(“vhigh”)) {

maint_Value[0][2]++;

} else if (car.maint.equals(“high”)) {

maint_Value[1][2]++;

} else if (car.maint.equals(“med”)) {

maint_Value[2][2]++;

} else {

maint_Value[3][2]++;

}

// doors

if (car.doors.equals(“2”)) {

doors_Value[0][2]++;

} else if (car.doors.equals(“3”)) {

doors_Value[1][2]++;

} else if (car.doors.equals(“4”)) {

doors_Value[2][2]++;

} else {

doors_Value[3][2]++;

}

// persons

if (car.persons.equals(“2”)) {

persons_Value[0][2]++;

} else if (car.persons.equals(“4”)) {

persons_Value[1][2]++;

} else {

persons_Value[2][2]++;

}

// lug_boot

if (car.lug_boot.equals(“small”)) {

lugboot_Value[0][2]++;

} else if (car.lug_boot.equals(“med”)) {

lugboot_Value[1][2]++;

} else {

lugboot_Value[2][2]++;

}

// safety

if (car.safety.equals(“low”)) {

safety_Value[0][2]++;

} else if (car.safety.equals(“med”)) {

safety_Value[1][2]++;

} else {

safety_Value[2][2]++;

}

// vgood下的东西

if (car.ClassValues.equals(“vgood”)) {

ClassValueTotal[3]++;// 统计unacc的个数

// buying: vhigh,high,med,low

if (car.buying.equals(“vhigh”)) {

buying_Vlaue[0][3]++;

} else if (car.buying.equals(“high”)) {

buying_Vlaue[1][3]++;

} else if (car.buying.equals(“med”)) {

buying_Vlaue[2][3]++;

} else {

buying_Vlaue[3][3]++;

}

// maint

if (car.maint.equals(“vhigh”)) {

maint_Value[0][3]++;

} else if (car.maint.equals(“high”)) {

maint_Value[1][3]++;

} else if (car.maint.equals(“med”)) {

maint_Value[2][3]++;

} else {

maint_Value[3][3]++;

}

// doors

if (car.doors.equals(“2”)) {

doors_Value[0][3]++;

} else if (car.doors.equals(“3”)) {

doors_Value[1][3]++;

} else if (car.doors.equals(“4”)) {

doors_Value[2][3]++;

} else {

doors_Value[3][3]++;

}

// persons

if (car.persons.equals(“2”)) {

persons_Value[0][3]++;

} else if (car.persons.equals(“4”)) {

persons_Value[1][3]++;

} else {

persons_Value[2][3]++;

}

// lug_boot

if (car.lug_boot.equals(“small”)) {

lugboot_Value[0][3]++;

} else if (car.lug_boot.equals(“med”)) {

lugboot_Value[1][3]++;

} else {

lugboot_Value[2][3]++;

}

// safety

if (car.safety.equals(“low”)) {

safety_Value[0][3]++;

} else if (car.safety.equals(“med”)) {

safety_Value[1][3]++;

} else {

safety_Value[2][3]++;

}

/**

概率统计

private void gailvTongJi() {

for (int i = 0; i < ClassValueTotal.length; i++) {

ClassValueTotal_gl[i] = (float) ClassValueTotal[i] / testTotal;

}

for (int i = 0; i < buying_Vlaue_gl.length; i++) {

for (int j = 0; j < buying_Vlaue_gl[0].length; j++) {

buying_Vlaue_gl[i][j] = (float) buying_Vlaue[i][j]

/ ClassValueTotal[j];

maint_Value_gl[i][j] = (float) maint_Value[i][j]

/ ClassValueTotal[j];

doors_Value_gl[i][j] = (float) doors_Value[i][j]

/ ClassValueTotal[j];

}

for (int i = 0; i < persons_Value_gl.length; i++) {

for (int k = 0; k < persons_Value_gl[0].length; k++) {

persons_Value_gl[i][k] = (float) persons_Value[i][k]

/ ClassValueTotal[k];

lugboot_Value_gl[i][k] = (float) lugboot_Value[i][k]

/ ClassValueTotal[k];

safety_Value_gl[i][k] = (float) safety_Value[i][k]

/ ClassValueTotal[k];

}

private void showGL() {

// System.out.println(“unacc\t\tacc\t\tgood\t\tvgood”);

// for (int i = 0; i < ClassValueTotal.length; i++) {

// System.out.print(ClassValueTotal_gl[i]+" ");

// }

// System.out.println(“unacc\t\tacc\t\tgood\t\tvgood”);

// System.out.println(“buy:”);

for (int i = 0; i < buying_Vlaue_gl.length; i++) { for (int j = 0; j
< buying_Vlaue_gl[0].length; j++) {
System.out.print(buying_Vlaue_gl[i][j]+" "); }
System.out.println(); } System.out.println(); for (int i = 0; i <
maint_Value_gl.length; i++) { for (int j = 0; j <
maint_Value_gl[0].length; j++) {
System.out.print(maint_Value_gl[i][j]+" "); } System.out.println();
} System.out.println(); for (int i = 0; i < doors_Value_gl.length;
i++) { for (int j = 0; j < doors_Value_gl[0].length; j++) {
System.out.print(doors_Value_gl[i][j]+" "); } System.out.println();
} System.out.println(); for (int i = 0; i < persons_Value_gl.length;
i++) { for (int j = 0; j < persons_Value_gl[0].length; j++) {
System.out.print(persons_Value_gl[i][j]+" "); }
System.out.println(); } System.out.println(); for (int i = 0; i <
lugboot_Value_gl.length; i++) { for (int j = 0; j <
lugboot_Value_gl[0].length; j++) {
System.out.print(lugboot_Value_gl[i][j]+" "); }
System.out.println(); } System.out.println(); for (int i = 0; i <
safety_Value_gl.length; i++) { for (int j = 0; j <
safety_Value_gl[0].length; j++) {
System.out.print(safety_Value_gl[i][j]+" "); }
System.out.println(); }

for (int i = testTotal; i < (testTotal + predictTotal); i++) {

Car c = vector.get(i);

for (int j = 0; j < c.predictResult.length; j++) {

System.out.print(c.predictResult[j] + “\t\t”);

}

System.out.println();

最后

由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！

小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

+) { for (int j = 0; j <

maint_Value_gl[0].length; j++) {
System.out.print(maint_Value_gl[i][j]+" "); } System.out.println();
} System.out.println(); for (int i = 0; i < doors_Value_gl.length;
i++) { for (int j = 0; j < doors_Value_gl[0].length; j++) {
System.out.print(doors_Value_gl[i][j]+" "); } System.out.println();
} System.out.println(); for (int i = 0; i < persons_Value_gl.length;
i++) { for (int j = 0; j < persons_Value_gl[0].length; j++) {
System.out.print(persons_Value_gl[i][j]+" "); }
System.out.println(); } System.out.println(); for (int i = 0; i <
lugboot_Value_gl.length; i++) { for (int j = 0; j <
lugboot_Value_gl[0].length; j++) {
System.out.print(lugboot_Value_gl[i][j]+" "); }
System.out.println(); } System.out.println(); for (int i = 0; i <
safety_Value_gl.length; i++) { for (int j = 0; j <
safety_Value_gl[0].length; j++) {
System.out.print(safety_Value_gl[i][j]+" "); }
System.out.println(); }

for (int i = testTotal; i < (testTotal + predictTotal); i++) {

Car c = vector.get(i);

for (int j = 0; j < c.predictResult.length; j++) {

System.out.print(c.predictResult[j] + “\t\t”);

}

System.out.println();

最后

由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！

[外链图片转存中…(img-ku0UMH1N-1713626399548)]

小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》

[外链图片转存中…(img-rkwTr1yZ-1713626399549)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-m9tqtVHi-1713626399549)]

2301_82243626

关注

22
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录