zdw12242
zdw12242

某国内IT大牌名企校招笔试 + 树的学习—（递归构建二叉树、递归非递归前序中序后序遍历二叉树、根据前序序列、中序序列构建二叉树）

转载自: http://blog.csdn.net/wzy_1988/article/details/11790511

前言

博主明天上午9点还有面试，今天突然看到某大牌IT公司笔试题目，必须做一下了

题目

一、单选题

1.假设把整数关键码K散列到N个槽列表，以下哪些散列函数是好的散列函数

A: h(K)=K/N;

B: h(K)=1;

C: h(K)=K mod N;

D: h(K)=(K+rand(N)) mod N, rand(N)返回0到N-1的整数

选择C，解释：开始纠结于C和D，但是hash的特性在于常数的时间执行插入、删除和查找操作，用D作为hash函数无法满足该条件，用C产生碰撞可以用链接法解决冲突，感谢@ zdw12242的纠正


2.下面排序算法中，初始数据集的排列顺序对算法的性能无影响的是：

A: 堆排序 B：插入排序

C: 冒泡排序 D:快速排序

选择A，解释：（1）堆排序的时间复杂度一直都是O(nlogn),不稳定（2）插入排序在初始有序情况下，时间复杂度为O(n),平均时间复杂度为O（n^2），稳定排序（3）冒泡排序在初始有序的情况下，增加交换标示flag可将时间复杂度降到O(n),稳定排序（4）快速排序在初始有序的情况下，可能会退化到O（n^2），不稳定排序


3. 下面说法错误的是：

A: CISC计算机比RISC计算机指令多

B: 在指令格式中，采用扩展操作码设计方案的目的是为了保持指令字长不变而增加寻址空间

C:增加流水线段数理论上可以提高CPU频率

D:冯诺依曼体系结构的主要特征是存储程序的工作方式

选择B，解释（1）CISC复杂指令集，RISC精简指令集，从名字上就可以得出A正确（2）保持指令字长度不变而增加指令操作的数量（3）看样子都觉得正确（4）冯诺依曼体系结构的主要特点：存储程序控制（要求计算机完成的功能，必须事先编制好相应的程序，并输入到存储器中，计算机的工作过程是运行程序的过程）;程序由指令构成，指令和数据都用二进制表示;指令由操作码和地址码构成;机器以cpu为中心


4. 不属于冯诺依曼体系结构必要组成部分是：

A:CPU B: Cache C:RAM D:ROM

B，解释：冯诺依曼体系结构必要组成部分：运算器、控制器、存储器、输入设备、输出设备，Cache属于缓存了


5. 一个栈的入栈序列式ABCDE则不可能的出栈序列是:

A:DECBA B:DCEBA C:ECDBA D:ABCDE

C，不解释


6.你认为可以完成编写一个C语言编译器的语言是：

A：汇编 B:C语言 C:VB D:以上全可以

D,解释：见知乎的一个解答 http://www.zhihu.com/question/20822934，其实你学好编译原理用什么语言都能写出来


7. 关于C++/JAVA类中的static成员和对象成员的说法正确的是：

A：static成员变量在对象构造时候生成

B: static成员函数在对象成员函数中无法调用

C: 虚成员函数不可能是static成员函数

D: static成员函数不能访问static成员变量

C,解释：虽然博主主要以php和c为主，php也能面向对象，我来简单说明一下。（1）static成员变量可以直接定义，例如public statci $a = 10; 所以A错（2）在对象成员函数里可以通过类名：：static函数名的方法调用，我的项目中超过静态方法（4）同样道理，类名：：static成员变量名，这也是访问static成员变量唯一的方法（3）是正确的，虽然我都不知道什么是虚函数，排除法可以完成


9：某进程在运行过程中需要等待从磁盘上读入数据，此时进程的状态将：

A: 从就绪变为运行 B:从运行变为就绪

C: 从运行变为阻塞 D:从阻塞变为就绪

C，解释：I/O事件让进程从running->waitting,参考链接： http://blog.csdn.net/wzy_1988/article/details/11003521


10：下面算法的时间复杂度为：

Int f(unsigned int n)
{

If(n==0||n==1)

Return 1;

Else

Return n*f(n-1);

}

A: O(1) B:O(n) C:O(N*N) D:O(n!)

B，解释：没啥好解释的


11: n从1开始，每个操作可以选择对n加1或者对n加倍。若想获得整数2013，最少需要多少个操作。

A:18 B:24 C:21 D；不可能

A，解释： 数学方法->从 2013 倒推， 奇数 减一，偶数 除2， 编程实现->是一个明显的bfs题目，编程实现为18,共享一下自己的bfs代码：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3.   
  4. #define FINAL 2013  
  5.   
  6. #define MAX 25  
  7.   
  8. typedef struct num {  
  9.     int d, time;  
  10. } num;  
  11.   
  12.   
  13. typedef struct queue {  
  14.     int front, rear, count;  
  15.     num data[10000000];  
  16. } queue;  
  17.   
  18.   
  19. void enQueue(queue *q, num d)  
  20. {  
  21.     q->data[q->rear ++] = d;  
  22.     q->count ++;  
  23. }  
  24.   
  25. num deQueue(queue *q)  
  26. {  
  27.     num res;  
  28.     res = q->data[q->front ++];  
  29.     q->count --;  
  30.   
  31.     return res;  
  32. }  
  33.   
  34.   
  35. int main(void)  
  36. {  
  37.     int flag = 0;  
  38.   
  39.     num bt, one, two, s;  
  40.   
  41.     bt.d = 2;  
  42.     bt.time = 1;  
  43.   
  44.     queue *q = (queue *)malloc(sizeof(queue));  
  45.     q->front = q->rear = q->count = 0;  
  46.   
  47.     enQueue(q, bt);  
  48.   
  49.     while (q->count > 0) {  
  50.         s = deQueue(q);  
  51.   
  52.         if (s.d == FINAL) {  
  53.             flag = 1;  
  54.             printf("%d\n", s.time);  
  55.             break;  
  56.         }  
  57.   
  58.         one.d = s.d + 1;  
  59.         one.time = s.time + 1;  
  60.         if (one.d <= FINAL && one.time <= MAX) {  
  61.             enQueue(q, one);  
  62.         }  
  63.   
  64.         two.d = s.d * 2;  
  65.         two.time = s.time + 1;  
  66.         if (two.d <= FINAL && two.time <= MAX) {  
  67.             enQueue(q, two);  
  68.         }  
  69.   
  70.         printf("%d\n", q->count);  
  71.     }  
  72.   
  73.     if (flag == 0)  
  74.         printf("不可能!\n");  
  75.   
  76.     return 0;  
  77. }  


12：对于一个具有n个顶点的无向图，若采用邻接表数据结构表示，则存放表头节点的数组大小为：

A: n B: n+1 C: n-1 D:n+边数

A，解释：感觉没啥好解释的，n个顶点数组大小应该就是n吧，如果非要从下标从1开始，那就是n+1，蛋疼的题目，话说在ACM上写bfs，dfs，最短路径全是用邻接矩阵，就谁会用邻接表这么蛋疼的设计，又不是hash


14：如下函数，在32bit系统foo(2^31-3)的值是：

Int foo(int x)
{

Return x&-x;

}

A： 0 B: 1 C:2 D:4

C,解释：我只想说注意运算符优先级，注意^是异或


15.对于顺序存储的线性数组，访问节点和增加节点删除节点的时间复杂度为：

A: O(n),O(n) B:O(n),O(1) C:O(1),O(n) D:O(n),O(n)

C，解释：给定下标，访问为O(1)，增加和删除节点涉及到移动操作为O(n)


16:在32为系统环境，编译选项为4字节对齐，那么sizeof(A)和sizeof(B)是：

Struct A
{
int a;
short b;
int c;
char d;
};

Struct B
{
int a;
short b;
char c;
int d;
};

A: 16,16 B:13,12 C:16,12 D:11,16

C，解释：字节对齐包含了每个变量自身对齐和复杂类型整体对齐。pragma pack参考链接： http://blog.csdn.net/wzy_1988/article/details/11834881
对于A：
  1. int a自身对齐是4,pragma pack指定对齐也是4,因此其有效对齐为4,起始地址0x0000满足0x0000 % 4 == 0
  2. short b自身对齐是2,指定对齐是4,因此有效对齐为其最小值2,起始地址0x0004满足0x0004 % 2 == 0
  3. int c自身对齐是4,pragma pack指定对齐也是4,因此其有效对齐为4,起始地址0x0006不满足0x0006 % 4 == 0,因此需要填充空字节，起始地址为0x0008
  4. char d自身对齐是1,指定对齐是4,因此有效对齐为其最小值1,起始地址0x000C满足0x000C % 1 == 0
  5. 结构体还需要整体对齐，也就是结构体成员最大有效对齐的倍数，0x000D不满足 % 4 ==0, 需要需要补充3个字节，总字节数为16
对于B：
  1. int a自身对齐是4,pragma pack指定对齐也是4,因此其有效对齐为4,起始地址0x0000满足0x0000 % 4 == 0
  2. short b自身对齐是2,指定对齐是4,因此有效对齐为其最小值2,起始地址0x0004满足0x0004 % 2 == 0
  3. char d自身对齐是1,指定对齐是4,因此有效对齐为其最小值1,起始地址0x0006满足0x000C % 1 == 0
  4. int c自身对齐是4,pragma pack指定对齐也是4,因此其有效对齐为4,起始地址0x0007不满足 % 4 ==0,需要补充一个空字节，起始地址为0x0008
  5. 结构体需要整体对齐，结构体整体有效对齐是4,0x000C % 4 == 0,因此总字节为12

17.袋中有红球，黄球，白球各一个，每次任意取一个放回，如此连续3次，则下列事件中概率是8/9的是：

A: 颜色全相同 B:颜色全不相同C:颜色不完全相同 D:颜色无红色

C，解释：（1）颜色全相同：C(1,3) / 27 =  1 / 9（2）颜色全不相同：3 * 2 * 1 / 27 = 2 / 9 （4）颜色无红色: 2 * 2 * 2 / 27 = 8 / 27 （3）颜色不完全相同 = 1 - P(颜色完全相同) = 1 - 1 / 9 = 8 / 9


18.一个洗牌程序的功能是将n张牌的顺序打乱，以下关于洗牌程序的功能定义说法最恰当的是：

A: 每张牌出现在n个位置上的概率相等

B: 每张牌出现在n个位置上的概率独立

C: 任何连续位置上的两张牌的内容独立

D: n张牌的任何两个不同排列出现的概率相等

D，解释：乐乐说选D，其实我觉得A也挺对的，这到题目我写了一个测试洗牌的程序，但是自己测试问题很大，怀疑是随机数获取的问题，求大家帮忙指点：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <time.h>  
  4.   
  5. #define N 10  
  6.   
  7. int arr[N] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  
  8.   
  9. void shuffleArray()  
  10. {  
  11.     int i, loc, tmp;  
  12.     time_t t;  
  13.   
  14.     srand((unsigned int)time(&t));  
  15.       
  16.     // 洗牌算法  
  17.     for (i = 0; i < N; i ++) {  
  18.         loc = rand() % (i + 1);  
  19.         tmp = arr[loc];  
  20.         arr[loc] = arr[i];  
  21.         arr[i] = tmp;  
  22.     }  
  23.   
  24.     // 打印输出  
  25.     for (i = 0; i < N; i ++)  
  26.         printf("%d ", arr[i]);  
  27.     printf("\n");  
  28. }  
  29.   
  30.   
  31. int main(void)  
  32. {  
  33.     int i, n;  
  34.   
  35.     while (scanf("%d", &n) != EOF) {  
  36.         for (i = 0; i < n; i ++) {  
  37.             // 测试洗牌  
  38.             shuffleArray();  
  39.         }  
  40.     }  
  41.   
  42.     return 0;  
  43. }  


19.用两种颜色去染排成一个圈的6个棋子，如果通过旋转得到则只算一种，一共有多少种染色：

A: 10 B:11 C:14: D:15

不会，这么多概率题目啊，我去


20.递归式的先序遍历一个n节点，深度为d的二叉树，则需要栈空间的大小为：

A: O(n) B:O(d) C:O(logn) D:(nlogn)

B，解释：需要考虑最坏的情况，A和B我不确定啊，蛋疼




二、多选题

21.两个线程运行在双核机器上，每个线程主线程如下，线程1：x=1;r1=y;线程2：y=1;r2=x;

X和y是全局变量，初始为0。以下哪一个是r1和r2的可能值：

A: r1=1,r2=1

B: r1=1,r2=0

C:r1=0,r2=0

D:r1=0,r2=1

ABD，解释：r1和r2不可能同时为0,当一个有赋值时，必然完成了对另一个x或y的赋值


22.关于Linux系统的负载，以下表述正确的是：

A: 通过就绪和运行的进程数来反映

B: 通过TOP命令查看

C: 通过uptime查看

D: Load:2.5,1.3,1.1表示系统的负载压力在逐渐变小

BC，解释：ALINUX系统还需要包含处于waitting状态的进程 D说明系统负载变大，load average分别是系统1分钟，5分钟，15分钟的平均负载 参考链接：（1） http://hi.baidu.com/liheng_2009/item/20ddc822dee757192a0f1ca4（2） http://blog.csdn.net/wzy_1988/article/details/11849473


23.关于排序算法的以下说法，错误的是：

A: 快速排序的平均时间复杂度O(nlogn),最坏O(N^2)

B:堆排序平均时间复杂度O(nlogn)，最坏O(nlogn)

C:冒泡排序平均时间复杂度O(n^2),最坏O(n^2)

D:归并排序的平均时间复杂度O(nlogn),最坏O(n^2)

D，解释：归并排序最坏的时间复杂度也是O(nlogn)


24.假设函数rand_k会随机返回一个【1，k】之间的随机数（k>=2）,并且每个证书出现的概率相等。目前有rand_7,通过调用rand_7（）和四则运算符，并适当增加逻辑判断和循环控制逻辑，下列函数可以实现的有：

A:rand_3 B:rand_21 C:rand_23 D:rand_49

ABCD，解释： 参考链接： http://blog.csdn.net/wzy_1988/article/details/11866973

填空和问答

25.某二叉树的前序遍历-+a*b-cd/ef，后续遍历abcd-*+ef/-,问其中序遍历序列为

扯淡啊，根据前序和后序没法唯一确定中序好不好，我擦


26.某缓存系统采用LRU，缓存容量为4，并且初始为空，那么在顺序访问以下数据项的时候：1,5,1,3,5,2,4,1,2

出现缓存直接命中的次数为：（），最后缓存即将淘汰的是（）

3,5,参考链接： http://blog.csdn.net/wzy_1988/article/details/11714651


27.两个较长的单链表a和b，为了找出节点node满足node in a并且node in b。请设计空间使用尽量小的算法

求两个链表的公共节点题目

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <string.h>  
  4.    
  5. typedef struct list {  
  6.     int value;  
  7.     struct list *next;  
  8. } list;  
  9.    
  10. void addDataInList(list **root, int data)  
  11. {  
  12.     list *pre, *current, *new;  
  13.     current = *root;  
  14.     pre = NULL;  
  15.    
  16.     while (current != NULL) {  
  17.         pre = current;  
  18.         current = current->next;  
  19.     }  
  20.        
  21.     new = (list *)malloc(sizeof(list));  
  22.     new->value = data;  
  23.     new->next = NULL;  
  24.    
  25.     if (pre == NULL) { // 头节点  
  26.         *root = new;  
  27.     } else {  
  28.         pre->next = new;  
  29.     }  
  30. }  
  31.    
  32. void searchInList(list *first, int m, list *second, int n)  
  33. {  
  34.     int i;  
  35.    
  36.     // 构成Y的形状  
  37.     if (m > n) {  
  38.         for (i = 0; i < m - n; i ++)  
  39.             first = first->next;  
  40.     } else {  
  41.         for (i = 0; i < n - m; i ++)  
  42.             second = second->next;  
  43.     }  
  44.    
  45.     // 查找第一个公共节点  
  46.     while (first != NULL && second != NULL && first->value != second->value) {  
  47.         first = first->next;  
  48.         second = second->next;  
  49.     }  
  50.    
  51.     if (first == NULL && second == NULL)  
  52.         printf("My God\n");  
  53.     else  
  54.         printf("%d\n", first->value);  
  55. }  
  56.    
  57.    
  58. int main(void)  
  59. {  
  60.     int i, n, m, data;  
  61.     list *first, *second;  
  62.    
  63.    
  64.     while (scanf("%d %d", &m, &n) != EOF) {  
  65.         // 构造第一个链表  
  66.         for (i = 0, first = NULL; i < m; i ++) {  
  67.             scanf("%d", &data);  
  68.             addDataInList(&first, data);  
  69.         }  
  70.    
  71.         // 构造第二个链表  
  72.         for (i = 0, second = NULL; i < n; i ++) {  
  73.             scanf("%d", &data);  
  74.             addDataInList(&second, data);  
  75.         }  
  76.    
  77.         // 第一个公共节点  
  78.         searchInList(first, m, second, n);  
  79.     }     
  80.    
  81.     return 0;  
  82. }  

28.存储数据量超出单节点数据管理能力的时候，可以采用的办法有数据库sharding的解决方案，也就是按照一定的规律把数据分散存储在多个数据管理节点N中（节点编号为0,1,2，，，，N-1）。假设存储的数据时a 请完成为数据a计算存储节点的程序
[cpp] view plain copy
  1. #define N 5  
  2.  int hash(int element){  
  3.     return element*2654435761;  
  4.  }  
  5.  int shardingIndex(int a){  
  6.      int p = hash(a);  
  7.      _________________________; //这里是空格  
  8.      return p;  
  9.  }  

p = p % N;解释：感觉没啥好解释的，基本的散列函数


29.宿舍内5个同学一起玩对战游戏，每场比赛有一些人作为红方，一些人作为蓝方，请问至少需要多少场比赛，才能使得任意两个人之间有一场红方对蓝方和蓝方对红方的比赛

4,被n多人指点之后的结果


后记

一面创新工厂感觉还不错，期待后续继续给力吧，话说一面结束没消息是闹哪样，先去吃饭，回来继续更新，昨天太累，今天竟然睡到下午才起床



前言

最近两个星期一直都在断断续续的学习二叉树的数据结构，昨晚突然有点融汇贯通的感觉，这里记录一下吧

题目要求

给定前序序列，abc##de#g##f###,构建二叉树，并且用递归和非递归两种方法去做前序，中序和后序遍历

二叉树的数据结构

[cpp] view plain copy
  1. #define STACKSIZE 10005  
  2.   
  3. /** 
  4.  * 二叉树的数据结构 
  5.  */  
  6. typedef struct btree {  
  7.     struct btree *lchild;  
  8.     struct btree *rchild;  
  9.     char item;  
  10. } btree;  
  11.   
  12. typedef btree *bt;  
  13.   
  14. /** 
  15.  * 定义顺序栈数据结构(非递归遍历) 
  16.  */  
  17. typedef struct stack {  
  18.     btree *db[STACKSIZE];  
  19.     int top;  
  20. } stack;  


递归构建二叉树

构建二叉树有固定的几种考察类型：
  1. 根据完整的先序序列构建二叉树
  2. 根据前序和中序序列构建二叉树

根据先序序列构建二叉树（c语言实现）

[cpp] view plain copy
  1. char str[101] = "abc##de#g##f###";  
  2. int count = 0;  
  3.   
  4. /** 
  5.  * 根据先序序列构建二叉树(因为涉及到对根节点指针修改，因此传递根节点指针的指针) 
  6.  */  
  7. void createBtree(btree **t)  
  8. {  
  9.     if (str[count ++] == '#') {  
  10.         *t = NULL;  
  11.     } else {  
  12.         *t = (btree *)malloc(sizeof(btree));  
  13.         (*t)->item = str[count - 1];  
  14.         createBtree(&(*t)->lchild);  
  15.         createBtree(&(*t)->rchild);  
  16.     }  
  17. }  

热潮

递归的前序、中序、后序算法（c语言实现）

[cpp] view plain copy
  1. /** 
  2.  * 递归先序遍历二叉树 
  3.  */  
  4. void recPreorder(btree *t)  
  5. {  
  6.     if (t) {  
  7.         printf("%c", t->item);  
  8.         recPreorder(t->lchild);  
  9.         recPreorder(t->rchild);  
  10.     }  
  11. }  
  12.   
  13. /** 
  14.  * 递归中序遍历二叉树 
  15.  */  
  16. void recInorder(btree *t)  
  17. {  
  18.     if (t) {  
  19.         recInorder(t->lchild);  
  20.         printf("%c", t->item);  
  21.         recInorder(t->rchild);  
  22.     }  
  23. }  
  24.   
  25. /** 
  26.  * 递归后序遍历二叉树 
  27.  */  
  28. void recPostorder(btree *t)  
  29. {  
  30.     if (t) {  
  31.         recPostorder(t->lchild);  
  32.         recPostorder(t->rchild);  
  33.         printf("%c", t->item);  
  34.     }  
  35. }  


非递归前序、中序遍历算法(c语言实现)

[cpp] view plain copy
  1. /** 
  2.  * 非递归前序遍历 
  3.  */  
  4. void preorderTraverse(btree *t)  
  5. {  
  6.     btree *p = t;  
  7.   
  8.     // 初始化栈  
  9.     stack *s = (stack *)malloc(sizeof(stack));  
  10.     s->top = 0;  
  11.   
  12.     while (p || s->top > 0) {  
  13.         if (p) {  
  14.             printf("%c", p->item);  
  15.             s->db[s->top ++] = p;  
  16.             p = p->lchild;  
  17.         } else {  
  18.             p = s->db[-- s->top];  
  19.             p = p->rchild;  
  20.         }  
  21.     }  
  22. }  
  23.   
  24. /** 
  25.  * 非递归中序遍历 
  26.  */  
  27. void inorderTraverse(btree *t)  
  28. {  
  29.     btree *p = t;  
  30.   
  31.     // 初始化栈  
  32.     stack *s = (stack *)malloc(sizeof(stack));  
  33.     s->top = 0;  
  34.   
  35.     while (p || s->top > 0) {  
  36.         if (p) {  
  37.             s->db[s->top ++] = p;  
  38.             p = p->lchild;  
  39.         } else {  
  40.             p = s->db[-- s->top];  
  41.             printf("%c", p->item);  
  42.             p = p->rchild;  
  43.         }  
  44.     }  
  45. }  


非递归后序遍历算法(c语言实现)

算法思想：

  1. 首先，也是找到最左边的叶子结点并把路上遇到的节点依次入栈
  2. 然后，弹出栈顶元素(该元素为最左边的叶子)，判断（1）它是否有右节点（2）如果有右节点，是否被访问过。如果满足（1）有右节点并且（2）右节点没有访问过，说明这是后序遍历的相对根节点，因此需要将这个节点再次入栈，并且它的右节点入栈，然后重新执行第一步。否则，就访问该节点，并且设置pre为此节点，同时把将遍历节点附空值，访问进入无限循环

算法代码：

[cpp] view plain copy
  1. /** 
  2.  * 非递归后序遍历 
  3.  */  
  4. void postTraverse(btree *t)  
  5. {  
  6.     btree *p, *pre;  
  7.     p = t;  
  8.     pre = NULL;  
  9.   
  10.     // 初始化栈  
  11.     stack *s = (stack *)malloc(sizeof(stack));  
  12.     s->top = 0;  
  13.   
  14.     while (p || s->top > 0) {  
  15.         if (p) {  
  16.             s->db[s->top ++] = p;  
  17.             p = p->lchild;  
  18.         } else {  
  19.             p = s->db[-- s->top];  
  20.             if (p->rchild != NULL && p->rchild != pre) { // p为相对根节点  
  21.                 s->db[s->top ++] = p;  
  22.                 p = p->rchild;  
  23.             } else {  
  24.                 printf("%c", p->item);  
  25.                 pre = p;  
  26.                 p = NULL;  
  27.             }  
  28.         }  
  29.     }  
  30. }  

注意：

严蔚敏的<<数据结构>>上有一段话很经典，摘录如下：”从二叉树遍历的定义可知，三种遍历算法之不同处仅在于访问根节点和遍历左、右子树的先后关系。如果在算法中暂且抹去和递归无关的visit语句，则三个遍历算法完全相同。因此，从递归执行过程的角度来看，前序、中序、后序遍历也完全相同。“ 这段话给我们的提示就是，前序、中序、后序遍历的算法相同，只是printf()语句位置而已。


根据前序序列、中序序列构建二叉树

函数定义

[plain] view plain copy
  1. bt rebuildTree(char *pre, char *in, int len);  

参数：
* pre：前序遍历结果的字符串数组
* in：中序遍历结果的字符串数组
len : 树的长度
例如：
前序遍历结果: a b c d e f g h
中序遍历结果: c b e d f a g h

算法思想

  1. 递归思想，递归的终止条件是树的长度len == 0
  2. 在中序遍历的数组中找到前序数组的第一个字符，记录在中序数组中的位置index.如果找不到，说明前序遍历数组和中序遍历数组有问题，提示错误信息，退出程序即可;找到index后，新建一个二叉树节点t，t->item = *pre,然后递归的求t的左孩子和有孩子
  3. 递归的左孩子：void rebuildTree(pre + 1, in, index)
  4. 递归的右孩子：void rebuildTree(pre + (index + 1), in + (index + 1), len - (index + 1))

实现代码（c语言版）

[cpp] view plain copy
  1. /** 
  2.  * Description:根据前序和中序构建二叉树 
  3.  */  
  4. bt rebuildTree(char *pre, char *in, int len)  
  5. {  
  6.     bt t;  
  7.     if(len <= 0)  
  8.     {   
  9.         //递归终止  
  10.         t = NULL;  
  11.     }else  
  12.     {   
  13.         //递归主体  
  14.         int index = 0;  
  15.           
  16.         while(index < len && *(pre) != *(in + index))  
  17.         {  
  18.             index ++;  
  19.         }  
  20.           
  21.         if(index >= len)  
  22.         {  
  23.             printf("前序遍历或者中序遍历数组有问题!\n");  
  24.             exit(-1);  
  25.         }  
  26.           
  27.         t = (struct bintree *)malloc(sizeof(struct bintree));  
  28.         t->item = *pre;  
  29.         t->lchild = rebuildTree(pre + 1, in, index);  
  30.         t->rchild = rebuildTree(pre + (index + 1), in + (index + 1), len - (index + 1));  
  31.     }  
  32.     return t;  
  33. }  

根据中序序列、后序序列构建二叉树

函数定义

[cpp] view plain copy
  1. /** 
  2.  * 中序、后序序列构建二叉树 
  3.  */  
  4. btree* rebuildTree(char *order, char *post, int len);  

算法思想

中序序列：C、B、E、D、F、A、H、G、J、I

后序序列：C、E、F、D、B、H、J、I、G、A

递归思路：

  1. 根据后序遍历的特点，知道后序遍历最后一个节点为根节点，即为A
  2. 观察中序遍历，A左侧CBEDF为A左子树节点，A后侧HGJI为A右子树节点
  3. 然后递归的构建A的左子树和后子树

实现代码(c代码)

[cpp] view plain copy
  1. /** 
  2.  * 根据中序和后序序列构建二叉树 
  3.  * (ps:昨晚参加阿里笔试，等到最后说可以免笔试直接面试，今天估计还是要根据学校筛选，哈哈，为了这点 
  4.  * 也得参加阿里笔试，不能让自己的学校受到鄙视) 
  5.  */  
  6.   
  7. #include <stdio.h>  
  8. #include <stdlib.h>  
  9. #include <string.h>  
  10.   
  11. int n;  
  12.   
  13. typedef struct btree {  
  14.     struct btree *lchild;  
  15.     struct btree *rchild;  
  16.     char data;  
  17. } btree;  
  18.   
  19. /** 
  20.  * 中序、后序序列构建二叉树 
  21.  */  
  22. btree* rebuildTree(char *order, char *post, int len)  
  23. {  
  24.     btree *t;  
  25.   
  26.     if (len <= 0) {  
  27.         return NULL;  
  28.     } else {  
  29.         int index = 0;  
  30.   
  31.         while (index < len && *(post + len - 1) != *(order + index)) {  
  32.             index ++;  
  33.         }     
  34.   
  35.         t = (btree *)malloc(sizeof(btree));  
  36.         t->data = *(order + index);  
  37.         t->lchild = rebuildTree(order, post, index);  
  38.         t->rchild = rebuildTree(order + index + 1, post + index, len - (index + 1));  
  39.     }  
  40.   
  41.     return t;  
  42. }  
  43.   
  44. /** 
  45.  * 前序遍历二叉树 
  46.  */  
  47. void preTraverse(btree *t)  
  48. {  
  49.     if (t) {  
  50.         printf("%c ", t->data);  
  51.         preTraverse(t->lchild);  
  52.         preTraverse(t->rchild);  
  53.     }  
  54. }  
  55.   
  56. int main(void)  
  57. {  
  58.     int i;  
  59.     char *post, *order;  
  60.     btree *t;  
  61.   
  62.     while (scanf("%d", &n) != EOF) {  
  63.         post = (char *)malloc(n);  
  64.         order = (char *)malloc(n);  
  65.           
  66.         getchar();  
  67.         for (i = 0; i < n; i ++)  
  68.             scanf("%c", order + i);  
  69.   
  70.         getchar();  
  71.         for (i = 0; i < n; i ++)  
  72.             scanf("%c", post + i);  
  73.   
  74.         t = rebuildTree(order, post, n);  
  75.   
  76.         preTraverse(t);  
  77.         printf("\n");  
  78.   
  79.         free(post);  
  80.         free(order);  
  81.   
  82.     }  
  83.   
  84.     return 0;  
  85. }  


递归清理二叉树

复习了c语言的内存分配，参考链接： http://blog.csdn.net/zinss26914/article/details/8687859， 要点就是malloc分配的内存在堆上，使用完后应该由程序员手动释放，这里写一下递归清理二叉树的代码

[cpp] view plain copy
  1. /** 
  2.  * 清理二叉树 
  3.  */  
  4. void cleanBtree(btree *t)  
  5. {  
  6.     if (t) {  
  7.         cleanBtree(t->lchild);  
  8.         cleanBtree(t->rchild);  
  9.         free(t);  
  10.     }  
  11. }  


后记

2012年今天是最后一天了，哈哈，终于把二叉树该掌握的部分都掌握了，还是不错的，期待新的一年2013年有更多的收获，2013年可能又是我人生发生抉择和变化的一年，我依然会坚持自己的价值观，踏踏实实的走下去，现在我学会最多的就是坚持，坚忍，光说不做是没有的，写程序如此，做人亦如此！

今天是2013年7月23日，重写了部分二叉树操作的代码，对指针的掌握和对数据结构的掌握更加熟练，希望校招一切顺利，自己加油！

=========================二叉树内容==============================

前言

最近两个星期一直都在断断续续的学习二叉树的数据结构，昨晚突然有点融汇贯通的感觉，这里记录一下吧

题目要求

给定前序序列，abc##de#g##f###,构建二叉树，并且用递归和非递归两种方法去做前序，中序和后序遍历

二叉树的数据结构

[cpp] view plain copy
  1. #define STACKSIZE 10005  
  2.   
  3. /** 
  4.  * 二叉树的数据结构 
  5.  */  
  6. typedef struct btree {  
  7.     struct btree *lchild;  
  8.     struct btree *rchild;  
  9.     char item;  
  10. } btree;  
  11.   
  12. typedef btree *bt;  
  13.   
  14. /** 
  15.  * 定义顺序栈数据结构(非递归遍历) 
  16.  */  
  17. typedef struct stack {  
  18.     btree *db[STACKSIZE];  
  19.     int top;  
  20. } stack;  


递归构建二叉树

构建二叉树有固定的几种考察类型：
  1. 根据完整的先序序列构建二叉树
  2. 根据前序和中序序列构建二叉树

根据先序序列构建二叉树（c语言实现）

[cpp] view plain copy
  1. char str[101] = "abc##de#g##f###";  
  2. int count = 0;  
  3.   
  4. /** 
  5.  * 根据先序序列构建二叉树(因为涉及到对根节点指针修改，因此传递根节点指针的指针) 
  6.  */  
  7. void createBtree(btree **t)  
  8. {  
  9.     if (str[count ++] == '#') {  
  10.         *t = NULL;  
  11.     } else {  
  12.         *t = (btree *)malloc(sizeof(btree));  
  13.         (*t)->item = str[count - 1];  
  14.         createBtree(&(*t)->lchild);  
  15.         createBtree(&(*t)->rchild);  
  16.     }  
  17. }  

热潮

递归的前序、中序、后序算法（c语言实现）

[cpp] view plain copy
  1. /** 
  2.  * 递归先序遍历二叉树 
  3.  */  
  4. void recPreorder(btree *t)  
  5. {  
  6.     if (t) {  
  7.         printf("%c", t->item);  
  8.         recPreorder(t->lchild);  
  9.         recPreorder(t->rchild);  
  10.     }  
  11. }  
  12.   
  13. /** 
  14.  * 递归中序遍历二叉树 
  15.  */  
  16. void recInorder(btree *t)  
  17. {  
  18.     if (t) {  
  19.         recInorder(t->lchild);  
  20.         printf("%c", t->item);  
  21.         recInorder(t->rchild);  
  22.     }  
  23. }  
  24.   
  25. /** 
  26.  * 递归后序遍历二叉树 
  27.  */  
  28. void recPostorder(btree *t)  
  29. {  
  30.     if (t) {  
  31.         recPostorder(t->lchild);  
  32.         recPostorder(t->rchild);  
  33.         printf("%c", t->item);  
  34.     }  
  35. }  


非递归前序、中序遍历算法(c语言实现)

[cpp] view plain copy
  1. /** 
  2.  * 非递归前序遍历 
  3.  */  
  4. void preorderTraverse(btree *t)  
  5. {  
  6.     btree *p = t;  
  7.   
  8.     // 初始化栈  
  9.     stack *s = (stack *)malloc(sizeof(stack));  
  10.     s->top = 0;  
  11.   
  12.     while (p || s->top > 0) {  
  13.         if (p) {  
  14.             printf("%c", p->item);  
  15.             s->db[s->top ++] = p;  
  16.             p = p->lchild;  
  17.         } else {  
  18.             p = s->db[-- s->top];  
  19.             p = p->rchild;  
  20.         }  
  21.     }  
  22. }  
  23.   
  24. /** 
  25.  * 非递归中序遍历 
  26.  */  
  27. void inorderTraverse(btree *t)  
  28. {  
  29.     btree *p = t;  
  30.   
  31.     // 初始化栈  
  32.     stack *s = (stack *)malloc(sizeof(stack));  
  33.     s->top = 0;  
  34.   
  35.     while (p || s->top > 0) {  
  36.         if (p) {  
  37.             s->db[s->top ++] = p;  
  38.             p = p->lchild;  
  39.         } else {  
  40.             p = s->db[-- s->top];  
  41.             printf("%c", p->item);  
  42.             p = p->rchild;  
  43.         }  
  44.     }  
  45. }  


非递归后序遍历算法(c语言实现)

算法思想：

  1. 首先，也是找到最左边的叶子结点并把路上遇到的节点依次入栈
  2. 然后，弹出栈顶元素(该元素为最左边的叶子)，判断（1）它是否有右节点（2）如果有右节点，是否被访问过。如果满足（1）有右节点并且（2）右节点没有访问过，说明这是后序遍历的相对根节点，因此需要将这个节点再次入栈，并且它的右节点入栈，然后重新执行第一步。否则，就访问该节点，并且设置pre为此节点，同时把将遍历节点附空值，访问进入无限循环

算法代码：

[cpp] view plain copy
  1. /** 
  2.  * 非递归后序遍历 
  3.  */  
  4. void postTraverse(btree *t)  
  5. {  
  6.     btree *p, *pre;  
  7.     p = t;  
  8.     pre = NULL;  
  9.   
  10.     // 初始化栈  
  11.     stack *s = (stack *)malloc(sizeof(stack));  
  12.     s->top = 0;  
  13.   
  14.     while (p || s->top > 0) {  
  15.         if (p) {  
  16.             s->db[s->top ++] = p;  
  17.             p = p->lchild;  
  18.         } else {  
  19.             p = s->db[-- s->top];  
  20.             if (p->rchild != NULL && p->rchild != pre) { // p为相对根节点  
  21.                 s->db[s->top ++] = p;  
  22.                 p = p->rchild;  
  23.             } else {  
  24.                 printf("%c", p->item);  
  25.                 pre = p;  
  26.                 p = NULL;  
  27.             }  
  28.         }  
  29.     }  
  30. }  

注意：

严蔚敏的<<数据结构>>上有一段话很经典，摘录如下：”从二叉树遍历的定义可知，三种遍历算法之不同处仅在于访问根节点和遍历左、右子树的先后关系。如果在算法中暂且抹去和递归无关的visit语句，则三个遍历算法完全相同。因此，从递归执行过程的角度来看，前序、中序、后序遍历也完全相同。“ 这段话给我们的提示就是，前序、中序、后序遍历的算法相同，只是printf()语句位置而已。


根据前序序列、中序序列构建二叉树

函数定义

[plain] view plain copy
  1. bt rebuildTree(char *pre, char *in, int len);  

参数：
* pre：前序遍历结果的字符串数组
* in：中序遍历结果的字符串数组
len : 树的长度
例如：
前序遍历结果: a b c d e f g h
中序遍历结果: c b e d f a g h

算法思想

  1. 递归思想，递归的终止条件是树的长度len == 0
  2. 在中序遍历的数组中找到前序数组的第一个字符，记录在中序数组中的位置index.如果找不到，说明前序遍历数组和中序遍历数组有问题，提示错误信息，退出程序即可;找到index后，新建一个二叉树节点t，t->item = *pre,然后递归的求t的左孩子和有孩子
  3. 递归的左孩子：void rebuildTree(pre + 1, in, index)
  4. 递归的右孩子：void rebuildTree(pre + (index + 1), in + (index + 1), len - (index + 1))

实现代码（c语言版）

[cpp] view plain copy
  1. /** 
  2.  * Description:根据前序和中序构建二叉树 
  3.  */  
  4. bt rebuildTree(char *pre, char *in, int len)  
  5. {  
  6.     bt t;  
  7.     if(len <= 0)  
  8.     {   
  9.         //递归终止  
  10.         t = NULL;  
  11.     }else  
  12.     {   
  13.         //递归主体  
  14.         int index = 0;  
  15.           
  16.         while(index < len && *(pre) != *(in + index))  
  17.         {  
  18.             index ++;  
  19.         }  
  20.           
  21.         if(index >= len)  
  22.         {  
  23.             printf("前序遍历或者中序遍历数组有问题!\n");  
  24.             exit(-1);  
  25.         }  
  26.           
  27.         t = (struct bintree *)malloc(sizeof(struct bintree));  
  28.         t->item = *pre;  
  29.         t->lchild = rebuildTree(pre + 1, in, index);  
  30.         t->rchild = rebuildTree(pre + (index + 1), in + (index + 1), len - (index + 1));  
  31.     }  
  32.     return t;  
  33. }  

根据中序序列、后序序列构建二叉树

函数定义

[cpp] view plain copy
  1. /** 
  2.  * 中序、后序序列构建二叉树 
  3.  */  
  4. btree* rebuildTree(char *order, char *post, int len);  

算法思想

中序序列：C、B、E、D、F、A、H、G、J、I

后序序列：C、E、F、D、B、H、J、I、G、A

递归思路：

  1. 根据后序遍历的特点，知道后序遍历最后一个节点为根节点，即为A
  2. 观察中序遍历，A左侧CBEDF为A左子树节点，A后侧HGJI为A右子树节点
  3. 然后递归的构建A的左子树和后子树

实现代码(c代码)

[cpp] view plain copy
  1. /** 
  2.  * 根据中序和后序序列构建二叉树 
  3.  * (ps:昨晚参加阿里笔试，等到最后说可以免笔试直接面试，今天估计还是要根据学校筛选，哈哈，为了这点 
  4.  * 也得参加阿里笔试，不能让自己的学校受到鄙视) 
  5.  */  
  6.   
  7. #include <stdio.h>  
  8. #include <stdlib.h>  
  9. #include <string.h>  
  10.   
  11. int n;  
  12.   
  13. typedef struct btree {  
  14.     struct btree *lchild;  
  15.     struct btree *rchild;  
  16.     char data;  
  17. } btree;  
  18.   
  19. /** 
  20.  * 中序、后序序列构建二叉树 
  21.  */  
  22. btree* rebuildTree(char *order, char *post, int len)  
  23. {  
  24.     btree *t;  
  25.   
  26.     if (len <= 0) {  
  27.         return NULL;  
  28.     } else {  
  29.         int index = 0;  
  30.   
  31.         while (index < len && *(post + len - 1) != *(order + index)) {  
  32.             index ++;  
  33.         }     
  34.   
  35.         t = (btree *)malloc(sizeof(btree));  
  36.         t->data = *(order + index);  
  37.         t->lchild = rebuildTree(order, post, index);  
  38.         t->rchild = rebuildTree(order + index + 1, post + index, len - (index + 1));  
  39.     }  
  40.   
  41.     return t;  
  42. }  
  43.   
  44. /** 
  45.  * 前序遍历二叉树 
  46.  */  
  47. void preTraverse(btree *t)  
  48. {  
  49.     if (t) {  
  50.         printf("%c ", t->data);  
  51.         preTraverse(t->lchild);  
  52.         preTraverse(t->rchild);  
  53.     }  
  54. }  
  55.   
  56. int main(void)  
  57. {  
  58.     int i;  
  59.     char *post, *order;  
  60.     btree *t;  
  61.   
  62.     while (scanf("%d", &n) != EOF) {  
  63.         post = (char *)malloc(n);  
  64.         order = (char *)malloc(n);  
  65.           
  66.         getchar();  
  67.         for (i = 0; i < n; i ++)  
  68.             scanf("%c", order + i);  
  69.   
  70.         getchar();  
  71.         for (i = 0; i < n; i ++)  
  72.             scanf("%c", post + i);  
  73.   
  74.         t = rebuildTree(order, post, n);  
  75.   
  76.         preTraverse(t);  
  77.         printf("\n");  
  78.   
  79.         free(post);  
  80.         free(order);  
  81.   
  82.     }  
  83.   
  84.     return 0;  
  85. }  


递归清理二叉树

复习了c语言的内存分配，参考链接： http://blog.csdn.net/zinss26914/article/details/8687859， 要点就是malloc分配的内存在堆上，使用完后应该由程序员手动释放，这里写一下递归清理二叉树的代码

[cpp] view plain copy
  1. /** 
  2.  * 清理二叉树 
  3.  */  
  4. void cleanBtree(btree *t)  
  5. {  
  6.     if (t) {  
  7.         cleanBtree(t->lchild);  
  8.         cleanBtree(t->rchild);  
  9.         free(t);  
  10.     }  
  11. }  


后记

2012年今天是最后一天了，哈哈，终于把二叉树该掌握的部分都掌握了，还是不错的，期待新的一年2013年有更多的收获，2013年可能又是我人生发生抉择和变化的一年，我依然会坚持自己的价值观，踏踏实实的走下去，现在我学会最多的就是坚持，坚忍，光说不做是没有的，写程序如此，做人亦如此！

今天是2013年7月23日，重写了部分二叉树操作的代码，对指针的掌握和对数据结构的掌握更加熟练，希望校招一切顺利，自己加油！



你可能感兴趣的:(递归,冒泡排序,二叉树,遍历,冯诺依曼)

  • [前端算法]动态规划 摇光93 算法算法动态规划
    最优子结构,重叠子问题爬楼梯递归+记忆化搜索自顶向下varclimbStairs=function(n){letmap=[]functiondfs(n){if(n=coins[j]){dp[i]=Math.min(dp[i],dp[i-coins[j]]+1);}}}if(dp[amount]===Infinity){return-1;}returndp[amount];}01背包问题functi
  • 《递归算法：原理剖析与典型例题精解》 m0_dawn 算法数据结构蓝桥杯学习职场和发展
    目录一、递归算法概述二、递归的时间复杂度三、递归与循环的区别（一）结构与实现方式（二）适用场景四、递归的优点（一）代码简洁易读（二）逻辑清晰直观（三）易于扩展和修改五、递归的缺点（一）空间复杂度高（二）效率低下（未优化时）（三）难以理解（复杂递归）六、循环的优点（一）空间复杂度低（二）效率高（简单迭代）（三）易于调试七、循环的缺点（一）代码复杂度高（复杂逻辑）（二）逻辑不够直观（三）难以扩展和修改
  • python核心语法 DB_UP python杂集python
    目录一、生成器1.1列表生成式1.2创建生成器二、迭代器2.1迭代对象2.2iter()函数2.3生成器和迭代器之间的区别三、高阶函数3.1map函数3.2reduce3.3filter3.4sorted3.4.1选择排序3.4.2冒泡排序notebook主目录及pip镜像源修改python基础语法python核心语法matplotlib基本操作python常见统计分析处理函数一、生成器1.1列表
  • 11. 盛最多水的容器 年轮不改 LeetCode热题100算法leetcode
    该题也是一道双指针的典型题目，需要注意的是木桶效应。根据木桶效应，短板决定了容器的高；如果使用暴力遍历的方法，一个短板进行的循环是没有意义的。需要避开对短板的循环，来提升效率。本题的双指针开始的时候应放在数组的两端，这样开始拥有最大的宽度。每一次的缩短宽度都是在摸索是否存在最大的短板能够比初始来的大。左右指针进行比较，谁小，谁就往中间移动。classSolution{public:intmaxAr
  • day_03_查找算法、排序算法 幻影maple 数据结构与算法查找算法排序算法
    六算法的概念和评价1基本概念2评定标准3描述方式七常用的查找算法1线性查找算法顺序查找算法1算法流程2算法评价2二分查找算法折半查找算法1算法流程2算法评价八常用的排序算法1冒泡排序算法1算法流程2算法评价2插入排序算法1算法流程2算法评价3选择排序算法1算法流程2算法评价4快速排序算法1算法流程2算法评价六、算法的概念和评价1、基本概念算法就是指对解题方案准确而又完整的描述，是一系列解决问题的清
  • python实现冒泡排序完整算法_利用python实现冒泡排序算法实例代码 weixin_39610759
    利用python实现冒泡排序算法实例代码冒泡排序冒泡排序（英语：BubbleSort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序算法的运作如下：1、比较相邻的元素。如果第一个比第二个大（升序
  • 【DAY.2】PHP数据结构与算法_排序_冒泡排序 我是妖怪_ 天天学习冒泡排序算法php
    思路分析：循环逐个对比，从第一个开始，与下一个数字进行对比，若大于则交换位置，每循环一遍将最大的一个排到最后。（依次比较相邻的元素，两两比较，就可以最终将最大（小）的元素调整到最顶端、次顶端、、、）$arr=array(3,2,5,6,1,8,4,9);functionbubble_sort($arr){$len=count($arr);//判断数组是否为空if($len$arr[$i+1]){$
  • 程序设计思考：归零思想 hookby 程序设计
    “归零思想”是一种在程序设计中常用的思考方法，主要指的是通过将某些值或状态归零，来简化问题或解决复杂度。这个思想在许多领域中都可以找到应用，尤其是在处理问题时需要清理和重置状态，避免累积错误或多余的计算。下面是几个典型的应用场景：1.状态重置在某些算法中，特别是动态规划、回溯、递归等问题中，我们可能需要在每个阶段重置某些变量或状态，防止它们影响后续的计算。例如，在递归算法中，递归结束后可以通过将某
  • CDN如何实现内容分发 黑石云 边缘计算
    CDN（内容分发网络）实现内容分发主要依赖于其分布式架构和一系列关键技术。以下是CDN实现内容分发的主要步骤和机制：一、DNS解析与重定向当用户在浏览器中输入域名请求访问某个网站时，首先会向本地DNS服务器发起域名解析请求。如果本地DNS服务器没有缓存该域名的解析结果，它会递归地查询根DNS服务器和授权DNS服务器，直到获得域名对应的IP地址。如果该域名配置了CDN服务，本地DNS服务器会将域名的
  • 传感器融合(UWB+IMU+超声波)，使用卡尔曼滤波器和3种不同的多点定位算法(最小二乘、递归最小二乘和梯度下降)研究（Matlab代码实现） 科研_研学社 算法matlab开发语言
    欢迎来到本博客❤️❤️博主优势：博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。⛳️座右铭：行百里者，半于九十。本文目录如下：目录⛳️赠与读者1概述一、引言二、传感器介绍（一）UWB（超宽带）（二）IMU（惯性测量单元）（三）超声波传感器三、定位算法（一）卡尔曼滤波器（二）多点定位算法1.最小二乘法2.递归最小二乘法3.梯度下降法四、系统架构五、实验设计六、结果与讨论七、结论2运行结果3参考文献
  • 【3-4】《Java面向对象高级知识》——继承、重写和重载、final关键字、抽象类、接口、多态、Object类、内部类、包装类、可变参数、递归 美少女降临人世间 【Java精华笔记】已完结抽象类final关键字重写和重载Java面向对象内部类
    文章目录一、继承格式二、子类实例化内存分析三、super详解四、重写1、重写的概念2、重写和重载的区别五、final关键字六、抽象类1、抽象类的概念2、抽象类常见问题3、抽象类和普通类的区别七、接口1、面向接口编程思想2、接口的编写3、接口和抽象类的区别八、多态1、多态的体现2、instanceof九、Object类概述1、toString2、equals十、内部类概述1、成员内部类（了解）2、局
  • 使用 `du` 命令可以查看根目录下每个子目录占用的磁盘空间大小 abments linux常用命令linux
    使用du命令可以查看根目录下每个子目录占用的磁盘空间大小。查看根目录下子目录大小的命令sudodu-sh/*解释：du：显示文件和目录的磁盘使用情况。-s：只显示每个目录的总大小（不递归显示子目录）。-h：以人类可读的格式显示大小（如KB、MB、GB）。/*：表示根目录下的所有子目录和文件。输出示例：4.0K/bin12M/boot0/dev1.5G/etc32G/home8.0K/lib...每
  • python中的两种循环 怎么昵称都被占用啊 python练习python
    python中的两种循环for循环（计数循环）while循环（条件循环）两种循环的区别range函数跳出循环break示例continue示例循环嵌套循环练习循环，三大语言结构之一，当它满足条件时反复执行某一段代码的过程，在python中有两种循环命令，分别为for循环和while循环for循环（计数循环）python中常用的循环结构之一，可以遍历一个可迭代对象中的元素。因为for循环的循环次数是
  • 为什么算法很难掌握 浅墨cgz 算法
    算法之所以难以掌握，主要是因为以下几个原因：1.抽象性算法是对问题的抽象解决方案，通常不依赖于具体的编程语言或实现细节。初学者可能难以将抽象的逻辑转化为具体的代码。例如，动态规划（DP）的核心思想是将问题分解为子问题并存储中间结果，但这种抽象思维需要大量练习才能掌握。2.数学基础要求许多算法依赖于数学知识，例如：时间复杂度分析：需要理解大O表示法、递归关系等。图论算法：需要了解图的基本概念（如节点
  • 什么是DNS缓存？DNS缓存有什么用？ 国科云 缓存
    DNS缓存在DNS解析过程中发挥了重要作用，有效提升了解析速度和访问体验。那什么是DNS缓存，DNS缓存有什么用呢？接下来国科云简单介绍下。什么是DNS缓存？标准的DNS解析过程，需要进行全球递归查询，依次去请求根服务器、顶级服务器、权威服务器，最终获得解析记录，返回到客户端浏览器。这个过程涉及多级DNS服务器，产生明显的时延，影响最终的解析和访问速度。基于此，DNS系统中引入了缓存机制。DNS服
  • LeetCode 771. 宝石与石头 不玩return的马可乐 算法/题库leetcode算法职场和发展c++数据结构
    在本篇博客中，我们将探讨如何解决LeetCode上的第771题——宝石与石头。这个问题涉及到字符串的处理和集合的使用，是一个典型的编程问题，适合初学者练习。解题思路解决这个问题的关键在于如何高效地检查stones中的每个字符是否在jewels中。我们可以通过以下步骤来实现：使用集合存储宝石类型：首先，将jewels中的所有字符存储在一个集合中，这样可以在O(1)时间内检查一个字符是否是宝石。遍历石
  • 递归算法实践--到仓合单助力京东物流提效增收 程序员
    作者：京东物流李硕#一、背景京东物流到仓业务「对商家」为了减少商家按照京东采购单分货备货过程，对齐行业直接按照流向交接，提升商家满意度；「对京东」揽收操作APP提效；到仓合单功能应运而生；二、问题一次批量采购单（一次50或者100个采购单）需要根据不同的规则合并成多个订单；每一个采购单可以是不同的来源类型（自营和非自营）、不同的收货类型，每一个采购单会有多个SKU，同一个SKU只有一个等级，一批采
  • 力扣148：排序链表 瀛台夜雪 力扣刷题链表leetcode数据结构
    力扣148：排序链表题目描述给你链表的头结点head，请将其按升序排列并返回排序后的链表。输入输出样例输入：head=[4,2,1,3]输出：[1,2,3,4]输入：head=[-1,5,3,4,0]输出：[-1,0,3,4,5]输入：head=[]输出：[]解法一，使用递归的归并排序，自顶向下，空间复杂度为O(logN)classSolution{public:ListNode*sortList
  • python 删除文件、目录_python删除文件和删除目录的方法 weixin_39778214 python删除文件目录
    下面来看一下python里面是如何删除一个文件及文件夹的~~首先引入OS模块importos删除文件：os.remove()删除空目录：os.rmdir()递归删除空目录：os.removedirs()递归删除目录和文件（类似DOS命令DeleteTree）：方法1：#Deleteeverythingreachablefromthedirectorynamedin'top',#assumingth
  • 【机器学习：二十六、决策树】 KeyPan 机器学习机器学习决策树人工智能算法深度学习数据挖掘
    1.决策树概述决策树是一种基于树状结构的监督学习算法，既可以用于分类任务，也可以用于回归任务。其主要通过递归地将数据划分为子集，从而生成一个具有条件结构的树模型。核心概念节点（Node）：每个节点表示一个特定的决策条件。根节点（RootNode）：树的起点，包含所有样本。分支（Branch）：每个分支代表一个条件划分的结果。叶节点（LeafNode）：终止节点，表示最终的决策结果。优点直观可解释：
  • 【LeetCode】215. 数组中的第K个最大元素（Java） m0_70234528 LeetCode排序leetcode数据结构算法
    目录题目描述思路1：sort排序思路2：优先队列JavaPriorityQueue创建PriorityQueue将元素插入PriorityQueue访问PriorityQueue元素删除PriorityQueue元素遍历PriorityQueuePriorityQueue其他方法PriorityQueue比较器(comparator)思路3：快速排序思路4：快速选择排序题目描述给定整数数组nums
  • 力扣---螺旋矩阵 53488736abcdefg leetcode矩阵算法
    给你一个m行n列的矩阵matrix，请按照顺时针螺旋顺序，返回矩阵中的所有元素。示例1：输入：matrix=[[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]题解：1.首先设定上下左右边界2.其次向右移动到最右，此时第一行因为已经使用过了，可以将其从图中删去，体现在代码中就是重新定义上边界3.判断若重新定义后，上下边界交错，表明螺旋矩阵遍历结束，跳出循环
  • leetcode437.路径总和III 努力d小白 #二叉树java算法开发语言
    标签：前缀和问题：给定一个二叉树的根节点root，和一个整数targetSum，求该二叉树里节点值之和等于targetSum的路径的数目。路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。示例1：输入：root=[10,5,-3,3,2,null,11,3,-2,null,1],targetSum=8输出：3解释：和等于8的路径有3条，如图所示。示例
  • 力扣hot100之螺旋矩阵 竹杖芒鞋序行 跟无神刷算法题系列leetcode矩阵算法
    classSolution:defspiralOrder(self,matrix:List[List[int]])->List[int]:#用四个数对应4个遍历的方向[0,1,2,3]-[右，下，左，上]go_state=0#起始必须向右#record_matrix=[[0]*nfor_inrange(m)]n_0,n_1,n_2,n_3=0,0,0,0m,n=len(matrix),len(ma
  • 【Java数据结构】二叉树相关算法 回响N 算法数据结构java开发语言链表
    第一题：获取二叉树中结点个数得到二叉树结点个数，如果结点为空则返回0，然后再用递归计算左树结点个数+根结点（1个）+右树结点个数。publicintnodeSize(Noderoot){if(root==null)return0;returnnodeSize1(root.left)+nodeSize1(root.right)+1;}第二题：获取叶子结点的个数得到叶子结点个数和结点总数的做法相同，也
  • 蓝桥杯备赛笔记（七）排序 小魏´•ﻌ•` 蓝桥杯C++蓝桥杯笔记算法
    1.冒泡排序(1)冒泡排序的思想冒泡排序的思想是每次将最大的一下一下运动到最右边，然后将最右边这个确定下来。再来确定第二个大的，再确定第三个大的...对于数组a[]，具体的来说，每次确定操作就是从左往右扫描，如果a[i]>a[i+1]，我们就执行swap(a[i],a[i+1])将两项交换，然后再往右检查，这样可以找出最大的并将其丢到最右边。第一次确定操作是将a[i]~a[n]中最大的放到a[n]
  • mysql -- WITH RECURSIVE 语法 m0_74824592 mysql数据库sql
    引言在SQL中，WITHRECURSIVE是一个用于创建递归查询的语句。它允许你定义一个CommonTableExpression(CTE)，该CTE可以引用自身的输出。递归CTE非常适合于查询具有层次结构或树状结构的数据，例如组织结构、文件系统或任何其他具有自引用关系的数据。一、基本语法WITHRECURSIVEcte_name(column1,column2,...)AS(--非递归的初始部分
  • [leetcode] 24. 两两交换链表中的节点 会飞的大鱼人 leetcode题解leetcode链表算法数据结构dfsjava
    文章目录题目描述解题方法方法一：数组存储java代码复杂度分析方法二：递归java代码复杂度分析方法三：迭代java代码复杂度分析相似题目题目描述给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。示例1：输入：head=[1,2,3,4]输出：[2,1,4,3]示例2：输入：head=[]输出：[]示例3：输入：he
  • python 获取字典值 adixuan8152 python
    一、Python中的字典遍历方法：info={'name':'xiaoming','sex':'nan','age':20,'id':1}info2={'name':'hhh','sex':'nv','addr':'beijign'}第一种方法：#直接循环字典，循环的是字典的key，如果想循环的时候同时获取到key和value，那么就要用.items()方法fork,vininfo.items()
  • 57-SQL中WITH RECURSIVE的用法 烟火缠过客 MySQLsql数据库
    SQL中WITHRECURSIVE的用法文章目录SQL中WITHRECURSIVE的用法定义**WITHRECURSIVE结构通常包含以下几个关键部分：****1.CTE（CommonTableExpression，公用表表达式）：**2.递归查询的结构3.连接操作符：4.终止条件示例EXPLAIN定义WITHRECURSIVE是SQL中的一种高级查询结构，用于执行递归查询。递归查询是一种特殊的查
  • 书其实只有三类 西蜀石兰 类
    一个人一辈子其实只读三种书，知识类、技能类、修心类。 知识类的书可以让我们活得更明白。类似十万个为什么这种书籍，我一直不太乐意去读，因为单纯的知识是没法做事的，就像知道地球转速是多少一样（我肯定不知道），这种所谓的知识，除非用到，普通人掌握了完全是一种负担，维基百科能找到的东西，为什么去记忆？ 知识类的书，每个方面都涉及些，让自己显得不那么没文化，仅此而已。社会认为的学识渊博，肯定不是站在
  • 《TCP/IP 详解，卷1：协议》学习笔记、吐槽及其他 bylijinnan tcp
    《TCP/IP 详解，卷1：协议》是经典，但不适合初学者。它更像是一本字典，适合学过网络的人温习和查阅一些记不清的概念。 这本书，我看的版本是机械工业出版社、范建华等译的。这本书在我看来，翻译得一般，甚至有明显的错误。如果英文熟练，看原版更好： http://pcvr.nl/tcpip/ 下面是我的一些笔记，包括我看书时有疑问的地方，也有对该书的吐槽，有不对的地方请指正： 1.
  • Linux—— 静态IP跟动态IP设置 eksliang linuxIP
    一.在终端输入 vi /etc/sysconfig/network-scripts/ifcfg-eth0 静态ip模板如下： DEVICE="eth0" #网卡名称 BOOTPROTO="static" #静态IP（必须） HWADDR="00:0C:29:B5:65:CA" #网卡mac地址 IPV6INIT=&q
  • Informatica update strategy transformation 18289753290
    更新策略组件： 标记你的数据进入target里面做什么操作，一般会和lookup配合使用，有时候用0,1,1代表 forward  rejected rows被选中，rejected row是输出在错误文件里，不想看到reject输出，将错误输出到文件，因为有时候数据库原因导致某些column不能update，reject就会output到错误文件里面供查看，在workflow的
  • 使用Scrapy时出现虽然队列里有很多Request但是却不下载，造成假死状态 酷的飞上天空 request
    现象就是： 程序运行一段时间，可能是几十分钟或者几个小时，然后后台日志里面就不出现下载页面的信息，一直显示上一分钟抓取了0个网页的信息。 刚开始已经猜到是某些下载线程没有正常执行回调方法引起程序一直以为线程还未下载完成，但是水平有限研究源码未果。 经过不停的google终于发现一个有价值的信息，是给twisted提出的一个bugfix 连接地址如下http://twistedmatrix.
  • 利用预测分析技术来进行辅助医疗 蓝儿唯美 医疗
    2014年，克利夫兰诊所（Cleveland Clinic）想要更有效地控制其手术中心做膝关节置换手术的费用。整个系统每年大约进行2600例此类手术，所以，即使降低很少一部分成本，都可以为诊 所和病人节约大量的资金。为了找到适合的解决方案，供应商将视野投向了预测分析技术和工具，但其分析团队还必须花时间向医生解释基于数据的治疗方案意味着 什么。  克利夫兰诊所负责企业信息管理和分析的医疗
  • java 线程(一)：基础篇 DavidIsOK java多线程线程
                                                            &nbs
  • Tomcat服务器框架之Servlet开发分析 aijuans servlet
    最近使用Tomcat做web服务器，使用Servlet技术做开发时，对Tomcat的框架的简易分析： 疑问： 为什么我们在继承HttpServlet类之后，覆盖doGet(HttpServletRequest req, HttpServetResponse rep)方法后，该方法会自动被Tomcat服务器调用，doGet方法的参数有谁传递过来？怎样传递？ 分析之我见： doGet方法的
  • 揭秘玖富的粉丝营销之谜 与小米粉丝社区类似 aoyouzi 揭秘玖富的粉丝营销之谜
    玖富旗下悟空理财凭借着一个微信公众号上线当天成交量即破百万，第七天成交量单日破了1000万;第23天时，累计成交量超1个亿……至今成立不到10个月，粉丝已经超过500万，月交易额突破10亿，而玖富平台目前的总用户数也已经超过了1800万，位居P2P平台第一位。很多互联网金融创业者慕名前来学习效仿，但是却鲜有成功者，玖富的粉丝营销对外至今仍然是个谜。   　　近日，一直坚持微信粉丝营销
  • Java web的会话跟踪技术 百合不是茶 url会话Cookie会话Seession会话Java Web隐藏域会话
    会话跟踪主要是用在用户页面点击不同的页面时,需要用到的技术点   会话:多次请求与响应的过程     1,url地址传递参数,实现页面跟踪技术          格式:传一个参数的 url?名=值     传两个参数的 url?名=值 &名=值   关键代码
  • web.xml之Servlet配置 bijian1013 javaweb.xmlServlet配置
    定义： <servlet> <servlet-name>myservlet</servlet-name> <servlet-class>com.myapp.controller.MyFirstServlet</servlet-class> <init-param> <param-name>
  • 利用svnsync实现SVN同步备份 sunjing SVN同步E000022svnsync镜像
    1. 在备份SVN服务器上建立版本库    svnadmin create test 2. 创建pre-revprop-change文件     cd test/hooks/     cp pre-revprop-change.tmpl pre-revprop-change 3. 修改pre-revprop-
  • 【分布式数据一致性三】MongoDB读写一致性 bit1129 mongodb
    本系列文章结合MongoDB，探讨分布式数据库的数据一致性，这个系列文章包括： 数据一致性概述与CAP 最终一致性(Eventually Consistency) 网络分裂(Network Partition)问题 多数据中心(Multi Data Center) 多个写者(Multi Writer)最终一致性 一致性图表(Consistency Chart) 数据
  • Anychart图表组件-Flash图转IMG普通图的方法 白糖_ Flash
    问题背景：项目使用的是Anychart图表组件，渲染出来的图是Flash的，往往一个页面有时候会有多个flash图，而需求是让我们做一个打印预览和打印功能，让多个Flash图在一个页面上打印出来。   那么我们打印预览的思路是获取页面的body元素，然后在打印预览界面通过$("body").append(html)的形式显示预览效果，结果让人大跌眼镜：Flash是
  • Window 80端口被占用 WHY? bozch 端口占用window
    平时在启动一些可能使用80端口软件的时候，会提示80端口已经被其他软件占用，那一般又会有那些软件占用这些端口呢？    下面坐下总结：         1、web服务器是最经常见的占用80端口的，例如：tomcat , apache  , IIS , Php等等；         2
  • 编程之美-数组的最大值和最小值-分治法（两种形式） bylijinnan 编程之美
    import java.util.Arrays; public class MinMaxInArray { /** * 编程之美 数组的最大值和最小值 分治法 * 两种形式 */ public static void main(String[] args) { int[] t={11,23,34,4,6,7,8,1,2,23}; int[]
  • Perl正则表达式 chenbowen00 正则表达式perl
    首先我们应该知道 Perl 程序中，正则表达式有三种存在形式，他们分别是： 匹配：m/<regexp>;/ （还可以简写为 /<regexp>;/ ，略去 m） 替换：s/<pattern>;/<replacement>;/ 转化：tr/<pattern>;/<replacemnt>;
  • [宇宙与天文]行星议会是否具有本行星大气层以外的权力呢? comsci
          举个例子: 地球,地球上由200多个国家选举出一个代表地球联合体的议会,那么现在地球联合体遇到一个问题,地球这颗星球上面的矿产资源快要采掘完了....那么地球议会全体投票,一致通过一项带有法律性质的议案,既批准地球上的国家用各种技术手段在地球以外开采矿产资源和其它资源........    &
  • Oracle Profile 使用详解 daizj oracleprofile资源限制
    Oracle Profile 使用详解 转 一、目的： Oracle系统中的profile可以用来对用户所能使用的数据库资源进行限制，使用Create Profile命令创建一个Profile，用它来实现对数据库资源的限制使用，如果把该profile分配给用户，则该用户所能使用的数据库资源都在该profile的限制之内。 二、条件： 创建profile必须要有CREATE PROFIL
  • How HipChat Stores And Indexes Billions Of Messages Using ElasticSearch & Redis dengkane elasticsearchLucene
    This article is from an interview with Zuhaib Siddique, a production engineer at HipChat, makers of group chat and IM for teams. HipChat started in an unusual space, one you might not
  • 循环小示例，菲波拉契序列，循环解一元二次方程以及switch示例程序 dcj3sjt126com c算法
    # include <stdio.h> int main(void) { int n; int i; int f1, f2, f3; f1 = 1; f2 = 1; printf("请输入您需要求的想的序列："); scanf("%d", &n); for (i=3; i<n; i
  • macbook的lamp环境 dcj3sjt126com lamp
      sudo vim /etc/apache2/httpd.conf   /Library/WebServer/Documents 是默认的网站根目录   重启Mac上的Apache服务   这个命令很早以前就查过了，但是每次使用的时候还是要在网上查： 停止服务：sudo /usr/sbin/apachectl stop 开启服务：s
  • java ArrayList源码 下 shuizhaosi888 ArrayList源码
    版本 jdk-7u71-windows-x64   JavaSE7 ArrayList源码上：http://flyouwith.iteye.com/blog/2166890     /** * 从这个列表中移除所有c中包含元素 */ public boolean removeAll(Collection<?> c) {
  • Spring Security（08）——intercept-url配置 234390216 Spring Securityintercept-url访问权限访问协议请求方法
    intercept-url配置 目录 1.1     指定拦截的url 1.2     指定访问权限 1.3     指定访问协议 1.4     指定请求方法   1.1   &n
  • Linux环境下的oracle安装 jayung oracle
    linux系统下的oracle安装 本文档是Linux(redhat6.x、centos6.x、redhat7.x) 64位操作系统安装Oracle 11g(Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production)，本文基于各种网络资料精心整理而成，共享给有需要的朋友。如有问题可联系：QQ：52-7
  • hotspot虚拟机 leichenlei javaHotSpotjvm虚拟机文档
    JVM参数  http://docs.oracle.com/javase/6/docs/technotes/guides/vm/index.html   JVM工具 http://docs.oracle.com/javase/6/docs/technotes/tools/index.html   JVM垃圾回收 http://www.oracle.com
  • 读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活” noaighost Webnode.js
    读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活” 眼里的Node.JS 初初接触node是一年前的事，那时候年少不更事。还在纠结什么语言可以编写出牛逼的程序，想必每个码农都会经历这个月经性的问题：微信用什么语言写的？facebook为什么推荐系统这么智能，用什么语言写的？dota2的外挂这么牛逼，用什么语言写的？……用什么语言写这句话，困扰人也是阻碍
  • 快速开发Android应用 rensanning android
    Android应用开发过程中，经常会遇到很多常见的类似问题，解决这些问题需要花时间，其实很多问题已经有了成熟的解决方案，比如很多第三方的开源lib，参考 Android Libraries 和 Android UI/UX Libraries。 编码越少，Bug越少，效率自然会高。 但可能由于 根本没听说过、听说过但没用过、特殊原因不能用、自己已经有了解决方案等等原因，这些成熟的解决
  • 理解Java中的弱引用 tomcat_oracle java工作面试
    　不久之前，我 面试了一些求职Java高级开发工程师的应聘者。我常常会面试他们说，“你能给我介绍一些Java中得弱引用吗？”，如果面试者这样说，“嗯，是不是垃圾回收有关的？”，我就会基本满意了，我并不期待回答是一篇诘究本末的论文描述。 　　然而事与愿违，我很吃惊的发现，在将近20多个有着平均5年开发经验和高学历背景的应聘者中，居然只有两个人知道弱引用的存在，但是在这两个人之中只有一个人真正了
  • 标签输出html标签" target="_blank">关于标签输出html标签 xshdch jsp
    http://back-888888.iteye.com/blog/1181202 关于<c:out value=""/>标签的使用，其中有一个属性是escapeXml默认是true(将html标签当做转移字符，直接显示不在浏览器上面进行解析)，当设置escapeXml属性值为false的时候就是不过滤xml，这样就能在浏览器上解析html标签， &nb
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他