上海大亚科技---2013年嵌入式工程师（笔试题）

最新推荐文章于 2020-07-26 12:00:00 发布

xiaopangzi313

最新推荐文章于 2020-07-26 12:00:00 发布

阅读量2.1k

点赞数

分类专栏： 10_笔/面试题集锦分析

本文链接：https://blog.csdn.net/xiaopangzi313/article/details/12495731

版权

10_笔/面试题集锦分析专栏收录该内容

46 篇文章 5 订阅

订阅专栏

1. 用两个栈实现一个队列，描述其算法

算法：

1) 入队：将序列入栈A

2) 出队：将序列全部出栈，再入栈B，然后，弹栈(弹一个元素)

2 、树的遍历方式有几种，如果按先序遍历出来的数存放到一个数组，则数组下标和节点位置的对应关系。

遍历方式：先序遍历、中序遍历、后序遍历

对应关系：略

3 . 什么是字节对齐，如果不字节对齐会出现什么后果。

自然对齐：如果一个变量的内存地址正好位于它长度的整数倍，他就被称做自然对齐

字节对齐：现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。

后果：会出现效率低下或者段错误

4. 数组和链表的区别

（1）逻辑结构。数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况，即在使用数组之前，就必须对数组的大小进行确定。而链表采用动态分配内存的形式实现，可以适应数据动态地增减的情况，需要时可以用new/malloc分配内存空间，不需要时用delete/free将已分配的空间释放，不会造成内存空间浪费，且可以方便地插入、删除数据项。

（2）内存结构。（静态）数组从栈中分配空间，对于程序员方便快速，但是自由度小。链表从堆中分配空间，自由度大，但是申请管理比较麻烦。

（3）数组中的数据在内存中是顺序存储的，而链表是随机存储的。数组的随机访问效率很高，可以直接定位，但插入、删除操作的效率比较低。链表在插入、删除操作上相对数组有很高的效率，而如果要访问链表中的某个元素的话，那就得从表头逐个遍历，直到找到所需要的元素为止，所以，链表的随机访问效率比数组低。

（4）链表不存在越界问题，数组有越界问题。数组便于查询，链表便于插入删除，数组节省空间但是长度固定，链表虽然变长但是占了更多的存储空间。

5.画出TCP、IP 模型图，IP 报头有哪些组成

（1）TCP/IP 模型图

（2）IP报头

6. OSI 7层模型数据封装顺序。TCP /UDP 属于那一层？ TCP/UDP 有何优缺点？

打包顺序：用户数据 --> 应用层协议头 -->TCP/UDP 头 --> IP 头 --> 以太网头

TCP/UDP　　属于传输层

1）TCP

优点：提供高可靠性通信

缺点：实时性不好

2） UDP

优点：效率高，实时性好

缺点：不保证可靠

7. 七层模型的网络层与传输层的作用

网络层 : 数据分组、路由选择

传输层：提供端对端的交换数据机制

8. 接触过的文件系统有哪些，他们都有哪些区别

Linux 下常见的文件系统有： EXT2、EXT3.、EXT4 、reiserfs

1）ext2 文件系统；
ext2文件系统应该说是Linux正宗的文件系统，早期的Linux都是用ext2，但随着技术的发展，大多Linux的发行版本目前并不用这个文件系统了；比如Redhat和Fedora 大多都建议用ext3 ，ext3文件系统是由ext2发展而来的。对于Linux新手，我们还是建议您不要用ext2文件系统；ext2支持undelete（反删除），如果您误删除文件，有时是可以恢复的，但操作上比较麻烦； ext2支持大文件；
2）ext3 文件系统：是由ext2文件系统发展而来；
ext3 is a Journalizing file system for Linux（ext3是一个用于Linux的日志文件系统），ext3支持大文件；但不支持反删除（undelete）操作； Redhat和Fedora都力挺ext3;
3）reiserfs 文件系统；
reiserfs 文件系统是一款优秀的文件系统，支持大文件，支持反删除（undelete）；

4）EXT4

Ext4是一种针对ext3系统的扩展日志式文件系统,是专门为 Linux 开发的原始的扩展文件系统（ext 或 extfs）的第四版。 Linux kernel 自 2.6.28 开始正式支持新的文件系统 Ext4。 Ext4 是 Ext3 的改进版，修改了 Ext3 中部分重要的数据结构，而不仅仅像 Ext3 对 Ext2 那样，只是增加了一个日志功能而已。Ext4 可以提供更佳的性能和可靠性，还有更为丰富的功能

嵌入式linux 常用的文件系统就有： jffs2, yaffs, cramfs, romfs, ramdisk, ramfs/tmpfs等。

jffs2：主要用于NOR型闪存，基于MTD驱动层，特点是：可读写的、支持数据压缩的、基于哈希表的日志型文件系统，并提供了崩溃/掉电安全保护，提供“写平衡”支持等。缺点主要是当文件系统已满或接近满时，因为垃圾收集的关系而使jffs2的运行速度大大放慢

Yaffs: yaffs/yaffs2是专为嵌入式系统使用NAND型闪存而设计的一种日志型文件系统。与jffs2相比，它减少了一些功能(例如不支持数据压缩)，所以速度更快，挂载时间很短，对内存的占用较小。另外，它还是跨平台的文件系统，除了Linux和eCos，还支持WinCE, pSOS和ThreadX等

Cramfs:一种只读的压缩文件系统,它也基于MTD驱动程序。在cramfs文件系统中，每一页(4KB)被单独压缩，可以随机页访问，其压缩比高达2:1,为嵌入式系统节省大量的Flash存储空间，使系统可通过更低容量的FLA一种简单的、紧凑的、只读的文件系统，不支持动态擦写保存，按顺序存放数据，因而支持应用程序以 XIP(eXecute In Place，片内运行)方式运行，在系统运行时，节省RAM空间。SH存储相同的文件，从而降低系统成本。

ramfs/tmpfs:Ramfs是Linus Torvalds开发的一种基于内存的文件系统，工作于虚拟文件系统(VFS)层，不能格式化，可以创建多个，在创建时可以指定其最大能使用的内存大小。(实际上，VFS本质上可看成一种内存文件系统，它统一了文件在内核中的表示方式，并对磁盘文件系统进行缓冲。)

NFS :NFS是由Sun开发并发展起来的一项在不同机器、不同操作系统之间通过网络共享文件的技术。在嵌入式Linux系统的开发调试阶段，可以利用该技术在主机上建立基于NFS的根文件系统，挂载到嵌入式设备，可以很方便地修改根文件系统的内容。以上讨论的都是基于存储设备的文件系统(memory-based file system)，它们都可用作Linux的根文件系统。

Window下常用的文件系统有： FAT16、FAT32、NTFS

1）FAT16

FAT16文件系统是从MS-DOS发展过来的一种文件系统，最大只能管理2GB的硬盘空间。其优点是它是一种标准的文件系统，如果将分区划分成FAT16文件系统，几乎所有的操作系统都可读写用这种格式存储的文件，包括Linux和UNIX等。

2）FAT32

FAT32文件系统可管理的硬盘空间高大2048GB，与FAT16相比，提高了存储空间的使用效率，缺点是兼容性没有FAT16好，只有Windows95OSR2、Windows98、Windows2000和WindowsXP可以访问。

3）NTFS

NTFS文件系统。它增加了对文件访问权的控制等保密措施。目前能识别NTFS文件系统的操作系统只有Windows NT、Windows2000和Windows XP。

9. 引用和指针的区别

Int m ,j;

Int &i = m ; // i 就是m 的引用

//Int & i = j ; XXXXX

（1）引用访问一个变量是直接访问，而指针是间接访问。
（2）引用是一个变量的别名，本身不单独分配自己的内存空间，而指针有自己的内存空间。
（3）引用在开始的时候必须初始化

10. Internet 采用哪种网络协议？该协议有哪些层次结构？

Internet 采用TCP/IP 协议

层次结构：从上到下依次为，应用层 + 传输层 + 网络层 + 数据接口与物理层

11 . 用预处理指令#define 声明一个常数，用以表名一年之中有多少秒？

#define Ｎ (365*24*3600)UL

12 . 重启网络服务，nfs，修改dns 和 ip地址所用的命令

重启网络： Sudo /etc/init.d/networking restart

//Sudo service network restart

重启nfs： sudo /etc/init.d/nfs-kernel-server restart

修改DNS ：echo "nameserver 8.8.8.8 ">> /etc/resolv.conf

修改IP ：ifconfig eth0 192.168.0.12 netmask 255.255.255.0

13 .路由表的作用是什么？普通路由表的查找过程，linux 如何配置一条默认路由

路由表：表中每条路由项都指明了要到达某个子网或某台主机的IP报文应通过路由器的哪个物理接口发送，才能到达该路径上的下一个路由器，或者无须再经过别的路由器便可转发到直接相连的网络中的目的主机。

普通路由表的查找过程：

1）判断路由是否匹配，若没有匹配扔给默认网关

2）判断是否直连，若直连直接转发

3）否则，以下一跳作为目的地址

默认路由命令:route add –net 0.0.0.0 netmask 0.0.0.0 gw 192.168.0.1

14 . 简述 0，‘0’，“\0”,‘\0’的区别

0 : 表示数字0

‘0’: 字符 0

“0”：字符串0

‘\0’：字符串结束符

15 . 链表的增、删、改、查，注意内存泄露（头插、尾插）

1 #include <stdio.h>  
2 #include <stdlib.h>  
3    
4 typedef struct _LinkNode_   
5 {  
6 int data ;  
7 struct _LinkNode_ * next ;  
8 } LinkNode ;  
9    
10 LinkNode *create_linknode()  
11 {  
12 LinkNode *new = NULL ;  
13 new = (LinkNode *)malloc(sizeof(LinkNode));  
14 new->next = NULL ;  
15 return new ;  
16 }  
17    
18 LinkNode *init_linklist()  
19 {  
20 LinkNode * node = NULL ;  
21 node = create_linknode();  
22 return node ;  
23 }  
24    
25 int insert_linklist_head (LinkNode * head ,int data)  
26 {  
27 LinkNode * tmp = NULL ;  
28 tmp = create_linknode();  
29 tmp->data = data ;  
30    
31 tmp->next = head->next;  
32 head->next = tmp ;  
33 return 0 ;  
34 }  
35    
36 int printf_linklist(LinkNode *head)  
37 {  
38 while(head->next != NULL)  
39 {  
40 printf("%d\t",head->next->data);  
41 head = head->next ;  
42 }  
43 putchar('\n');  
44 return 0 ;  
45 }  
46    
47 int modify_linklist(LinkNode *head,int data_old,int data_new)  
48 {  
49    
50 while(head->next!= NULL)  
51 {  
52 if(head->next->data == data_old)  
53 head->next->data = data_new ;  
54 head = head->next ;  
55 }  
56 return 0 ;  
57 }  
58    
59 int search_linklist(LinkNode *head,int index)  
60 {  
61 LinkNode * p = head->next ;  
62 int tmp = index ;  
63 while(tmp -- )  
64 {  
65 p = p->next ;  
66 }  
67 printf("the %d data in the Linklist is %d\n",index,p->data);  
68    
69 return 0;   
70 }  
71    
72 int delete_linklist(LinkNode *head,int data)  
73 {  
74 LinkNode *temp ;  
75 while(head != NULL && head->next != NULL  )  
76 {  
77 temp = head->next ;  
78 if(head->next->data == data)  
79 head->next = temp->next ;  
80 else  
81 head = head->next ;  
82    
83 }  
84 return 0 ;  
85 }  
86    
87 int free_linklist(LinkNode *head)  
88 {  
89 LinkNode *p = head ,*temp;  
90    
91 while(p != NULL)  
92 {  
93 temp = p ;  
94 p = p->next ;  
95 free(temp);  
96 }  
97    
98 return 0;  
99 }  
100    
101 int insert_linklist_rear(LinkNode *head,int data )  
102 {  
103 LinkNode *node;  
104 node = create_linknode() ;  
105 node->data = data ;  
106 node->next = NULL ;  
107    
108 while(head->next != NULL)  
109 head = head->next ;  
110 head->next = node ;  
111    
112 return 0 ;  
113 }  
114    
115    
116 int reverse_linklist( LinkNode *head)   
117 {  
118 LinkNode *p ,*q  ;  
119 q = head->next ;  
120 head->next = NULL ;  
121 while(q != NULL)  
122 {  
123 p = q->next  ;  
124 q->next = head->next ;  
125 head->next = q ;  
126 q = p ;  
127 }  
128    
129 return 0 ;  
130 }  
131    
132    
133 int main(int argc, const char *argv[])  
134 {  
135 LinkNode * head  ;  
136 int i ;  
137 head = init_linklist() ;  
138    
139 #if 0  
140 for(i = 0; i < 10; i ++)  
141 insert_linklist_head(head,i);  
142 #endif   
143    
144 for(i = 0; i < 10; i ++)  
145 insert_linklist_rear(head,i);  
146 printf_linklist(head);  
147    
148 modify_linklist(head,3,4) ;  
149 printf_linklist(head);  
150 search_linklist(head,3);  
151 printf_linklist(head);  
152    
153 delete_linklist(head,4);  
154 printf_linklist(head);  
155    
156 reverse_linklist(head);  
157 printf_linklist(head);  
158    
159 free_linklist(head);  
160    
161 return 0;  
162 }  
163    
164    
165    
166    
167 16 .单链表反转  
168    
169 int reverse_linklist( LinkNode *head) // 带头结点的反转  
170 {  
171 LinkNode *p ,*q  ;  
172 q = head->next ;  
173 head->next = NULL ;  
174 while(q != NULL)  
175 {  
176 p = q->next  ;  
177 q->next = head->next ;  
178 head->next = q ;  
179 q = p ;  
180 }  
181    
182 return 0 ;  
183 }  
184    
 
185    
186 17 .实现内存拷贝函数  
187    
188 void memcpy(void *dest,void *src,int count)  
189 {  
190 if(src == NULL || dest == NULL)  
191         return -1 ;  
192      
193      if(dest <= src || dest >= src + conunt - 1)  
194 {  
195 while(count -- )  
196 {  
197 *dest ++ = *src ++ ;  
198    
199 }  
200    
201 }  
202     else  
203 {  
204 src_t = src + count - 1 ;  
205 dest_t = dest + count - 1 ;  
206 while(count --)  
207 {  
208 *dest_t -- = *src_t -- ;  
209 }  
210 }  
211    
212     return dest ;  
213 }  
214    
215 18 . 字符串，this is a test! 反转，test！ a  is this . 用代码实现  
216    
217 #include <stdio.h>  
218 #define N 32  
219    
220 int get_data(char *dest, int num);  
221 int reverse_word(char *str);  
222    
223 int main()  
224 {  
225 char buff[N];  
226    
227 get_data(buff,N);  
228 puts(buff);  
229 reverse_word(buff);  
230 puts(buff);  
231 return 0;  
232 }  
233    
234 void swap(char *head, char *tail)  
235 {  
236 while(head < tail)  
237 {  
238 *head ^= *tail;  
239 *tail ^= *head;  
240 *head ++ ^= *tail --;  
241 }  
242 }  
243    
244 int reverse_word(char *str)  
245 {  
246 char *head = str,  
247  *tail = str;  
248    
249 while('\0' != *tail)  
250 tail ++;  
251 swap(head, tail - 1);  
252    
253 while('\0' != *head)  
254 {  
255 while(32 == *head)  
256 head ++;  
257 tail = head;  
258 while(32 != *tail && '\0' != *tail)  
259 tail ++;  
260 swap(head, tail - 1 );  
261 head = tail;  
262 }  
263    
264    
265 return 0;  
266 }  
267    
268 int get_data(char *dest, int num)  
269 {  
270 char ch;  
271 int count = 0;  
272    
273 if(NULL == dest || num < 1)  
274 return 0;  
275    
276 while('\n' != (ch = getchar()) && count < num - 1)  
277 {  
278 if(ch >= 'a' && ch <= 'z')  
279 ;  
280 else if(ch >= 'A' && ch <= 'Z')  
281 ch += 32;  
282 else  
283 ch = 32;  
284 dest[count ++] = ch;  
285 }  
286 dest[count] = '\0';  
287 return count;  
288 }

xiaopangzi313

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
上海大亚科技---2013年嵌入式工程师（笔试题）

1. 用两个栈实现一个队列，描述其算法算法：1) 入队：将序列入栈A2) 出队：将序列全部出栈，再入栈B，然后，弹栈(弹一个元素) 2 、树的遍历方式有几种，如果按先序遍历出来的数存放到一个数组，则数组下标和节点位置的对应关系。遍历方式：先序遍历、中序遍历、后序遍历对应关系：略 3 . 什么是字节对齐，如果不字节对齐会出现什么后果。
复制链接

扫一扫