二进制堆及其应用，数据结构课程设计（C++）

二进制堆及其应用 【问题描述】 堆是设计很巧妙的数据结构，堆排序的算法也有很多应用。但当堆比较庞大时，选取堆顶元素及重新建堆的工作量也较大。利用堆的定义构建二进制堆，应用于优先队列有很大的优势。二进制堆是在二进制树Bk上建立的数据结构。一个整数可以表示为二进制数，一组关键字组成的序列可以由一组二进制堆表示。 【设计要求】 设计基于STL框架的二进制堆的抽象数据类型及其实现。 （1）实现二进制堆Hk的ADT。 （2）应用基本运算，实现二进制堆的简单应用。

JAVA数据结构 用栈替换所有与pattern匹配的子树为bitree

问题：改了很多次，左边的树不匹配，但是右边的树匹配，怎么回到左节点看接下来的树是否匹配啊！问题应该在replaceALL方法里。   ``` //10-24 以中根和后根遍历序列构造二叉树，替换所有与pattern匹配的子树为bitree。 public class BinaryTree<T> { public BinaryNode<T>root; public BinaryTree() { this.root = null; } public boolean isEmpty() //判断是否是空 { return this.root == null; } public String toString()//输出带空子树先跟序列 { return toString(this.root); } public String toString(BinaryNode<T>p) { if(p==null) return "^"; return p.data.toString()+""+toString(p.left)+toString(p.right); } public BinaryTree(T inlist[],T postlist[]) { this.root=BinaryTreecreate(inlist,0,inlist.length-1,postlist,0,postlist.length-1); } //由后根遍历的次序可知，该二叉树的根是potlist[n-1]；改节点必定在中根次序中 //由中根遍历次序可知，Inlist[i]节点前段节点在根的左子树上，inlist[i]后的所有节点在根节点的右子树上 private BinaryNode<T> BinaryTreecreate(T[] inlist, int inbegin, int inend, T[] postlist, int postbegin, int postend) { if (postbegin < 0 || inbegin > inend) //递归结束条件 return null; BinaryNode<T> p = new BinaryNode<T>(postlist[postend]); int j = inbegin; //标记查找到的根结点的位置 while (j <= inend&&inlist[j] != postlist[postend]) { //遍历查找 j++; } p.left = BinaryTreecreate(inlist, inbegin, j - 1, postlist, postbegin, postbegin + j - inbegin - 1); //递归构造左子树 p.right = BinaryTreecreate(inlist, j + 1, inend, postlist, postbegin + j - inbegin, postend - 1); ////递归构造右子树 return p; } public BinaryTree(T[] prelist)//构造二叉树，prelist数组指定二叉树标明空子树的先根遍历序列 { this.root=create(prelist); } //以从i开始的标明空子树的先根序列，创建一颗以prelist[i]为根的子树，返回根结点，递归方法 private int i=0; private BinaryNode<T>create(T[] prelist) { BinaryNode<T>p=null; if(i<prelist.length) { T elem=prelist[i]; i++; if(elem!=null) //不能elem!="kong",因为T不一定是String { p=new BinaryNode<T>(elem); //创建叶子结点 p.left=create(prelist); //创建P的左子树，递归调用 p.right=create(prelist); //创建P的右子树，递归调用 } } return p; } //比较 public boolean equals(BinaryNode<T> p,BinaryNode<T> q) { return (p==null&&q==null)||(p!=null&&q!=null)&&(q.data.equals(p.data))&& equals(p.left,q.left)&&equals(p.right,q.right); } //对象复制 BinaryTree(BinaryTree<T> bitree) //实现BinaryTree<T>二叉树类声明的深拷贝构造方法 { this.root = copy(bitree.root); } private BinaryNode<T> copy(BinaryNode<T> p) //方法实现 { BinaryNode<T> q = null; if (p != null) { q = new BinaryNode<T>(p.data); q.left = copy(p.left); q.right = copy(p.right); } return q; } public void replaceAll(BinaryTree<T> pattern, BinaryTree<T> bitree) { if(equals(pattern)) this.root=this.copy(bitree.root); else ** this.replaceall(this.root,pattern.root,bitree.root); ** //可不写 } **_ public void replaceall(BinaryNode<T> p,BinaryNode<T> pattern,BinaryNode<T> bitree) //parent指向this的结点；pattern指向pattern的结点；bitree指向bitree的结点； { //parent指向this的结点；p指向pattern的结点；m指向bitree的结点； System.out.print("替换后："); //优先遍历的非递归算法 P154 LinkedStack<BinaryNode<T>>stack=new LinkedStack<BinaryNode<T>>();//创建的这个空栈为链式栈，使用单链表存储数据且实现栈接口 P91 while(p!=null||!stack.isEmpty())//P非空或栈非空时 { if( p!= null&&pattern!=null) { if(this.equals(p.left, pattern)) { // System.out.print(pattern); p.left=this.copy(bitree); // stack.push(p); // p=p.left; } if(this.equals(p.right, pattern)) { // System.out.print(pattern); p.right=this.copy(bitree); p=stack.pop(); // p=p.right; } else { // // System.out.print(p.data); stack.push(p); p=p.left; } } //p==null&&! if(stack.isEmpty()||p==null) { // // System.out.print("^"); // p=stack.pop(); // P指向出栈结点 if(stack.isEmpty()) ** p=p.right; // 进入右子树** else if (p==null) { p = stack.pop(); p = p.right; } } // System.out.print(""); //} } }**_ public static void main(String args[]) { String[] parent={"A","B","D",null,"G",null,null,"D",null,"G",null,null,"C","E",null,null,"F","H",null,null,"D",null,"G"}; String[] inlist={"D","G","B","A","E","C","H","F"}; //中根次序 String[] postlist={"G","D","B","E","H","F","C","A"}; //后根次序 String[] pattern1={"D",null,"G"}; String[] bitree1={"M","D",null,"G"}; BinaryTree<String> values=new BinaryTree<String>(parent); BinaryTree<String> pattern=new BinaryTree<String>(pattern1); BinaryTree<String> bitree=new BinaryTree<String>(bitree1); BinaryTree<String> tree=new BinaryTree<String>(inlist,postlist); System.out.println("构造出来的二叉树以先根次序输出为："+tree); System.out.println("替换前树values的序列： "+values); //输出替换前树values的序列 System.out.println("pattern序列： "+pattern); System.out.println("bitree序列： "+bitree); ** values.replaceAll(pattern,bitree); //替换** // System.out.print(values); //System.out.println("替换后树values的序列： "+values); //输出替换后树values的序列 } } ```

二叉树后序遍历非递归算法 运行有问题！ 求解答~ 谢啦

/** 二叉树后序遍历非递归算法(有问题) 分析： a(flag=1)，只遍历完左子树，右子树尚未遍历，则该结点不出栈，利用栈顶结点找到它的右子树，准备遍历 b(flag=2)，遍历完右子树，将该结点出栈，并访问它 */ struct BiNode{ char data; BiNode *lchild,*rchild; }; struct Element{ BiNode *bt; int flag; }; void postOrder2(BiNode *bn){ int top=-1; Element s[20];///假定不会发生上溢 while(bn!=NULL||top!=-1){///两个条件都不成立才退出循环 while(bn!=NULL){ top++; s[top].bt=bn; s[top].flag=1;///结点连同标志位一起入栈 bn=bn->lchild; } while(top!=-1&&s[top].flag==2){ bn=s[top--].bt; cout<<bn->data; } if(top!=-1){ s[top].flag=2; bn=s[top].bt->rchild; } } }

基于哈夫曼树的数据压缩算法

A 基于哈夫曼树的数据压缩算法 时间限制(C/C++):1000MS/3000MS 运行内存限制:65536KByte 总提交:445 测试通过:131 描述 输入一串字符串，根据给定的字符串中字符出现的频率建立相应哈夫曼树，构造哈夫曼编码表，在此基础上可以对待压缩文件进行压缩（即编码），同时可以对压缩后的二进制编码文件进行解压（即译码）。 输入 多组数据，每组数据一行，为一个字符串（只考虑26个小写字母即可）。当输入字符串为“0”时，输入结束。 输出 每组数据输出2n+4行（n为输入串中字符类别的个数）。第一行为统计出来的字符出现频率（只输出存在的字符，格式为：字符：频度），每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第二行至第2n行为哈夫曼树的存储结构的终态（形如教材139页表5.2（b），一行当中的数据用空格分隔）。第2n+2行为每个字符的哈夫曼编码（只输出存在的字符，格式为：字符：编码），每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第2n+3行为编码后的字符串，第2n+4行为解码后的字符串（与输入的字符串相同）。 样例输入 aaaaaaabbbbbccdddd aabccc 0 样例输出 a:7 b:5 c:2 d:4 1 7 7 0 0 2 5 6 0 0 3 2 5 0 0 4 4 5 0 0 5 6 6 3 4 6 11 7 2 5 7 18 0 1 6 a:0 b:10 c:110 d:111 00000001010101010110110111111111111 aaaaaaabbbbbccdddd a:2 b:1 c:3 1 2 4 0 0 2 1 4 0 0 3 3 5 0 0 4 3 5 2 1 5 6 0 3 4 a:11 b:10 c:0 111110000 aabccc

C++ 数据结构 创建一个二叉树，广度优先遍历。为啥结果不正确？

创建一个二叉树，广度优先遍历。 照着书上写的，但结果不对（正确结果是输入什么输出什么） ``` /*广度优先算法*/ #include<iostream> #include<queue> using namespace std; void visit(char x) { cout<<x<<" "; } template<class T> class BinaryTreeNode{ private: T data; BinaryTreeNode<T>* leftchild; BinaryTreeNode<T>* rightchild; public: BinaryTreeNode() { leftchild=NULL; rightchild=NULL; } BinaryTreeNode(T _data) { data=_data; } BinaryTreeNode(T _data,BinaryTreeNode<T>* left=NULL,BinaryTreeNode<T>* right=NULL) { data=_data; leftchild=left; rightchild=right; } BinaryTreeNode<T>* getLeftChild()const { return leftchild; } BinaryTreeNode<T>* getRightChild()const { return leftchild; } void setLeftChild(BinaryTreeNode<T>* l) { leftchild=l; } void setRightChild(BinaryTreeNode<T>* r) { rightchild=r; } T getvalue()const { return data; } void setvalue(const T& x) { data=x; } bool isLeaf()const { if(leftchild==NULL&&rightchild==NULL) return true; else return false; } }; template<class T> class BinaryTree{ private: BinaryTreeNode<T>* root; public: BinaryTree(BinaryTreeNode<T>* _root) { root=_root; } void deleteBinaryTree(BinaryTreeNode<T>* root) { if (root->getLeftChild()!= NULL) deleteBinaryTree(root->getLeftChild()); if (root->getRightChild()!= NULL) deleteBinaryTree(root->getRightChild()); delete root; root = NULL; } bool isEmpty()const { if(root==NULL) return true; else return false; } BinaryTreeNode<T>* getRoot()const { return root; } void levelOrder(BinaryTreeNode<T>* root)//广度优先遍历 { using std::queue; queue<BinaryTreeNode<T> *> aQueue; BinaryTreeNode<T>* pointer=root; if(pointer) aQueue.push(pointer); while(!aQueue.empty()) { pointer=aQueue.front(); aQueue.pop(); visit(pointer->getvalue()); if(pointer->getLeftChild()!=NULL) aQueue.push(pointer->getLeftChild()); if(pointer->getRightChild()!=NULL) aQueue.push(pointer->getRightChild()); } } }; //按照前序顺序建立二叉树 BinaryTreeNode<char>* creatBinaryTree() { BinaryTreeNode<char> * temp=new BinaryTreeNode<char>; char c; cout<<"按照前序顺序输入要建立的二叉树"<<endl; cin>>c; if(c=='#')//当遇到#时，令树的根节点为NULL，从而结束该分支的递归 temp=NULL; else { temp->setvalue(c); temp->setLeftChild(creatBinaryTree()); temp->setRightChild(creatBinaryTree()); } return temp; } int main() { BinaryTreeNode<char> * root=creatBinaryTree(); BinaryTree<char> B(root); cout<<"广度优先遍历的输出顺序为："<<endl; B.levelOrder(root); } ```

递归调用循环的非递归形式

背景：之前在算法书上看到说所有的递归算法都可以写成非递归的形式。 那么遍历一个完全树的所有叶子节点，我看过两个算法，一个是递归调用，非常简单。 还有一个使用了队列：(c++ 和伪代码的混合表示) queue.push(root);//根节点进队 while (!queue.isEmpty()) { queue.push(root->left); queue.push(root->right); if (!queue.top()->hasChild()) { print queue.top()->data; } queue.pop(); } 上面的算是非递归形式。 不过我想问的是，是不是说一定需要队列或者堆栈这样的辅助数据结构才能解决该问题？ 因为我觉得之前的一些递归算法改成的非递归算法都没有用到什么数据结构。 比如合并排序的非递归形式。用到的仅仅是两个向量而已。 我一直认为递归算法改成非递归形式是有一定的模板可循的。如果辅助数据结构不可避免，是不是意味着所有的递归算法只是理论上可以写成递归形式，至于写不写的出来，还要看个人的数据结构水平？

应用在子树上的数据结构的查询的算法，利用C语言的程序设计的方式来实现？

Problem Description bobo has a tree, whose vertices are conveniently labeled by 1,2,…,n. At the very begining, the i-th vertex is assigned with weight wi. There are q operations. Each operations are of the following 2 types: Change the weight of vertex v into x (denoted as "! v x"), Ask the total weight of vertices whose distance are no more than d away from vertex v (denoted as "? v d"). Note that the distance between vertex u and v is the number of edges on the shortest path between them. Input The input consists of several tests. For each tests: The first line contains n,q (1≤n,q≤105). The second line contains n integers w1,w2,…,wn (0≤wi≤104). Each of the following (n - 1) lines contain 2 integers ai,bi denoting an edge between vertices ai and bi (1≤ai,bi≤n). Each of the following q lines contain the operations (1≤v≤n,0≤x≤104,0≤d≤n). Output For each tests: For each queries, a single number denotes the total weight. Sample Input 4 3 1 1 1 1 1 2 2 3 3 4 ? 2 1 ! 1 0 ? 2 1 3 3 1 2 3 1 2 1 3 ? 1 0 ? 1 1 ? 1 2 Sample Output 3 2 1 6 6

数据结构C语言版二叉树的问题。

**strong text** #include "stdio.h" #include "malloc.h" #include "stdlib.h" #include "conio.h" #define stacksize 100 #define DataType char //便于后期修改。可以直接去修改char 类型来达到快速的修改，在程序长的情况下。 typedef struct node//二叉树的结构体定义 { DataType data; struct node *l; struct node *r; }node,*bitree; typedef struct Node //线索二叉树的结构体定义 { DataType data; int ltag; int rtag; struct Node *l; struct Node *r; }BiTNode,*tree; typedef struct //盏的结构体定义 { DataType zhan[stacksize]; int top; }wode; void initstack(wode *s) //初始化盏 { s->top=-1; } void CreateBiTree(bitree *bt) //二叉树的建立二叉链表方法 //创建的二叉树是不可见的，没成功？ { char ch; ch = getchar(); if(ch=='.') bt=NULL; else { *bt=(bitree)malloc(sizeof(bitree)); //生成一个新结点 (*bt)->data=ch; CreateBiTree(&(*(bt))->l); //生成左子树 CreateBiTree(&(*(bt))->r); //生成右子树 } printf("建立完成"); return; } void Visit(char ch)//访问节点 { printf("%c ",ch); } void preorder(bitree root)//以先序的遍历序列来输出二叉树 { if(root!=NULL) { printf("先序输出二叉树"); printf("%c",root->data); preorder(root->l); preorder(root->r); } } void inorder(bitree root)//中序遍历二叉树 { if(root!=NULL) { printf("中序遍历二叉树序列"); inorder(root->l); Visit(root->data); inorder(root->r); } } void postorder(bitree root)//后序遍历二叉树 { if(root!=NULL) { printf("后序遍历二叉树序列"); postorder(root->l); postorder(root->r); Visit(root->data); } } void printfpreorder(bitree root)//二叉树先序输出叶子节点 { printf("二叉树先序输出叶子节点"); if(root!=NULL) { if(root->l==NULL&&root->r==NULL) //判断条件左右子树为空 printf("%c",root->data); printfpreorder(root->l); printfpreorder(root->r); } } void leaf(bitree root) //后序遍历二叉树的叶子节点输出 { printf("后序遍历二叉树的叶子节点输出"); int n; if(root!=NULL) { leaf(root->l); leaf(root->r); if(root->l==NULL&&root->r==NULL) //判断条件 n++; } } int posttreedepth(bitree root)//后序遍历二叉树的深度递归算法 { printf("后序遍历二叉树的深递归算法"); int hl,hr,max; if(root!=NULL) { hl=posttreedepth(root->l); hr=posttreedepth(root->r); max=hl>hr?hl:hr; return(max+1); } else return(0); } int pretreedepth(bitree root,int h) //先序遍历二叉树的深度的递归算法 { printf("先序遍历二叉树深度的递归算法"); int depth; if(root!=NULL) { if(h>depth) depth=h; pretreedepth(root->l,h++); pretreedepth(root->r,h++); } return(depth); } void Inorder(bitree root)//中序遍历的非递归算法 { printf("中序遍历的非递归算法"); int top=0; bitree p; bitree s[stacksize]; int m; m=stacksize-1; p=root; do{ while(p!=NULL) { if(top>m) return; top=top+1; s[top]=p; p=p->l; } if(top!=0) { p=s[top]; top=top-1; Visit(p->data); p=p->r; } } while(p!=NULL||top!=0); } void inthred(tree root) //二叉树的中序线索化 { printf("二叉树的中序线索化"); tree pre; if(root!=NULL) { inthred(root->l); if(root->l==NULL) { root->ltag=1;root->l=pre; } if(pre!=NULL&&pre->r==NULL) { pre->r=root; pre->rtag=1; } pre=root; inthred(root->r); } } BiTNode *inpre(tree p)//中序线索化后找节点的前驱 { printf("中序线索化后找节点的前驱"); tree pre,q; if(p->ltag==1) pre=p->l; else { for(q=p->l;q->rtag==0;q=q->r); pre=q; } return(pre); } BiTNode *innext(tree p)//在中序线索二叉树里找节点的后继 { printf("在中序线索二叉树中找节点的后继"); tree next,q; if(p->ltag==1) next=p->l; else { for(q=p->r;q->ltag==0;q=q->l); next=q; } return(next); } BiTNode *infirst(tree root)//在中序线索二叉树中找第一个节点 { printf("在中序线索二叉树中找第一个节点"); BiTNode *p=root; if(!p) return(NULL); while(p->ltag==0) p=p->l; return p; } void tinorder(tree root)//遍历中序线索二叉树 { printf("遍历中序线索二叉树"); BiTNode *p; p=infirst(p); while (p) { printf("%c ",p->data); p=innext(p); } } void main() { int m; int h=0; bitree bt; tree root; CreateBiTree(&bt); for(;;) { printf("请输入数子来选择你想要的功能\n"); printf("数字为----1-------时 建立二叉树\n"); printf("数字为----2-------时 先序遍历输出二叉树\n"); printf("数字为----3------时 中序遍历二叉树\n"); printf("数字为-----4------时 后序遍历二叉树\n"); printf("数字为------5------时 二叉树先序输出叶子节点\n"); printf("数字为------6-------时 后序遍历二叉树输出节点\n"); printf("数字为-------7------时 后序遍历二叉树的深度\n"); printf("数字为-------8--------时 先序遍历二叉树的深度\n"); printf("数字为------9------时 中序遍历的非递归算法\n"); printf("数字为-----10时 中序遍历线索化\n"); printf("数字为-------11------时 中序遍历线索化后找节点的前驱\n"); printf("数字为------12------时 中序线索化后找后继\n"); printf("数字为-------13------时 中序线索二叉树找第一个节点\n"); printf("数字为------14-----时 遍历中序线索二叉树\n"); printf("\n\n请输入 (1--14) 的数字"); scanf_s("%d",&m); if(m>=2&&m<=14) { switch (m) { case 2:(bt); break; //先序遍历输出二叉树 case 3:inorder(bt); break; //中序遍历二叉树 case 4:postorder(bt); break; case 5:printfpreorder(bt); break; //二叉树先序输出叶子节点 case 6:leaf(bt); break; //后序遍历二叉树输出节点 case 7:posttreedepth(bt); break; //后序遍历二叉树的深度 case 8:pretreedepth(bt,h); break; //先序遍历二叉树的深度 case 9:Inorder(bt); break; //中序遍历的非递归算法 case 10:inthred(root); break; //中序遍历的线索化 case 11:BiTNode *inpre(tree p); break; //中序线索化后找节点的前驱 case 12: *innext(root); break; //中序线索二叉树找后继 case 13:BiTNode *infirst(tree root); break; //中序线索二叉树找第一个节点 case 14:tinorder(root); break; //遍历中序线索二叉树 case 0: exit(0); break; } printf("\n\n操作完毕，请再次选择！"); } else printf("\n\n选择错误，请再次选择！"); } } 这串代码在vs2012 上有错误，但我是一个新手不太明白，求大神解答，谢谢了。

求助，数据结构二叉树问题

试编写算法，求给定二叉树上从根结点到叶子结点的一条其路径长度等于树的深度减一的路径（即列出从根结点到该叶子结点的结点序列），若这样的路径存在多条，则输出路径终点（叶子结点）在“最左”的一条。

一个关于B树的删除问题

今天碰巧看到数据结构与算法中的B树，结果发现了一个问题，3阶B树如下：  现在需要删除右下角的4节点，按照书上讲的，此时右节点关键字个数恰好等于【m/2-1应该合并其和右兄弟节点和父节点。可是此时会产生两个空缺，分别是父节点和左孩子（原本4的位置），所以这个时候就不知道咋做了，有没有大神帮个忙做一下这个题，实在是不知道咋做，谢谢各位了！

编写算法对以孩子链表表示的树以广义表表示

不能上图：A(B(D,E,F),C(G,H)) 广义表表示，请编写算法输出其广义表 c语言实现

求一个c++程序时至13点

二叉树相关算法的实验验证 [实验目的] 验证二叉树的链接存储结构及其上的基本操作。 [实验内容及要求] 1、 定义链接存储的二叉树类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建一棵二叉树，并对其初始化； 2）先根、中根、后根遍历二叉树； 3）在二叉树中搜索给定结点的父结点； 4）搜索二叉树中符合数据域条件的结点； 3、 由教师随机指定树结构，测试上述功能；

[C++数据结构]自己按书中代码打了一个二叉查找树模板类，发现不能在树上正常插入元素

以下代码分为一个头文件和一个.cpp文件，可复制粘贴直接运行，头文件记得命名为BST.h 我的运行环境是vs2017，编译没有出错，插入函数也是照书中代码一点点打的，保证没有抄错。但是无法正常插入，麻烦大佬们花两分钟帮忙看看，是不是代码的错，在下C++才学一年，希望能大家能多指教，非常感谢！ 代码出自《数据结构与算法分析 C++语言描述 第2版》Larry Nyhoff著 清华大学出版社 第600页 ``` /* 头文件名字如下： BST.h 这是一个二叉查找树模板类，我只定义了元素插入二叉树的函数 代码出自《数据结构与算法分析 C++语言描述 第2版》Larry Nyhoff著 第600页 保证没有抄错，大佬们可以直接复制粘贴到编译器中执行 后面有测试的test.cpp文件,也可以直接复制粘贴 */ #include <iostream> #include <new>//我不知道该头文件的用处，书上是这么写的 using namespace std; #ifndef BINARY_SEARCH_TREE_H #define BINARY_SEARCH_TREE_H template <typename DataType> class BinarySearchTree { private: /*节点类*/ class BinNode { public: DataType data; BinNode * left; BinNode * right; BinNode() :left(0),right(0){} BinNode(DataType item) :data(item), left(0), right(0) {} };//节点类声明结束 typedef BinNode * BinNodePointer;//用BinNodePointe来代替BinNode * //类成员 BinNode * myRoot; public: BinarySearchTree();//构造 void insert(const DataType & item)const;//插入 private: void insertAux(BinNodePointer subtreeRoot, const DataType & item)const;//插入辅助函数 };//模板类声明结束 //以下是函数定义 //构造 template <typename DataType> inline BinarySearchTree<DataType>::BinarySearchTree():myRoot(0){} //插入 template<typename DataType> inline void BinarySearchTree<DataType>::insert(const DataType & item) const { insertAux(myRoot, item); } //插入辅助函数定义，用了递归 template<typename DataType> void BinarySearchTree<DataType>::insertAux( BinarySearchTree<DataType>::BinNodePointer subtreeRoot, const DataType & item) const { if (subtreeRoot == 0){ subtreeRoot = new BinarySearchTree<DataType>::BinNode(item); cout<<"xxx\n";//之后用for循环测试是否插入成功，如果成功只显示一次，失败显示n次。 } else if (item < subtreeRoot->data)//左子树 insertAux(subtreeRoot->left, item); else if (subtreeRoot->data)//右子树 insertAux(subtreeRoot->right, item); else cerr << "Item already in the tree\n"; } #endif ``` 下面是测试用的main函数 ``` #include <iostream> #include "BST.h" using namespace std; int main() { BinarySearchTree<int> bst; //测试插入函数 int number; for (number=0;;) { number++; if (number == 999)break; bst.insert(number); }//如果一直是空树的话会不断的输出"xxx" return 0; } ```

请问如何用用java语言实现IP地址字典树？谢谢

用java语言实现IP地址字典树 字典树，又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 字典树示例： 字典树的基本性质： （1）根节点不包含字符，除根节点外每一个节点都只包含一个字符； （2）从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串； （3）每个节点的所有子节点包含的字符都不相同。 字典树的基本操作有：查找、插入和删除, 搜索字典项目的方法为： （1）从根结点开始一次搜索； （2）取得要查找关键词的第一个字母，并根据该字母选择对应的子树并转到该子树继续进行检索； （3）在相应的子树上，取得要查找关键词的第二个字母,并进一步选择对应的子树进行检索。 （4）迭代过程…… （5）在某个结点处，关键词的所有字母已被取出，则读取附在该结点上的信息，即完成查找。 根据字典树的上述特性，设计一种字典树，实现下列要求： （1）该字典树能够实现对IP地址的查找。IP地址采用点分形式表示，如：192.168.1.1，即字典树每个节点只能包含0-9和”.”十一个字符中的一个。 （2）该字典树具有插入和查找和统计的功能 （3）用一组IP地址（期中一些IP地址以192开始）初始化该字典树 （4）在该字典树中查找以192开始的IP地址的个数，并打印出查找结果。 （5）查找10.10.10.10是否在该字典数据中存在，并打印出查找结果。

hihocoder 1014的相关问题

大家好，想请教大家关于hihocoder 1014的相关问题 问题描述： /*时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Hi和小Ho是一对好朋友，出生在信息化社会的他们对编程产生了莫大的兴趣，他们约定好互相帮助，在编程的学习道路上一同前进。 这一天，他们遇到了一本词典，于是小Hi就向小Ho提出了那个经典的问题：“小Ho，你能不能对于每一个我给出的字符串，都在这个词典里面找到以这个字符串开头的所有单词呢？” 身经百战的小Ho答道：“怎么会不能呢！你每给我一个字符串，我就依次遍历词典里的所有单词，检查你给我的字符串是不是这个单词的前缀不就是了？” 小Hi笑道：“你啊，还是太年轻了！~假设这本词典里有10万个单词，我询问你一万次，你得要算到哪年哪月去？” 小Ho低头算了一算，看着那一堆堆的0，顿时感觉自己这辈子都要花在上面了... 小Hi看着小Ho的囧样，也是继续笑道：“让我来提高一下你的知识水平吧~你知道树这样一种数据结构么？” 小Ho想了想，说道：“知道~它是一种基础的数据结构，就像这里说的一样！” 小Hi满意的点了点头，说道：“那你知道我怎么样用一棵树来表示整个词典么？” 小Ho摇摇头表示自己不清楚。 提示一：Trie树的建立 “你看，我们现在得到了这样一棵树，那么你看，如果我给你一个字符串ap，你要怎么找到所有以ap开头的单词呢？”小Hi又开始考校小Ho。 “唔...一个个遍历所有的单词？”小Ho还是不忘自己最开始提出来的算法。 “笨！这棵树难道就白构建了！”小Hi教训完小Ho，继续道：“看好了！” 提示二：如何使用Trie树 提示三：在建立Trie树时同时进行统计！ “那么现在！赶紧去用代码实现吧！”小Hi如是说道 输入 输入的第一行为一个正整数n，表示词典的大小，其后n行，每一行一个单词（不保证是英文单词，也有可能是火星文单词哦），单词由不超过10个的小写英文字母组成，可能存在相同的单词，此时应将其视作不同的单词。接下来的一行为一个正整数m，表示小Hi询问的次数，其后m行，每一行一个字符串，该字符串由不超过10个的小写英文字母组成，表示小Hi的一个询问。 在20%的数据中n, m<=10，词典的字母表大小<=2. 在60%的数据中n, m<=1000，词典的字母表大小<=5. 在100%的数据中n, m<=100000，词典的字母表大小<=26. 本题按通过的数据量排名哦～ 输出 对于小Hi的每一个询问，输出一个整数Ans,表示词典中以小Hi给出的字符串为前缀的单词的个数。 样例输入 5 babaab babbbaaaa abba aaaaabaa babaababb 5 babb baabaaa bab bb bbabbaab 样例输出 1 0 3 0 0*/ 我的代码： #include <stdio.h> #include <stdlib.h> struct trie { int num; struct trie *data[26]; }*p; void trie1(struct trie *x) { int i; x->num = 0; for(i = 0; i < 26; i++) x->data[i] = NULL; } void insertTrie(char s[]) { int i; trie1(p); p->num++; for(i=0;s[i];i++) { int j = s[i] - 'a'; if(p->data[j] == NULL) { p->data[j] = (struct trie *)malloc(sizeof(struct trie)); trie1(p->data[j]); } p = p->data[j]; p->num++; } } int searchTrie(char s[]) { int i; //struct trie *q = root ; //trie1(p); for(i = 0; p&&s[i]; i++) { int j = s[i] - 'a'; p = p->data[j]; } if(!p) return 0; else return p->num; } int main() { char s[12]; int n, m; while(~scanf("%d", &n)) { //root = (struct Trie *)malloc(sizeof(struct trie)); while(n--) { scanf("%s", s); insertTrie(s); } scanf("%d", &m); while(m--) { scanf("%s", s); printf("%d\n", searchTrie(s)); } } return 0; } 不知道有什么问题啊，但是运行出错，希望各位大神帮我看看，谢谢！

求高手解答二进制堆及其应用问题

2、二进制堆及其应用 　　　【问题描述】 　　　堆是设计很巧妙的数据结构，堆排序的算法也有很多应用。但当堆比较庞大时，选取堆顶元素及重新建堆的工作量也较大。利用堆的定义构建二进制堆，应用于优先队列有很大的优势。二进制堆是在二进制树Bk上建立的数据结构。一个整数可以表示为二进制数，一组关键字组成的序列可以由一组二进制堆表示。 　　　【设计要求】 　　　设计二进制堆的抽象数据类型及其实现。 　　（1）实现二进制堆Hk的ADT。 　　（2）实现二进制堆的简单应用。 以上是我的作业题，我没看懂这个具体是要做什么，怎么做。求高手们给讲解一下，越详细越好。 谢谢啦~~~

如何用大小根交替堆实现双端优先队列？

双端优先队列是一个支持如下操作的数据结构： •Insert (S, x) – 将元素x插入集合S •Extract –Min (S) –删除S中的最小关键字 •Extract –Max (S) –删除S中的最大关键字 可用小大根交替堆来实现对上述三个操作的支持。小大根交替堆是一个满足如下小大根交替条件的完全二元树：如果该二元树不空，那么其上的每个元素都有一个称为关键字的域，且针对该关键字，二元树按层次形成了小大根交替的形式，即对于小大根交替堆中的任何一个结点x，如果x位于小根层次，那么x就是以x为根节点的二元树中键值最小的结点，并称该结点为一个小根结点。同样的道理，如果x位于大根层次，那么x就是以x为根节点的二元树中键值最大的结点，并称该结点为一个大根结点。在小大根交替堆中根结点位于小根层次。

关于HUFFMAN利用数组压缩的算法问题

整体代码如下，具体关于问题在最下方， struct head { unsigned char b; /*the charactor*/ long count; /*the frequency*/ long parent,lch,rch; /*make a tree*/ char bits[256]; /*the haffuman code*/ } header[512],tmp; void compress() { clock_t start,end; char filename[255],outputfile[255],buf[512]; int fn = 0, sz = 0, sz1 = 0; double x = 0; unsigned char c; long i,j,m,n,f; long min1,pt1,flength; FILE *ifp,*ofp; printf("源文件名:"); gets_s(filename); ifp=fopen(filename,"rb"); if(ifp==NULL) { printf("源文件打开失败!\n"); return; } fn = _fileno(ifp); /*取得文件指针的底层流式文件号*/ sz = _filelength(fn);/*根据文件号取得文件大小*/ printf("文件大小为:%d B.\n", sz); sz1 = sz; printf("压缩后文件名:"); gets_s(outputfile); start=clock(); /* 计时开始 */ ofp=fopen(outputfile,"wb"); if(ofp==NULL) { printf("压缩文件打开失败!\n"); return; } flength=0; while(!feof(ifp)) { fread(&c,1,1,ifp);//读数据 header[c].count++; //字符重复出现频率+1 flength++; //字符出现原文件长度+1 } flength--; header[c].count--;//减一平衡位数 for(i=0;i<512;i++) { if(header[i].count!=0) header[i].b=(unsigned char)i; /*将每个哈夫曼码值及其对应的ASCII码存放在一维数组header[i]中， 且编码表中的下标和ASCII码满足顺序存放关系*/ else header[i].b=0; header[i].parent=-1; //对结点进行初始化 header[i].lch=header[i].rch=-1; } for(i=0;i<256;i++)//根据频率（权值）大小，对结点进行排序，选择较小的结点进树 { for(j=i+1;j<256;j++) { if(header[i].count<header[j].count) { tmp=header[i]; header[i]=header[j]; header[j]=tmp; } } } for(i=0;i<256;i++) if(header[i].count==0) break; n=i; m=2*n-1; //外部叶子结点数为n个时，内部结点数为n-1，整个哈夫曼树的需要的结点数为2*n-1. for(i=n;i<m;i++)//构建哈夫曼树 { min1=999999999; for(j=0;j<i;j++) { if(header[j].parent!=-1) continue;//parent!=-1说明该结点已存在哈夫曼树中，跳出循环重新选择新结点*/ if(min1>header[j].count) { pt1=j; min1=header[j].count;//找到最小值 continue; } } header[i].count=header[pt1].count; header[pt1].parent=i; //依据parent域值（结点层数）确定树中结点之间的关系 header[i].lch=pt1;//计算左分支权值大小 min1=999999999; for(j=0;j<i;j++) { if(header[j].parent!=-1) continue; if(min1>header[j].count) { pt1=j; min1=header[j].count; continue; } } header[i].count+=header[pt1].count; header[i].rch=pt1;//计算右分支权值大小 header[pt1].parent=i; } for(i=0;i<n;i++) //哈夫曼无重复前缀编码 { f=i; header[i].bits[0]=0;//根结点编码0 while(header[f].parent!=-1) { j=f; f=header[f].parent; if(header[f].lch==j) //置左分支编码0 { j=strlen(header[i].bits);//扫描长度 memmove(header[i].bits+1,header[i].bits,j+1);//由header复制j+ 1个到前者 //依次存储连接“0”“1”编码 header[i].bits[0]='0'; } else//置右分支编码1 { j=strlen(header[i].bits);//计算字符长度？ memmove(header[i].bits+1,header[i].bits,j+1); header[i].bits[0]='1'; } } } fseek(ifp,0,SEEK_SET);//从文件开始位置向前移动0字节，即定位到文件开始位置 fwrite(&flength,sizeof(int),1,ofp);/*用来将数据写入文件流中，参数flength指向欲写入的数据地址， 总共写入的字符数以参数size*int来决定，返回实际写入的int数目1*/ fseek(ofp,8,SEEK_SET); buf[0]=0; //定义缓冲区,它的二进制表示00000000 f=0; pt1=8; /*假设原文件第一个字符是"A"，8位2进制为01000001，编码后为0110识别编码第一个'0'， 那么我们就可以将其左移一位，看起来没什么变化。下一个是'1'，应该|1，结果00000001 同理4位都做完，应该是00000110，由于字节中的8位并没有全部用完，我们应该继续读下一个字符， 根据编码表继续拼完剩下的4位，如果字符的编码不足4位，还要继续读一个字符， 如果字符编码超过4位，那么我们将把剩下的位信息拼接到一个新的字节里*/ while(!feof(ifp)) { c=fgetc(ifp); f++; for(i=0;i<n;i++) { if(c==header[i].b) break; } strcat(buf,header[i].bits); j=strlen(buf); c=0; while(j>=8) //对哈夫曼编码位操作进行压缩存储 { for(i=0;i<8;i++) { if(buf[i]=='1') c=(c<<1)|1; else c=c<<1; } fwrite(&c,1,1,ofp); pt1++; //统计压缩后文件的长度 strcpy(buf,buf+8);//一个字节一个字节拼接 j=strlen(buf); } if(f==flength) break; } if(j>0) //对哈夫曼编码位操作进行压缩存储 { strcat(buf,"00000000"); for(i=0;i<8;i++) { if(buf[i]=='1') c=(c<<1)|1; else c=c<<1; } fwrite(&c,1,1,ofp); pt1++; } fseek(ofp,4,SEEK_SET); fwrite(&pt1,sizeof(long),1,ofp); fseek(ofp,pt1,SEEK_SET); fwrite(&n,sizeof(long),1,ofp); for(i=0;i<n;i++) { fwrite(&(header[i].b),1,1,ofp); c=strlen(header[i].bits); fwrite(&c,1,1,ofp); j=strlen(header[i].bits); if(j%8!=0) //若存储的位数不是8的倍数，则补0 { for(f=j%8;f<8;f++) strcat(header[i].bits,"0"); } while(header[i].bits[0]!=0) { c=0; for(j=0;j<8;j++) //字符的有效存储不超过8位，则对有效位数左移实现两字符编码的连接 { if(header[i].bits[j]=='1') c=(c<<1)|1; //|1不改变原位置上的“0”“1”值 else c=c<<1; } strcpy(header[i].bits,header[i].bits+8);// 把字符的编码按原先存储顺序连接 fwrite(&c,1,1,ofp); } } fclose(ifp); printf("压缩成功!\n"); end=clock(); /* 计时结束 */ fn = _fileno(ofp); /*取得文件指针的底层流式文件号*/ sz = _filelength(fn);/*根据文件号取得文件大小*/ printf("压缩后文件大小为:%d B.\n", sz); x = (sz / sz1)*1.0; printf("压缩率为:%d B.\n", x); fclose(ofp); printf("压缩用时%f秒\n",(double)(end - start) / CLOCKS_PER_SEC); return; } // 整体代码如上，请问下 关于找到最小值以后 header[i].count=header[pt1].count; header[pt1].parent=i; //依据parent域值（结点层数）确定树中结点之间的关系 header[i].lch=pt1;//计算左分支权值大小 哈夫曼生成的节点权重不应该两者之和么，这个对于双亲的赋值不是很懂，这种利用数组进行排序以后的这个操作不是很明白，这个i好像是顺序，但不是累加，怎么剔除以后去和剩下的节点比较啊。原来搞不明白这里怎么赋值的

用fscanf和fgets从文件读取数据存储到链表失败是为什么？？

我建立了链表结构，然后从文件导入数据，然后输出链表内容，发现输出的内容顺序不对内容也有点地方出错了！ （下面是代码） #include <iostream> #include<fstream> #include<stdlib.h> #include<string.h> #include<stdio.h> typedef struct node{ char question[200]; char option_A[50]; char option_B[50]; char option_C[50]; char option_D[50]; char answer[3]; char respond[3]; char analysis[200]; int length; struct node *next; }LNODE,*LinkList; int main(void) { LNODE *L; L=new LNODE; L->next=NULL; L->length=0; LNODE *p; LNODE *q; q=L; int i; FILE *tk; if((tk=fopen("//Users//apple//Documents//Test System//test question.txt","r"))==NULL) { printf("File open error!\n"); exit(0); } while(!feof(tk)) { fgets(q->question,sizeof(LNODE),tk); fgets(q->option_A,sizeof(LNODE),tk); fgets(q->option_B,sizeof(LNODE),tk); fgets(q->option_C,sizeof(LNODE),tk); fgets(q->option_D,sizeof(LNODE),tk); fgets(q->answer,sizeof(LNODE),tk); fgets(q->analysis,sizeof(LNODE),tk); p=new LNODE; p->next=NULL; q->next=p; q=q->next; } if(fclose(tk)) { printf("Can not close the file!\n"); exit(0); } q=L; while(q->next) { printf("%s",q->question); printf("%s",q->option_A); printf("%s",q->option_B); printf("%s",q->option_C); printf("%s",q->option_D); printf("%s",q->answer); printf("%s",q->analysis); q=q->next; } } （这是文档里的内容） 在数据结构中，从逻辑结构上可以把数据结构分成（） A.动态结构和静态结构 B.紧凑结构和非紧凑结构 C.线性结构和非线性结构 D.内部结构和外部结构 C 略 与数据元素本身的形式，内容，相对位置，个数无关的是数据的（） A.存储结构 B.存储实现 C.逻辑结构 D.运算实现 C 略 通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（） A.数据具有同一特点 B.每个数据元素都一样 C.不仅每个数据元素所包含的数据项都一样，而且对应数据项的类型要一致 D.数据元素所包含的数据项的个数要相等 C 只有这样系统才能高效统一的对数据进行管理。 算法的时间复杂度取决于（） A.问题的规模 B.待处理的数据的初态 C.计算机的配置 D.A和B D 略 顺序表中第一个元素的储存地址是100，每个元素的长度为2，则第5个元素的地址是（） A.100 B.108 C.100 D.120 B 100+（5-1）*2==108 线性表若采用链式存储结构，要求内存中可用存储单元的地址（） A.部分是连续的 B.一定是不连续的 C.必须是连续的 D.连续或不连续都可以 D 因为链表有指针跟踪从而连不连续都可以。 用链接方式存储的队列，在进行删除运算时（） A.仅修改头指针 B.仅修改尾指针 C.头尾指针都一定要修改 D.头尾指针可能都要修改 D 一般只修改头指针，但是删除的结点若为最后一个时，则要重新对尾指针赋值。 一个递归算法必须包括（） A.递归部分 B.终止条件和递归部分 C.迭代部分 D.终止条件和迭代部分 D 略 串是一种特殊的线性表，其特殊性体现在（） A.可以顺序储存 B.可以链式储存 C.数据元素是单个字符 D.数据元素可以是多个字符 C 串是一种内容受限的线性表。 把一棵树转化为二叉树后，这棵二叉树的形态是（） A.唯一的 B.有多种 C.有多种，但根结点都没有左孩子 D.有多种，但根结点都没有右孩子 A 略。 利用二叉链表存储树，则根结点的右指针（） A.指向最左孩子 B.指向最右孩子 C.非空 D.为空 C 右指针指向兄弟结点。 在以下的存储形式中，不是树的存储形式的是（） A.双亲表示法 B.孩子链表表示法 C.孩子兄弟表示法 D.顺序存储表示法 D 常用孩子兄弟表示法转化为二叉树进行储存。 在一个无向图，所有顶点的度数之和等于图的边数的（）倍 A.1/2 B.1 C.2 D.4 A 略 折半查找与二叉排序树的时间性能（） A.相同 B.完全不同 C.有时不相同 D.数量级都是O（log2n） C 要看初始数据的状态。 堆的形状是一棵（） A.二叉排序树 B.满二叉树 C.完全二叉树 D.平衡二叉树 C 略 若一组记录的排序码为（46，79，56，38，40，84），则利用堆排序的方式建立的初始堆为（） A.79，46，56，38，40，84 B.84，79，56，38，40，46 C.84，79，56，46，40，38 D.84，56，79，40，46，38 C 画出图去找矛盾。 快速排序在下列（）最易发挥作用 A.被排序的数据中具有多个相同的排序码 B.被排序的数据已经基本有序 C.被排序的数据完全无序 D.被排序的数据中的最大值和最小值相差悬殊 C 完全无序时用快速排序。 （这是输出后的内容，第一行与原文档的根本不同，而且后面也有很多乱的错误的）  有哪位大神指导一下小白！！

爬虫福利二 之 妹子图网MM批量下载

爬虫福利一：27报网MM批量下载 点击 看了本文，相信大家对爬虫一定会产生强烈的兴趣，激励自己去学习爬虫，在这里提前祝：大家学有所成！ 目标网站：妹子图网 环境：Python3.x 相关第三方模块：requests、beautifulsoup4 Re：各位在测试时只需要将代码里的变量path 指定为你当前系统要保存的路径，使用 python xxx.py 或IDE运行即可。 ...

字节跳动视频编解码面经

三四月份投了字节跳动的实习（图形图像岗位），然后hr打电话过来问了一下会不会opengl，c++，shador，当时只会一点c++，其他两个都不会，也就直接被拒了。 七月初内推了字节跳动的提前批，因为内推没有具体的岗位，hr又打电话问要不要考虑一下图形图像岗，我说实习投过这个岗位不合适，不会opengl和shador，然后hr就说秋招更看重基础。我当时想着能进去就不错了，管他哪个岗呢，就同意了面试...

Java学习的正确打开方式

在博主认为，对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结，前三者博主将淋漓尽致地挥毫于这篇博客文章中，至于总结在于个人，实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍，博客次之，这又是一个层次了，这里暂时不提后面再谈。博主将为各位入门java保驾护航，各位只管冲鸭！！！上天是公平的，只要不辜负时间，时间自然不会辜负你。 何谓学习？博主所理解的学习，它是一个过程，是一个不断累积、不断沉淀、不断总结、善于传达自己的个人见解以及乐于分享的过程。

程序员必须掌握的核心算法有哪些？

由于我之前一直强调数据结构以及算法学习的重要性，所以就有一些读者经常问我，数据结构与算法应该要学习到哪个程度呢？，说实话，这个问题我不知道要怎么回答你，主要取决于你想学习到哪些程度，不过针对这个问题，我稍微总结一下我学过的算法知识点，以及我觉得值得学习的算法。这些算法与数据结构的学习大多数是零散的，并没有一本把他们全部覆盖的书籍。下面是我觉得值得学习的一些算法以及数据结构，当然，我也会整理一些看过...

linux系列之常用运维命令整理笔录

本博客记录工作中需要的linux运维命令，大学时候开始接触linux，会一些基本操作，可是都没有整理起来，加上是做开发，不做运维，有些命令忘记了，所以现在整理成博客，当然vi，文件操作等就不介绍了，慢慢积累一些其它拓展的命令，博客不定时更新 free -m 其中：m表示兆，也可以用g，注意都要小写 Men：表示物理内存统计 total：表示物理内存总数(total=used+free) use...

Python 基础（一）：入门必备知识

Python 入门必备知识，你都掌握了吗？

兼职程序员一般可以从什么平台接私活？

这个问题我进行了系统性的总结，以下将进行言简意赅的说明和渠道提供，希望对各位小猿/小媛们有帮助~ 根据我们的经验，程序员兼职主要分为三种：兼职职位众包、项目整包和自由职业者驻场。 所谓的兼职职位众包，指的是需求方这边有自有工程师配合，只需要某个职位的工程师开发某个模块的项目。比如开发一个 app，后端接口有人开发，但是缺少 iOS 前端开发工程师，那么他们就会发布一个职位招聘前端，来配合公司一...

程序员接私活怎样防止做完了不给钱？

首先跟大家说明一点，我们做 IT 类的外包开发，是非标品开发，所以很有可能在开发过程中会有这样那样的需求修改，而这种需求修改很容易造成扯皮，进而影响到费用支付，甚至出现做完了项目收不到钱的情况。 那么，怎么保证自己的薪酬安全呢？ 我们在开工前，一定要做好一些证据方面的准备（也就是“讨薪”的理论依据），这其中最重要的就是需求文档和验收标准。一定要让需求方提供这两个文档资料作为开发的基础。之后开发...

Python十大装B语法

Python 是一种代表简单思想的语言，其语法相对简单，很容易上手。不过，如果就此小视 Python 语法的精妙和深邃，那就大错特错了。本文精心筛选了最能展现 Python 语法之精妙的十个知识点，并附上详细的实例代码。如能在实战中融会贯通、灵活使用，必将使代码更为精炼、高效，同时也会极大提升代码B格，使之看上去更老练，读起来更优雅。

数据库优化 - SQL优化

以实际SQL入手，带你一步一步走上SQL优化之路！

2019年11月中国大陆编程语言排行榜

2019年11月2日，我统计了某招聘网站，获得有效程序员招聘数据9万条。针对招聘信息，提取编程语言关键字，并统计如下： 编程语言比例 rank pl_ percentage 1 java 33.62% 2 cpp 16.42% 3 c_sharp 12.82% 4 javascript 12.31% 5 python 7.93% 6 go 7.25% 7 p...

写了很久，这是一份最适合/贴切普通大众/科班/非科班的『学习路线』

说实话，对于学习路线这种文章我一般是不写的，大家看我的文章也知道，我是很少写建议别人怎么样怎么样的文章，更多的是，写自己的真实经历，然后供大家去参考，这样子，我内心也比较踏实，也不怕误导他人。 但是，最近好多人问我学习路线，而且很多大一大二的，说自己很迷茫，看到我那篇 普普通通，我的三年大学 之后很受激励，觉得自己也能行，（是的，别太浪，你一定能行）希望我能给他个学习路线，说...

经典算法（5）杨辉三角

写在前面： 我是 扬帆向海，这个昵称来源于我的名字以及女朋友的名字。我热爱技术、热爱开源、热爱编程。技术是开源的、知识是共享的。 这博客是对自己学习的一点点总结及记录，如果您对 Java、算法 感兴趣，可以关注我的动态，我们一起学习。 用知识改变命运，让我们的家人过上更好的生活。 目录一、杨辉三角的介绍二、杨辉三角的算法思想三、代码实现1.第一种写法2.第二种写法 一、杨辉三角的介绍 百度

腾讯算法面试题：64匹马8个跑道需要多少轮才能选出最快的四匹？

昨天，有网友私信我，说去阿里面试，彻底的被打击到了。问了为什么网上大量使用ThreadLocal的源码都会加上private static？他被难住了，因为他从来都没有考虑过这个问题。无独有偶，今天笔者又发现有网友吐槽了一道腾讯的面试题，我们一起来看看。 腾讯算法面试题：64匹马8个跑道需要多少轮才能选出最快的四匹？ 在互联网职场论坛，一名程序员发帖求助到。二面腾讯，其中一个算法题：64匹...

面试官：你连RESTful都不知道我怎么敢要你？

干货，2019 RESTful最贱实践

为啥国人偏爱Mybatis，而老外喜欢Hibernate/JPA呢？

关于SQL和ORM的争论，永远都不会终止，我也一直在思考这个问题。昨天又跟群里的小伙伴进行了一番讨论，感触还是有一些，于是就有了今天这篇文。 声明：本文不会下关于Mybatis和JPA两个持久层框架哪个更好这样的结论。只是摆事实，讲道理，所以，请各位看官勿喷。 一、事件起因 关于Mybatis和JPA孰优孰劣的问题，争论已经很多年了。一直也没有结论，毕竟每个人的喜好和习惯是大不相同的。我也看...

SQL-小白最佳入门sql查询一

不要偷偷的查询我的个人资料，即使你再喜欢我，也不要这样，真的不好；

项目中的if else太多了，该怎么重构？

介绍 最近跟着公司的大佬开发了一款IM系统，类似QQ和微信哈，就是聊天软件。我们有一部分业务逻辑是这样的 if (msgType = "文本") { // dosomething } else if(msgType = "图片") { // doshomething } else if(msgType = "视频") { // doshomething } else { // doshom...

致 Python 初学者

欢迎来到“Python进阶”专栏！来到这里的每一位同学，应该大致上学习了很多 Python 的基础知识，正在努力成长的过程中。在此期间，一定遇到了很多的困惑，对未来的学习方向感到迷茫。我非常理解你们所面临的处境。我从2007年开始接触 python 这门编程语言，从2009年开始单一使用 python 应对所有的开发工作，直至今天。回顾自己的学习过程，也曾经遇到过无数的困难，也曾经迷茫过、困惑过。开办这个专栏，正是为了帮助像我当年一样困惑的 Python 初学者走出困境、快速成长。希望我的经验能真正帮到你

“狗屁不通文章生成器”登顶GitHub热榜，分分钟写出万字形式主义大作

一、垃圾文字生成器介绍 最近在浏览GitHub的时候，发现了这样一个骨骼清奇的雷人项目，而且热度还特别高。 项目中文名：狗屁不通文章生成器 项目英文名：BullshitGenerator 根据作者的介绍，他是偶尔需要一些中文文字用于GUI开发时测试文本渲染，因此开发了这个废话生成器。但由于生成的废话实在是太过富于哲理，所以最近已经被小伙伴们给玩坏了。 他的文风可能是这样的： 你发现，

程序员：我终于知道post和get的区别

IT界知名的程序员曾说：对于那些月薪三万以下，自称IT工程师的码农们，其实我们从来没有把他们归为我们IT工程师的队伍。他们虽然总是以IT工程师自居，但只是他们一厢情愿罢了。 此话一出，不知激起了多少(码农)程序员的愤怒，却又无可奈何，于是码农问程序员。 码农：你知道get和post请求到底有什么区别？ 程序员：你看这篇就知道了。 码农：你月薪三万了？ 程序员：嗯。 码农：你是怎么做到的? 程序员：

《程序人生》系列-这个程序员只用了20行代码就拿了冠军

你知道的越多，你不知道的越多 点赞再看，养成习惯GitHub上已经开源https://github.com/JavaFamily，有一线大厂面试点脑图，欢迎Star和完善 前言 这一期不算《吊打面试官》系列的，所有没前言我直接开始。 絮叨 本来应该是没有这期的，看过我上期的小伙伴应该是知道的嘛，双十一比较忙嘛，要值班又要去帮忙拍摄年会的视频素材，还得搞个程序员一天的Vlog，还要写BU

加快推动区块链技术和产业创新发展，2019可信区块链峰会在京召开

11月8日，由中国信息通信研究院、中国通信标准化协会、中国互联网协会、可信区块链推进计划联合主办，科技行者协办的2019可信区块链峰会将在北京悠唐皇冠假日酒店开幕。 　　区块链技术被认为是继蒸汽机、电力、互联网之后，下一代颠覆性的核心技术。如果说蒸汽机释放了人类的生产力，电力解决了人类基本的生活需求，互联网彻底改变了信息传递的方式，区块链作为构造信任的技术有重要的价值。 　　1...

程序员把地府后台管理系统做出来了，还有3.0版本！12月7号最新消息：已在开发中有github地址

第一幕：缘起 听说阎王爷要做个生死簿后台管理系统，我们派去了一个程序员…… 996程序员做的梦： 第一场：团队招募 为了应对地府管理危机，阎王打算找“人”开发一套地府后台管理系统，于是就在地府总经办群中发了项目需求。 话说还是中国电信的信号好，地府都是满格，哈哈！！！ 经常会有外行朋友问：看某网站做的不错，功能也简单，你帮忙做一下？ 而这次，面对这样的需求，这个程序员

网易云6亿用户音乐推荐算法

网易云音乐是音乐爱好者的集聚地，云音乐推荐系统致力于通过 AI 算法的落地，实现用户千人千面的个性化推荐，为用户带来不一样的听歌体验。 本次分享重点介绍 AI 算法在音乐推荐中的应用实践，以及在算法落地过程中遇到的挑战和解决方案。 将从如下两个部分展开： AI 算法在音乐推荐中的应用 音乐场景下的 AI 思考 从 2013 年 4 月正式上线至今，网易云音乐平台持续提供着：乐屏社区、UGC

8年经验面试官详解 Java 面试秘诀

    作者 | 胡书敏 责编 | 刘静 出品 | CSDN（ID：CSDNnews） 本人目前在一家知名外企担任架构师，而且最近八年来，在多家外企和互联网公司担任Java技术面试官，前后累计面试了有两三百位候选人。在本文里，就将结合本人的面试经验，针对Java初学者、Java初级开发和Java开发，给出若干准备简历和准备面试的建议。   Java程序员准备和投递简历的实

面试官如何考察你的思维方式？

1.两种思维方式在求职面试中，经常会考察这种问题：北京有多少量特斯拉汽车？ 某胡同口的煎饼摊一年能卖出多少个煎饼？ 深圳有多少个产品经理？ 一辆公交车里能装下多少个乒乓球？ 一

碎片化的时代，如何学习

今天周末，和大家聊聊学习这件事情。 在如今这个社会，我们的时间被各类 APP 撕的粉碎。 刷知乎、刷微博、刷朋友圈； 看论坛、看博客、看公号； 等等形形色色的信息和知识获取方式一个都不错过。 貌似学了很多，但是却感觉没什么用。 要解决上面这些问题，首先要分清楚一点，什么是信息，什么是知识。 那什么是信息呢？ 你一切听到的、看到的，都是信息，比如微博上的明星出轨、微信中的表情大战、抖音上的...

so easy！ 10行代码写个"狗屁不通"文章生成器

前几天，GitHub 有个开源项目特别火，只要输入标题就可以生成一篇长长的文章。 背后实现代码一定很复杂吧，里面一定有很多高深莫测的机器学习等复杂算法 不过，当我看了源代码之后 这程序不到50行 尽管我有多年的Python经验，但我竟然一时也没有看懂 当然啦，原作者也说了，这个代码也是在无聊中诞生的，平时撸码是不写中文变量名的, 中文...

知乎高赞：中国有什么拿得出手的开源软件产品？(整理自本人原创回答)

知乎高赞：中国有什么拿得出手的开源软件产品？ 在知乎上，有个问题问“中国有什么拿得出手的开源软件产品（在 GitHub 等社区受欢迎度较好的）？” 事实上，还不少呢~ 本人于2019.7.6进行了较为全面的回答，对这些受欢迎的 Github 开源项目分类整理如下： 分布式计算、云平台相关工具类 1.SkyWalking，作者吴晟、刘浩杨 等等 仓库地址: apache/skywalking 更...

相关热词 c# plc s1200 c#里氏转换原则 c# 主界面 c# do loop c#存为组套 模板 c# 停掉协程 c# rgb 读取图片 c# 图片颜色调整 最快 c#多张图片上传 c#密封类与密封方法