精华内容
下载资源
问答
  • 在使用BFS和DFS遍历图的时候,一般都会维护一个set或者visit数组,标记被访问过的节点,在遍历时需要判断是否被访问过 一、DFS(深度优先遍历) ...Step2:下图 DFS(0) 访问节点0,Visited标注为T,...

    在使用BFS和DFS遍历图的时候,一般都会维护一个set或者visit数组,标记被访问过的节点,在遍历时需要判断是否被访问过

    一、DFS(深度优先遍历)

    DFS采用递归和栈,从起点顶点开始,递归访问其所有邻近节点。

    Step1:下图 DFS(1) 访问节点1,Visited标注为T,以1为顶点,准备访问1的邻近节点0

    Step2:下图 DFS(0) 访问节点0,Visited标注为T,以0为顶点,遍历0的邻近节点3,3也标注为T,准备访问3的邻近节点7

    Step3:下图 DFS(7) 访问节点7,Visited标注为T,以7为顶点,准备访问7的邻近节点5

    Step4:下图 DFS(5) 访问节点5,Visited标注为T,以5为顶点,准备访问5的邻近节点3,但是发现3标注为T(已经被访问过),再看5是否有其它邻近节点,如果有,继续访问,如果没有,返回上一级。这里返回上一级节点7

     Step5:返回至节点7

     Step6:同理以7为顶点,看7是否有其它邻近节点,如果有,继续访问,如果没有,返回上一级。这里返回上一级节点3

     Step7:同理以3为顶点,看3是否有其它邻近节点,如果有,继续访问,如果没有,返回上一级。这里返回上一级节点0

     Step8:同理以0为顶点,如果有邻近节点,继续访问,如果没有,返回上一级。这里返回上一级节点(最初的顶点)1 

    Step9:同理以1为顶点,看1是否有其它邻近节点,如果有,继续访问,如果没有,返回上一级,这里继续访问1的下个邻近节点2(节点1的上一个邻近节点是0)

    Step10:下图 DFS(2) 访问节点2,标注为T,准备访问2的邻近节点,0,1和4,发现0和1都被访问过了,访问4

    Step11:下图 DFS(4) 访问节点4,标注为T,准备访问4的邻近节点,2(被访问过),返回上一级2

    Step12:下图 发现2的邻近节点也都被访问过了,返回上一级1

     Step13:下图 访问1的最后一个邻近节点5,发现被访问过,返回至节点1

    Step14:至此 ,1的所有邻近节点都被深度优先遍历完了,下图中,只有6节点没有被访问到,标注为F。 

    二叉树的DFS递归Java实现(N叉树用for循环替代左右遍历)

    //DFS递归实现
    public void DFSWithRecursion(TreeNode root) {
        if (root == null)
            return;
     
        //在这里处理遍历到的TreeNode节点
            
        if (root.left != null)
            DFSWithRecursion(root.left);
        if (root.right != null)
            DFSWithRecursion(root.right);
    }

    二叉树的DFS栈Java实现(N叉树用for循环替代左右遍历)

    //DFS的栈实现(Stack)
    public void DFSWithStack(TreeNode root) {
         if (root == null)
             return;
         Stack<TreeNode> stack = new Stack<>();
         stack.push(root);
         while (!stack.isEmpty()) {
             TreeNode treeNode = stack.pop();
     
             //在这里处理遍历到的TreeNode
                 
             if (treeNode.right != null)
                 stack.push(treeNode.right);
             if (treeNode.left != null)
                 stack.push(treeNode.left);
         }
    }

    Keys and Rooms 题解

    class Solution {
        public boolean canVisitAllRooms(List<List<Integer>> rooms) {
                    boolean[] visit = new boolean[rooms.size()];
            visitRooms(rooms, visit);
            // DFS后,如果有房间没有访问到,返回false
            for (int i = 0; i < rooms.size(); i++) {
                if (!visit[i]) {
                    return false;
                }
            }
            return true;
        }
    
        // DFS遍历
        private void visitRooms(int index, List<List<Integer>> rooms, boolean[] visit) {
            // 防止死循环
            if (visit[index]) {
                return;
            }
            // 遍历每一个访问的房间,标注T
            visit[index] = true;
            // 深度优先遍历每一个房间
            for (int i = 0; i < rooms.get(index).size(); i++) {
                visitRooms(rooms.get(index).get(i), rooms, visit);
            }
            return;
        }
    }

    Maximum Difference Between Node and Ancestor 题解

    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode(int x) { val = x; }
     * }
     */
    class Solution {
        private int res=Integer.MIN_VALUE;
        public int maxAncestorDiff(TreeNode root) {
            // 存储当前路径的最大最小值,其中max和min是随着节点更新而更新的,这点很重要
            int min=Integer.MAX_VALUE;
            int max=Integer.MIN_VALUE;
            DFS(root,min,max);
            return res;
        }
        private void DFS(TreeNode root,int min,int max){
            // 当前节点为空,进行一次比较
            if (null == root) {
                res=Math.max(res,max-min);
                return;
            }
            // 访问节点后更新max和min
            if (root.val > max) {
                max=root.val;
            }
            if (root.val < min) {
                min=root.val;
            }
            // 继续遍历
            DFS(root.left,min,max);
            DFS(root.right,min,max);
        }
    }

     Max Area of Island 题解

    class Solution {
        public int maxAreaOfIsland(int[][] grid) {
            boolean[][] visit = new boolean[grid.length][grid[0].length];
            int res = 0;
            // 遍历没有被访问过的land,更新res
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[0].length; j++) {
                    if (grid[i][j] == 1 || !visit[i][j]) {
                        res = Math.max(res, DFS(i, j, grid, visit));
                    }
                }
            }
            return res;
        }
    
        private int DFS(int x, int y, int[][] grid, boolean[][] visit) {
            if (x >= grid.length || x < 0 || y < 0 || y >= grid[0].length || grid[x][y] == 0 || visit[x][y]) {
                return 0;
            }
            // 这里的count不是随着节点更新而更新的,而是在当前节点计算准确值返回给上一级节点的
            int count=1;
            visit[x][y] = true;
            // 不同于上一题求某一条路径上的最大差值,这里求的是所有路径的总值,所以要叠加计算后返回给上一级节点,不断递归叠加回root节点,即为所求值
            count += DFS(x - 1, y, grid, visit);
            count += DFS(x, y - 1, grid, visit);
            count += DFS(x + 1, y, grid, visit);
            count += DFS(x, y + 1, grid, visit);
            return count;
        }
    }

    二、BFS(广度优先遍历)

    BFS采用队列,从起点顶点开始,层级遍历至遍历所有节点。

    Step1:下图入队第一层节点(节点1),标注T,遍历第一层节点,入队第一层的邻近节点(第二层节点0、3、6),标注T

    Step2:第一层节点出队,遍历第二层节点0、3、6

     Step3:出队节点0和3,入队第三层节点2和5,标注T

      Step4:节点6出队,遍历第三层节点,2和5都没有邻近节点,第三层节点出队

    Step5:至此 ,共三层节点,层级遍历完顶点为1的所有节点。第一层节点1,第二层节点0 3 6,第三层节点2 5。

    二叉树的BFS队列Java实现

    //使用Queue实现BFS
    public void BFSWithQueue(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null)
            queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
     
            //在这里处理遍历到的TreeNode节点
     
            if (treeNode.left != null)
                queue.add(treeNode.left);
            if (treeNode.right != null)
                queue.add(treeNode.right);
        }
    }

    N叉树的BFS队列Java实现

    //使用Queue实现BFS
    public void BFSWithQueue(Node root) {
        Queue<Node> queue = new ArrayDeque<>();
        if (root != null)
            queue.add(root);
        Set<Node> visited = new HashSet<>();
        
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            visited.add(node);
    
            // int size = queue.size(); 这里可以记录每一层的节点大小
            // 在这里处理遍历到的Node节点
     
            if (node.children != null) {
                for (Node child : node.children) {
                    if (child != null && !visited.contains(child){
                        queue.add(child);
                    }
                }
            }
        }
    }

    Keys and Rooms 题解(同一道题,区别于上边的DFS算法) 

    class Solution {
        public boolean canVisitAllRooms(List<List<Integer>> rooms) {
                    boolean[] visit = new boolean[rooms.size()];
            visitRooms(rooms, visit);
            // DFS后,如果有房间没有访问到,返回false
            for (int i = 0; i < rooms.size(); i++) {
                if (!visit[i]) {
                    return false;
                }
            }
            return true;
        }
    
        // BFS遍历,遍历一个房间,就将对应的index标注为true
        private void visitRooms(List<List<Integer>> rooms, boolean[] visit) {
            Queue<Integer> queue = new ArrayDeque<>();
            queue.add(0);
            while (!queue.isEmpty()) {
                int tmp = queue.poll();
                // int size = queue.size(); 这里可以计算每一层的节点数
                // 标注为T
                visit[tmp] = true;
                // 遍历层级节点
                for (int i : rooms.get(tmp)) {
                    // 没访问过才会放入这一层,防止死循环
                    if (!visit[i]) {
                        queue.add(i);
                    }
                }
            }
        }
    }

    还有很多经典例子,不断更新中

    展开全文
  • 一、Java的四大存储结构如下图红色框标注: 二、四大存储结构的基本概述如下: 存储结构分四类:顺序存储、链接存储、索引存储 和 散列存储。 顺序结构和链接结构适用在内存结构中。 索引结构和...

    一、Java的四大存储结构如下图红色框标注:


    二、四大存储结构的基本概述如下:

    存储结构分四类:顺序存储、链接存储、索引存储 和 散列存储

    顺序结构和链接结构适用在内存结构中。

    索引结构和散列结构适用在外存与内存交互结构。


    顺序存储:在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构。

    特点:

    1、随机存取表中元素。

    2、插入和删除操作需要移动元素。


    链接存储:在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点。

    特点:

    1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成,所以相同空间内假设全存满的话顺序比链式存储更多)。
    2、逻辑上相邻的节点物理上不必相邻。
    3、插入、删除灵活 (不必移动节点,只要改变节点中的指针)。
    4、查找结点时链式存储要比顺序存储慢。
    5、每个结点是由数据域和指针域组成。


    索引存储:除建立存储结点信息外,还建立附加的索引表来标识结点的地址。索引表由若干索引项组成。

    特点:

    索引存储结构是用结点的索引号来确定结点存储地址,其优点是检索速度快,缺点是增加了附加的索引表,会占用较多的存储空间。


    散列存储:散列存储,又称hash存储,是一种力图将数据元素的存储位置与关键码之间建立确定对应关系的查找技术。

    散列法存储的基本思想是:由节点的关键码值决定节点的存储地址。散列技术除了可以用于查找外,还可以用于存储。

    特点:

    散列是数组存储方式的一种发展,相比数组,散列的数据访问速度要高于数组,因为可以依据存储数据的部分内容找到数据在数组中的存储位置,进而能够快速实现数据的访问,理想的散列访问速度是非常迅速的,而不像在数组中的遍历过程,采用存储数组中内容的部分元素作为映射函数的输入,映射函数的输出就是存储数据的位置,这样的访问速度就省去了遍历数组的实现,因此时间复杂度可以认为为O(1),而数组遍历的时间复杂度为O(n)。


























    展开全文
  • 下面是大数据常用算法,快速排序的java实现(基于字符串hash值的顺序排序 ,下面会标注排序不同的数据需要改写的比较代码,只需要改写比较代码就能实现不同数据的排序) 快速排序(Quicksort)是对冒...
    在数据处理方面,排序是很多算法的基础,很多处理操作都是在排序的基础上进行。很多刚开始学习编程的朋友可能只知道选择和冒泡排序。这两种排序算法在小数据量的时候还可以,在大数据面前需要的时间也是海量的。下面是大数据常用算法,快速排序的java实现(基于字符串hash值的顺序排序 ,下面会标注排序不同的数据需要改写的比较代码,只需要改写比较代码就能实现不同数据的排序) 
    快速排序(Quicksort)是对冒泡排序的一种改进。
    快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列
    /**
    * 快速排序,此方法是递归将一个数组分成两段,前面的都小于中间的值,后面的都大于中中间的值,有缺陷,对重复的数据排序速度过慢
    * @param strs 待排序的字符串
    * @param low 能达到的最小索引
    * @param high 能达到的最大索引
    */
    @Deprecated
    public static void quickSort(String strs[], int low, int high) {
    
    
    if (strs == null || strs.length < 1) {
    return;
    }
    if (low < high) {
    int mid = getMid(strs, low, high);
    quickSort(strs, low, mid - 1);
    quickSort(strs, mid + 1, high);
    }
    }
    /**
    * 快速排序时分段,将比第一个大的都放后面,比第一个小的都放前面,并返回中间点(开始时候的第一个被换到的索引)
    * @param strs
    * @param low
    * @param high
    * @return
    */
    @Deprecated
    private static int getMid(String[] strs, int low, int high) {
    String temp = strs[low];
    while (low < high) {
    while (low < high && strs[high].hashCode() > temp.hashCode()) {//这里是排序的比较代码,和下面一句比较代码的大于小于互换就能变为逆序
    high--;
    }
    strs[low] = strs[high];
    while (low < high && strs[low].hashCode() <= temp.hashCode()) {//比较代码2
    low++;
    }
    strs[high] = strs[low];
    }
    strs[low] = temp;
    return low;
    }


    上面这种方法是快速排序的基本实现,但是当数据中相等的数据太多的时候,每次将划分两部分一部分过小,一部分过大,效率和冒泡排序类似。下面是改进版。如果其选中的中间数据碰到相等的数据的话会将相等的数据聚合到一起再对剩下的两部分数据进行排序
    /**
    * 简单优化版的快速排序,
    * @param arr 待排序数组
    * @param low 能达到最低索引
    * @param high 能达到最高索引
    */
    public static void quickSortPlus(String[] arr, int low, int high) {
    
    
    if (low >= high)
    return;
    int lt = low;
    int gt = high;
    String temp = arr[low];
    int i = low + 1;
    while (i <= gt) {
    if (arr[i].hashCode() < temp.hashCode()) {//比较代码1
    swap(arr, lt, i);
    lt++;
    i++;
    } else if (arr[i].hashCode() > temp.hashCode()) {//比较代码2
    swap(arr, gt, i);
    gt--;
    } else {
    i++;
    }
    }
    quickSortPlus(arr, low, lt - 1);
    quickSortPlus(arr, gt + 1, high);
    
    
    }
    



    如果以上没有表达清楚或者有错误的地方的话欢迎交流 lidaju1995@163.com


    展开全文
  • OPENCV EM算法详解和JAVA实现

    千次阅读 2017-08-23 23:03:56
    2EM算法是一种非监督的学习算法,它的输入数据事先不需要进行标注。相反,该算法从给定的样本集中,能计算出高斯混和参数的最大似然估计。也能得到每个样本对应的标注值,类似于kmeans聚类(输入样本数据,输出样本...

    1EM算法是一种迭代算法,主要用于计算后验分布的众数或极大似然估计,广泛地应用于缺损数据、截尾数据、成群数据、带有讨厌参数的数据等所谓不完全数据的统计推断问题。

    2EM算法是一种非监督的学习算法,它的输入数据事先不需要进行标注。相反,该算法从给定的样本集中,能计算出高斯混和参数的最大似然估计。也能得到每个样本对应的标注值,类似于kmeans聚类(输入样本数据,输出样本数据的标注)。

    3优点:EM算法简单且稳定,迭代能保证观察数据对数后验似然是单调不减的。

    缺点:对于大规模数据和多维高斯分布,其总的迭代过程,计算量大,迭代速度易受影响;EM算法的收敛速度,非常依赖初始值的设置,设置不当,计算时的代价是相当大的;EM算法中的M-Step依然是采用求导函数的方法,所以它找到的是极值点,即局部最优解,而不一定是全局最优解。


    4EM算法的函数是trainEM,函数原型为:

     bool trainEM(InputArray samples, OutputArray logLikelihoods=noArray(),OutputArray labels=noArray(),OutputArray probs=noArray())

    四个参数:

     samples: 输入的样本,一个单通道的矩阵。从这个样本中,进行高斯混和模型估计。

    logLikelihoods: 可选项,输出一个矩阵,里面包含每个样本的似然对数值。

    labels: 可选项,输出每个样本对应的标注。

    probs: 可选项,输出一个矩阵,里面包含每个隐性变量的后验概率

    这个函数没有输入参数的初始化值,是因为它会自动执行kmeans算法,将kmeans算法得到的结果作为参数初始化。

    这个trainEM函数实际把E步骤和M步骤都包含进去了,我们也可以对两个步骤分开执行,OPENCV3.0中也提供了分别执行的函数:

    bool trainE(InputArray samples, InputArray means0,
                            InputArray covs0=noArray(),
                            InputArray weights0=noArray(),
                            OutputArray logLikelihoods=noArray(),
                            OutputArray labels=noArray(),
                            OutputArray probs=noArray())
     bool trainM(InputArray samples, InputArray probs0,
                            OutputArray logLikelihoods=noArray(),
                            OutputArray labels=noArray(),
                            OutputArray probs=noArray())
    trainEM函数的功能和kmeans差不多,都是实现自动聚类,输出每个样本对应的标注值。但它比kmeans还多出一个功能,就是它还能起到训练分类器的作用,用于后续新样本的预测。
    
    预测函数原型为:
    Vec2d predict2(InputArray sample, OutputArray probs) const

    sample: 待测样本

    probs : 和上面一样,一个可选的输出值,包含每个隐性变量的后验概率

    返回一个Vec2d类型的数,包括两个元素的double向量,第一个元素为样本的似然对数值,第二个元素为最大可能混和分量的索引值。

    在本文中,我们用两个实例来学习opencv中的EM算法的应用。

    EM算法在CPP里有示例代码,位于,如果安装了.net 或者按我前一篇文章配置了GCC就可以自己编译运行研究,代码位于/openc/\sources/samples/cpp/em.cpp

    5这里使用一个哥们写的C++,实现对一个图片颜色分类,图片路径要改一下,下面JAVA和实现与CPP功能一样:

    #include "stdafx.h"
    #include "opencv2/opencv.hpp"
    #include <iostream>
    using namespace std;
    using namespace cv;
    using namespace cv::ml;
    
    int main()
    {
        const int MAX_CLUSTERS = 5;
        Vec3b colorTab[] =
        {
            Vec3b(0, 0, 255),
            Vec3b(0, 255, 0),
            Vec3b(255, 100, 100),
            Vec3b(255, 0, 255),
            Vec3b(0, 255, 255)
        };
        Mat data, labels;
        Mat pic = imread("f:/aa.jpg");
        for (int i = 0; i < pic.rows; i++)
        for (int j = 0; j < pic.cols; j++)
        {
            Vec3b point = pic.at<Vec3b>(i, j);
            Mat tmp = (Mat_<float>(1, 3) << point[0], point[1], point[2]);
            data.push_back(tmp);
        }
    
        int N =3;  //聚成3类
        Ptr<EM> em_model = EM::create();
        em_model->setClustersNumber(N);
        em_model->setCovarianceMatrixType(EM::COV_MAT_SPHERICAL);
        em_model->setTermCriteria(TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 300, 0.1));
        em_model->trainEM(data, noArray(), labels, noArray());
    
        int n = 0;
        //显示聚类结果,不同的类别用不同的颜色显示
        for (int i = 0; i < pic.rows; i++)
        for (int j = 0; j < pic.cols; j++)
        {
            int clusterIdx = labels.at<int>(n);
            pic.at<Vec3b>(i, j) = colorTab[clusterIdx];
            n++;
        }
        imshow("pic", pic);
        waitKey(0);
    
        return 0;
    }

    同样效果的JAVA代码如下,JAVA的代码比较少,随着opencv在ANDROID平台大放光彩,相信这方面资源会越来越多。

    import org.opencv.core.Core;
    import org.opencv.core.CvType;
    import org.opencv.core.Mat;
    import org.opencv.core.Scalar;
    import org.opencv.core.TermCriteria;
    import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.ml.EM;
    
    public class MyMl {
    	public static void main(String[] args) {
    		System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    
    		int MAX_CLUSTERS = 6;
    		Scalar colorTab[] = { new Scalar(0, 0, 255), new Scalar(0, 255, 0), new Scalar(255, 100, 100),
    				new Scalar(255, 0, 255), new Scalar(0, 255, 255), new Scalar(0, 0, 0) };
    		Mat data = new Mat(), labels = new Mat();
    		Mat pic = Imgcodecs.imread("F:/aa.jpg");
    		for (int i = 0; i < pic.rows(); i++)
    			for (int j = 0; j < pic.cols(); j++) {
    				double[] point = pic.get(i, j);
    				Mat tmp = new Mat(1, 3, CvType.CV_32FC1);
    				tmp.put(0, 0, point);
    				data.push_back(tmp);
    			}
    
    		int N = 3;
    		EM em_model = EM.create();
    		em_model.setClustersNumber(N);
    		em_model.setCovarianceMatrixType(EM.COV_MAT_SPHERICAL);
    		em_model.setTermCriteria(new TermCriteria(TermCriteria.COUNT + TermCriteria.EPS, 300, 0.1));
    		em_model.trainEM(data, new Mat(), labels, new Mat());
    
    		int n = 0;
    		// 显示聚类结果,不同的类别用不同的颜色显示
    		for (int i = 0; i < pic.rows(); i++)
    			for (int j = 0; j < pic.cols(); j++) {
    				int clusterIdx = (int) labels.get(n, 0)[0];
    				pic.put(i, j, new double[] { colorTab[clusterIdx].val[0], colorTab[clusterIdx].val[1],
    						colorTab[clusterIdx].val[2] });
    				n++;
    		}
    		Imgcodecs.imwrite("F:/a1.png", pic);
    	}
    }
    

    运行效果,修改int N = 3;可以使用更多的颜色自动标注分类



    参考:

    http://www.cnblogs.com/denny402/p/5036288.html

    http://blog.csdn.net/fennvde007/article/details/17734597

    展开全文
  • 对于K个类别的数据选取K个质心 距离第 个质心最近的点归为 类 2、算法具体步骤: - 选取K个随机点,将其标注为K个类别 - 计算样本点到这K个随机点的距离,根据距离最近的第i个点将其分类i类 - 根据分类的结果...
  • kmeans算法的流程:  EM思想很伟大,在处理... Kmeans算法属于无监督学习中的一种,相比于监督学习,能节省很多成本,省去了大量的标签标注。每个数据点都有自己的隐式的分类。聚类要做的是,从中选取出数...
  • 它不仅可以查找数据,还可以高效地插入、删除数据。  特点:每个节点的key值大于左子节点,小于右子节点。注意它不一定是完全的二叉树。  所以节点的key是唯一的,我们就是通过它来索引key对应的value,注意...
  • java 狗一枚,最近在准备面试跳槽,在翻看了 boss 直聘上很多招聘信息后发现很多感兴趣的岗位都是标注后端工程师的,一般 jd 都是标注 c++/java/goland 会一个就可以了,然后就是一些通用的后端要求,比如数据结构,...
  • 详谈java注解

    2020-12-06 22:41:11
    牵肠挂肚的算法考试也考完了,现在也要好好学java...注释会被编译器直接忽略,注解则可以被编译器打包进入class文件,因此,注解是一种用作标注的“元数据”。 ①:jdk5.0 新增的功能 如果框架中没有注解的话,那么就
  • 玩转算法面试day01

    2019-08-08 14:23:52
    注:很多语言的标注库中快排的基本实现都是三路快排【包括java】 2 数据都是独特的 推荐常用的快速排序 注 :快排非常依赖数组的随机存储 3 数据几乎有序【正确位置较近】 推荐插入排序 【例】银行事务处理的数据...
  • Java实现二叉树的遍历

    2019-11-19 23:04:23
    最近在复习Java数据结构与算法的知识,这里编写代码实现二叉树的遍历。 二叉树的遍历分为两个方面,即深度优先和广度优先。深度优先遍历包含前序遍历、中序遍历、和后续遍历;广度优先遍历包含层序遍历。不同的...
  • Java Concurrency in Practice Java并发编程实践 中英文版

    千次下载 热门讨论 2013-07-16 13:13:11
    Java并发编程实践,压缩包包含其中文版、英文版及书中的代码示例。喜欢本书请购买正版,英文原版及中文译本目录如下: 目录 英文原版: Listings xii Preface xvii Chapter 1: ...附录A 并发性标注 参考文献
  • java生成tfrecord文件

    千次阅读 2018-10-13 00:06:31
    最近在做一个ner识别模型,用算法标注了一亿出头的数据,刚刚开始用python生成tfrecord文件,这一步非常的费时间,一亿条数据每一千万生成一个文件差不多要两个半小时的时间才能生成完成,左思右想想找一种快的方法...
  • 版权声明:本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。...自我介绍数据结构和算法JavaJava EE知识点储备计算机网络操作系统数据库相关XML常识性知识 总结
  • java实现普通队列

    2021-01-20 19:18:08
    约瑟夫问题是数据结构中的经典算法题,这里使用java中的单向环形链表解决该问题。 一、问题描述 n个人围成一圈,每个人分别标注为1、2、…、n,要求从1号从1开始报数,报到m的人出圈,接着下一个人又从1开始报数,...
  • java求解约瑟夫问题

    2021-01-19 22:25:07
    约瑟夫问题是数据结构中的经典算法题,这里使用java中的单向环形链表解决该问题。 一、问题描述 n个人围成一圈,每个人分别标注为1、2、…、n,要求从1号从1开始报数,报到m的人出圈,接着下一个人又从1开始报数,...
  • FudanNLP java -based

    2012-05-06 23:35:00
    中文分词|词性标注|实体名识别|关键词抽取|句法分析|文本分类|机器学习|信息检索|JAVA - Google Project Hosting介绍FudanNLP主要是为中文自然语言处理而开发的工具包,也包含为实现这些任务的机器学习算法数据集...
  • Java典型模块

    2012-02-25 18:27:40
    第1篇 Java开发必备基础 第1章 搭建Java开发环境 1.1 Java的过去、现在和未来 1.1.1 Java的历史 1.1.2 Java的语言特点 1.1.3 Java API简介 1.1.4 Java未来发展 1.2 Java程序设计环境 1.2.1 命令行工具——JDK 6.0 ...
  • 在过程演示中对各个操作过程中途径的点进行了色彩的标注,实现了对BST中典型算法进行动态的模拟演示,帮助初学者理解在算法执行过程中各种要素的变化状态,将BST的学习中大量的理论性概念、算法数据和模型直观而且...
  • 除了 大数据之外其他的知识图谱都是应该要学会并了解,其中有一些是重点掌握的模块(标注了红色外框),比如 Java基础、Java集合(绿框的是线程安全的)、JVM、算法数据结构,数据库中的Mysql、Spring、Redis。...
  • 结巴分词(java版)只保留的原项目针对搜索引擎分词的功能(cut_for_index、cut_for_search),词性标注,关键词提取没有实现(今后如用到,可以考虑实现)。 * 简介 ** 支持分词模式 - Search模式,用于对用户查询词...
  • Java并发编程实战

    2013-06-20 16:49:53
    Java并发编程实战 本书深入浅出地介绍了Java线程和并发,是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发,介绍了如何使用类库提供的基本并发构建块,用于避免并发危险...附录A 并发性标注289
  • java 面试题 总结

    2009-09-16 08:45:34
    Int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。 原始类型封装类 booleanBoolean charCharacter byteByte shortShort intInteger longLong floatFloat doubleDouble ...
  • Java EE常用框架.xmind

    2020-06-19 16:08:35
    1,targetEntity 属性表示默认关联的实体类型,默认为当前标注的实体类。 2,cascade属性表示与此实体一对一关联的实体的级联样式类型。 3,fetch属性是该实体的加载方式,默认为即时加载EAGER 4,optional属性...
  • 简历投递邮箱:xiaoxingqiang#zhihu.com #换成 @ 标注渠道来源哈NLP 算法开发工程师 待遇:25k 以上 具体根据能力面议职位描述:1、负责分词和词性标注,实体识别与消歧,关键词抽取,语义表示与文本相似度;...
  • 做智能问答时,算法是必不可少的一个环节,但是怎么验证算法的准确性是个问题,比如,我需要一个可以验证句子合理性的算法,但是需要两种标注好的数据,一种是合理的句子,一种是不合理的句子。合理的句子很好找,...
  • 25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................
  •  3.1.4 基本数据的拆、装箱操作(autoboxing和unboxing) 32  3.2 枚举 34  3.2.1 枚举的实现原理 34  3.2.2 枚举的简单应用 36  3.2.3 枚举的高级特性 37  3.3 反射 39  3.3.1 反射的基石——class类 ...
  • 25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................
  • Int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。 原始类型 封装类 boolean Boolean char Character byte Byte short Short int Integer long Long float Float double ...

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

java数据标注算法

java 订阅