byf_study_alway的专栏

主要涉及无线网创建和单源最短路径问题设计要求：设计我们学校的平面图，至少包括10个以上的场所，每两个场所间可以有不同的路，且路长也可能不同，找出从任意场所到达另一场所的最佳路径（最短路径）。基本要求：1）设计校园平面图，在校园景点选10个左右景点。以图中顶点表示校园内各景点，存放景点名称、代号、简介等信息；以边表示路径，存放路径长度等有关信息。2）为来

代码：#include #include #include using namespace std;bool verifyBst(int data[],int length){ if(data == NULL || length <=0) return true; int root = data[length - 1]; int i=0; //查找左子树节点和长度

很容易想到为二进制的与或非。加法分为三步：1 各位相加不进位 0 + 0 =0， 0+1 = 1,1+0=1,1+1=1，很明显是异或运算2 进位 1+1 =10进位，其余均不进位 ，进行左移动一位3 一直循环代码：#include using namespace std;int sum(int data1,int data2){ int sum,carry;

1 通过构造函数代码：

输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。代码：#include #include #include using namespace std;bool isStackSeq(int *pPush,int *pPop,int length){ bool isstack = false; if(pPush

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增的排序的数组的一个旋转，输出旋转数组的最小元素。例如输入{1,2,3,4,5}的一个旋转为{3,4,5,1,2}，该数组的最小值为1。可以使用从头到尾遍历，时间复杂度为O（n），根据其特性可以使用二分查找，降低时间复杂度。代码：#include using namespace std;i

很容易想到用先序遍历，并传递进去一个数组和当前和。just so so代码：#include #include #include using namespace std;typedef struct tree{ int data; struct tree * lchild; struct tree * rchild;}Tree,*pTree;void create

主要通过递归完成：1 根节点是否相同，不相同，进行第一次递归2 根节点相同，在另外一个函数进行递归，判断子节点是否相同#include #include using namespace std; typedef struct tree{ int key; struct tree *left; struct tree *right; } * pTree,Tree;

直接递归代码：#include #include using namespace std; typedef struct listNode{ int key; struct listNode *pNext; } * pNode,Node;void createNode(pNode &pHead){ bool isFirst=true; int temp; sc

使用数据结构stack或者递归1 使用stack#include #include using namespace std; typedef struct listNode{ int key; struct listNode *pNext; } * pNode,Node;void createNode(pNode &pHead){ bool isFirst=true;

题目：设计包含min函数的栈。定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。文件分布：头文件和main文件头文件：代码#include #include using namespace std;template class stackWithMin{ private :

方法一：通过私有化构造函数代码：#include using namespace std;//只能在堆上进行创建class sealedClass{private : sealedClass(){} ~sealedClass(){}public: static sealedClass * getInstance(){ return new sealedClass(

#include using namespace std;void GetNext(char* p,int next[]) { int pLen = strlen(p); next[0] = -1; int k = -1; int j = 0; while (j < pLen - 1) { //

很容易想到递归，实现确实不是太容易，对本人来说。平衡二叉树是有序的，要求链表也是有序。\代码：#include //平衡二叉树转化为双向链表using namespace std;typedef struct tree{ int data; struct tree *lchild; struct tree *rchild;}Tree,*pTree;void

1 递归，很简单代码：#include using namespace std; typedef struct node{ int data; struct node * pNext;}Node ,*pNode;void createNode(pNode & pHead){ int temp; scanf("%d",&temp); pNode p,q; boo

对于一颗二叉树，可以根据先序遍历（后序遍历）和中序遍历重新还原出二叉树。主要通过递归实现。关键是找出对应左右子树的长度，之后传递先序遍历的开始节点、结束节点，中序遍历的开始节点、结束节点。代码：#include using namespace std;typedef struct tree{ int data; struct tree *lchild; struct

解析：

使用STL容器 multiset代码：#include #include #include using namespace std;typedef multiset > intSet;typedef multiset >::iterator intIter;void findMaxNum(const vector &data,int k){ intSet Max;

优化方法： 剪枝一：可以进行剪枝，因为很多情况是没有意义的，当重量大于背包容量的时候，没有必要对剩下的物品再来决策了。 剪枝二：将剩下的所有物品都选取其总价值也没有目前已经求得的方案的价值还大的话，也可以返回。#include #define M 3 #define ERROR 0#define OK 1typedef int status;int curweight=0

对于每一个物品i，对于该物品只有选与不选2个决策，总共有n个物品，可以顺序依次考虑每个物品，这样就形成了一棵解空间树：基本思想就是遍历这棵树，以枚举所有情况，最后进行判断，如果重量不超过背包容量，且价值最大的话，该方案就是最后的答案。 #include #define M 3 //定义有三个物品int limitweight; //背包最多存放多少物品int maxValue=0

#include #include #define OK 1#define ERROR -1#define OVERFLOW 0#define MAXVER 20 //定义最大定点数#define MAXINT 200 //定义无穷大typedef enum{UDG,UDN,DG,DN} GraphKind;// 定义无向图 无向网 有向图 有向网typedef char

有向图和无向图差别就是一句代码的差别 ，无向图中代码注释掉即可有向图和有向网的差别也就是权值的差别  有向网需要赋予权值  有向图有连线自动赋值为1深度优先采用递归方法（参考前面几篇文章，里面有具体的深度优先和广度优先访问和队列基本操作）广度优先采用队列上代码#include #include #define OK 1#define ERROR -1#define O

#include #include typedef struct node{ int data; struct node *next;}Node,*LNode;//创建不带头节点的链表void create(LNode &head,int n){ int i; LNode p,q; for(i=0;i<n;i++) { q=(LNode)malloc(siz

#include #include #define OK 1#define ERROR 0typedef int status;typedef struct BiNode{ char data; struct BiNode *lchild,*rchild;}BiTNode,*BiTree; //定义二叉树status createBiNode(BiTree &t){

#include#include#define OVERFLOW -1#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int status;typedef char TElemType;typedef struct TNode{ TElemType data; struct TNode *lc

队列是先进先出的数据结构，出队的一端叫队首，入队的一端叫队尾，就像是日常生活中排队买火车票一样，下面是队列的基本操作创建史带头节点的链表#include #include #define OK 1#define ERROR -1#define OVERFLOW 0typedef int elemtype;typedef int status;typedef struc

#include #include #define M 7#define N 3//对于工作的存储typedef struct Job{ int id; int time;}job[M];//对于机器的存储typedef struct Mechine{ int id; int avail;}Me[N];//对应于每台

贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。#include #define M 5struct node{ float value; float weight; int flag;}Node[M],temp;float Value,curvalue=0;float Weight,curweig

递归函数就是直接或间接调用自身的函数。递归式:    当wn>C时，  f(n,C)=f(n-1,C);    当wnf(n，C) = max(f(n-1,C), vn+f(n-1, C-wn) );    初始条件为：f(i, 0) = 0; f(0,i) = 0; f(0,0) = 0;#include #define MAX 100in

很自然想起来递归：代码：#include #include using namespace std;typedef struct tree1{ int data; struct tree1 * lchild; struct tree1 * rchild;}Tree,* pTree;void createTree(pTree & p){ int temp ; scan

使用两个指针，和判断一个链表是否形成环类似代码：#include #include using namespace std;typedef struct node { int data; struct node *next ;}Node,*pNode;void creatNode( pNode &pHead ){ bool isFirst=true; pNode p

约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。方法1：使用stl：：list模拟环形链表，参考剑指offer代码：#include #include using namespace std;i

先看百度一道面试题：有一颗二叉树，定义树的高度为从根到叶子节点的最长距离，树的宽度为每层节点的最大值，树的面积定义为高度和宽度的乘积。写一个函数计算一个二叉树的面积。(15分)解决这道题参考资料剑指offer和编程之美，分别求求二叉树高度和宽度。都是采用递归：求高度参考：http://blog.youkuaiyun.com/buyingfei8888/article/details

有1000桶酒，其中1桶有毒。而一旦吃了，毒性会在1周后发作。现在我们用小老鼠做实验，要在1周后找出那桶毒酒，问最少需要多少老鼠，如何检测（老鼠的使用量越少越好，注意，毒性1周后才会发作，而且一周后必须出结果，所以时间紧迫） 思路： 为何需要老鼠做实验，显然是根据老鼠的死活来判断酒的毒性，每一只老鼠只有2种状态，死和活，n只老鼠就是这n个死或活的状态，应该由此敏感的联想到二进制，隐

这道题本质上还是考查二元树的遍历如果一棵树只有一个结点，它的深度为1。如果根结点只有左子树而没有右子树，那么树的深度应该是其左子树的深度加1；同样如果根结点只有右子树而没有左子树，那么树的深度应该是其右子树的深度加1。如果既有右子树又有左子树呢？那该树的深度就是其左、右子树深度的较大值再加1。上面的这个思路用递归的方法很容易实现，只需要对遍历的代码稍作修改即可参考资料：

排列#include // 主要是找到当前要排的 和后面要排数的关系int swap(int m,int n){ if(n==1) return m-n+1; return m*swap(m-1,n-1);}int main(){ int m=5,n=4; printf("%d",swap(5,4));} 组合

全排列输出：解法一:#include /* 递归思想： 取出数组第一个元素放到最后一个元素 即a[0] 和a[n]交换 然后一次递归a[n] 个元素的全排列 1 如果数组只有一个元素 n=1 a={1} 则全排列就是{1} 2 如果有两个元素 n=2 a={1,2} 则全排列是 {2,1} a[1]与a[2]交换 交换后求a[

哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。#include #include #include typedef struct { int weight; int parent,lchild,rchild; //儿子节点的parent存放父节点的下标

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