《程序员面试宝典》-学习笔记。
也许你现在还用不到它，先看看吧，指不定什么时候就用上了呢！这不是杞人忧天，而是未雨绸缪！
一般有3种，网络工程师，测试工程师，软件开发人员。
外企对设计模式，软件度量等方面试题的喜爱有增无减。
求职五部曲，笔试，电话面试，面试，签约，违约。
公司除了询问你的项目经验之外，最好的询问方式就是考量你的基本功，包括编程风格，赋值语句等等，
设计模式，是解决某一类问题的一般性解决方案，
35岁退休其实是一种误解，只要我们规划好我们的职业生涯，提高技术水平，沟通技巧，管理能力，完全可以像国外程序员一样工作到60再退休，
纸的简历相比于电子简历有一种亲切感，重视程序也高一些。
据统计，80%的简历都是不合格的。
一般来说学习经历从大学写起，再早的除非有特殊成就，就不用写，
对于荣誉证书，成绩单，列出即可，不用附图，企业感兴趣会要求你带上的，
不要为了一次面试机会编写虚假简历，
要写出自己的特点，否则会让HR认为你什么都合适，其实也就是什么都不合适，
针对性的简历，按照对方的要求，突出自己的相关经历，
一般不要写上资质要求，太高，企业雇不起；太低，容易让企业觉得你无足轻松，
而且对第一份工作来说，资质不重要，不要费太多脑经，
个人信息写必须的即可，国家单位要写上政治面貌，
不要用太多措辞表达工作业绩，
某方面知识的掌握程序，可以分为精通，掌握，熟悉，理解，让人一目了然，
简历模板，
姓名，电话，方便他人联系，
毕业学校，专业，时间，
项目，反应能力，
兴趣爱好，反应工作生活态度，
p21，一份具体的项目模板，
里面包含一份个人评价，
外企，出题，答题，都用英文，不一定要通过CET6，
智力测试，占比很少，3%~5%,有些甚至没有，
不同公司侧重不同，
偏硬件公司考C++，指针，数据结构多些，
偏软件公司考设计模式，模板多，
面试官，喜欢考你纸上写程序，
电话面试主要是对简历模糊信息的确认，验证，
一般的IT公司对技术人员的着装要求都不会太高，关键是精神状态好，
面试官针对某个项目反复提问，他可能特别精通，或者以后这方面的技术使用的较多，
架构师一般会考行业背景，UML建模及工具的使用，
不熟悉的内容，可以沉默，不要尴尬和紧张，
正式的offer会提供，
薪水（税前or税后），
补助（税前or税收），
工作职位，
工作时间，地点，
保险，公积金等福利，
签约前一定要弄清楚，
1，户口是否解决，跳巢后有些单位要看户口，结婚出国等也有影响，
如果不长呆北京，就不是很重要，
五险指的是，养老保险，医疗保险，失业保险，人身意外伤害保险，生育保险，
一金指的是，住房公积金，
工资扣得多，公司帮你缴费也越多，
从某种程度上来讲，良好的培训比优厚的待遇更有吸引力，
大公司，文档优先，
架构师，可能不知道很多技术细节，
一些，高手，也只是在他那个领域精通，
平均工资高的行业，平均压力也大，
其实选什么行业，真的不重要，事情是人做出来的，快乐是最重要的，
不会有一件事情，让大家都变成功，历史上不曾有，将来也不曾有，
好，不是少干活，多拿钱，
我来给你加强下过程的理解，
开始count=0，
count=1，
10011100001111
&
10011100001110
=
10011100001110，
count=2，
10011100001110
&
10011100001101
=
10011100001100，
这么给你说吧，
十进制4用二进制表示为0100，
十进制4减1后，对应二进制要调位，0011，
两者相与，就为0，
后面不停这种循环，
结论就是，一次消灭一个二进制中的1，
5.2例题1，
！x++，
我想说的是，位！操作，并没有改变x的值，
至于后置++，没理解错误，做个简单总结，后置++，就是当前那一块操作，最后才进行，
5.2例题2，
总结下，我去这个题，我又入坑了，
首先，后置++，比我想的还要后，
然后，printf函数，是从右到左输出的，
最终这个数组的状态是，129，7，8，9，10，
只有第一个改变了，
第二种写法好，部分运算放到外面，提高效率，缺点是不够简洁，
我的总结是，浮点和整数的存储不同，
第二个，还是很值得去分析下的，
47page，例题2，
一个是不同数据类型，字节长度不同，发生截断，
一个是改变的是指针的类型，没有改变数据本身的意义，故结果没变，
51page，例题1，
感觉，有点超出我要用的了，
http://www.cnblogs.com/qytan36/archive/2010/09/27/1836569.html
讲了char和unsigned的区别，可以学习，
这个题，开拓思路，不错，
58page，和朱老师讲过的同类问题，
定义宏，返回两个参数中较小的一个，
#define MIN(A,B)( (A)<=(B) ? (A):(B) )
这里，对结构体大小的讲解，挺全面，
sizeof（），A和B分别是6，8，
long，一般4字节，
short，一般2字节，
char，1字节，
主要看后两段的讲解，
double，在32位中也占用8个字节，这点倒是要注意，
其它就是与之前重叠的知识点了，
http://blog.csdn.net/lyl0625/article/details/7350045
这篇文章讲了16，32，64位环境下不同数据占用空间的大小，
page69，不想看了，
一个空类，占用空间是1，
单一继承的空类，占用空间也是1，
涉及虚继承的，由于有虚指针，所以大小为4，
int *pi;
*pi = 5;
这是错误的，因为你不知道指向谁，
这道题是错的，
我想说的是，
调用的函数申请的内存和str没有关系，具体自己理解，不多说，
然后strcpy函数第一个参数，需要有内存，
指向指针的指针，这个例子不错，
char* strA()
{
char str[] = "hello world";
return str;
}你可以在char *前面加const，
不用数组申请，用指针申请，
int main()
{
int a[3];
a[0] = 0;
a[1] = 10;
a[2] = 20;
int *p, *q;
p = a;
q = &a[2];
cout<<q-p<<endl; //2
cout<<a[q-p]<<endl; //20
system("pause");
return 0;
}q-p的实际运算是，q的地址减去p的地址，再除以sizeof（int），即2，
page84，好恶心，
感觉这种复杂度的，不会用吧，
答案是 int （*a【10】）（int）；
这个题和上面很想，感觉不是那么突兀了，
结果是2，5
数组名本身就是指针，再加上个&，就变成了双指针，这里的双指针就是指二维数组，加1，就是数组整体加一行，
这个解释方法也是挺新奇，
空指针和迷途指针的区别，
当delete一个指针后，实际上仅仅是让编译器释放内存，指针本身依然存在，这时就是迷途指针，
为这个指针赋值0，就变为空指针了，
不同的是，迷途指针的值，带有随机性，因此似乎能访问，但是潜存危险，
而空指针，一般0地址，我没记错的话，是硬件级别不能访问的，
第8部分，循环，递归与概率，没怎么看，
page108，没看懂嘎，
面向对象的基本概念是什么，
对象，类和继承，
空类包含的成员函数，
除了有构造函数，析构函数，拷贝构造函数外，
还有一个赋值函数，这个好像不熟悉啊，
C++中的struct和class的区别是，默认权限不同，
struct的存在，是为了兼容以前的C项目，
停到119page，
位运算与嵌入式编程，
这个题也是有意思，对printf认识，更深入了，
%f代表浮点数，
float是单精度浮点数，占4字节，
double是双精度浮点数，占8字节，
page，164，
C++中的强制类型转换，
问题是，题目好怪，好怪的转换，
这道题也是类型转换的，
我觉得，暂时对我有用的是这些话，
page，108的例二，非常重要，之前C++学习的内存分析，这里很典型，
109page，例三，迭代器移动特点，很重要，
111page，普通函数，变为泛型函数，
有些时候，数据结构没变，就是数据变了，所以有容器，就省事多了，
一个空类，除了会产生，构造函数，析构函数，拷贝构造函数外，
还会产生赋值函数，应该就是=吧，
C++中的struct和class，差别不大，除了你熟悉的那些，
这个错误挺有意思，跑了下，编译都报错，
如果想把静态成员变量私有（即权限是private：），可以通过共有静态成员函数返回其值实现，
类中，初始化列表的初始化变量顺序是根据成员变量的声明顺序来执行的，
也挺经典的，
125page，是一个string类的实现，可以，挺全面，
有点看不懂啊，
这个调用的讲解，不错，
特别是这句，
关于继承，我觉得之前的理解是对的，
不过要补充说明一点的是，类中与类外，
比如私有继承基类的共有成员，那么在子类中可以访问这个继承过来的成员，但是在子类外部，就不能直接访问，
每个对象里有虚标指针，指向虚表，虚表里面存放了虚函数的地址，虚函数表是顺序存放虚函数地址的，不需要用到链表，
数据结构，多敲几遍，还有我想说的是，这几个数据结构的题，正好就是我们要掌握的类型，可以，挺好，
这个是单链表的相关代码，
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <conio.h>
using namespace std;
typedef struct student
{
int data;
struct student *next;
}node;
void print( node *head);
node* del( node *head, int num);
node *create();
node *sort( node *head);
void print( node *head);
int length( node *head);
node *reverse( node *head);
void searchmid( node *head, node *mid);
int main()
{
node *head, *mid;
int x = 0;
head = create();
print( head);
//printf("input you want delete");
//scanf("%d", &x);
//head = del( head, x);
head = sort( head);
print( head);
head = reverse( head);
print( head);
searchmid( head, mid);
printf("%d", mid->data);
system("pause");
return 0;
}
void searchmid( node *head, node *mid)
{
node *temp = head;
while( head->next->next !=NULL) //这里有问题
{
head = head->next->next;
temp = temp->next;
mid = temp;
}
}
node *reverse( node *head)
{
node *p1, *p2, *p3;
if( head ==NULL || head->next ==NULL)
{
return head;
}
p1 = head, p2 = p1->next;
while( p2) //这里稍微有点理解不过来，不过逆序是基础
{
p3 = p2->next;
p2->next = p1;
p1 = p2;
p2 = p3;
}
head->next = NULL;
head = p1;
return head;
}
node* del( node *head, int num)
{
node *p1, *p2;
p1 =head;
while( num!=p1->data && p1->next!=NULL)
{
p2 = p1;
p1 = p1->next;
}
if( num == p1->data)
{
if( p1 = head)
{
head = p1->next;
free( p1);
}
else
{
p2->next = p1->next;
}
}
else
{
printf("\n %d could not been found", num);
}
return head;
}
node *create()
{
node *head, *p, *s;
int x = 0, cycle = 1;
head = (node *)malloc( sizeof( node));
p = head;
while( cycle)
{
printf("\nplease input the data:");
scanf("%d", &x);
if( x!=0)
{
s = ( node *)malloc( sizeof( node));
s->data = x;
printf("\n %d", s->data);
p->next = s;
p = s;
}
else
cycle = 0;
}
head = head->next;
p->next = NULL;
printf("\n yyy %d", head->data);
return head;
}
node *sort( node *head)
{
node *p, *p2, *p3;
int n;
int temp;
n = length( head);
if( head == NULL||head->next == NULL)
return head;
p = head;
for( int j=1; j<n; ++j) //这个排序算法想不起来了，说明排序不熟悉
{
p = head;
for( int i =0; i<n-j; ++i)
{
if( p->data > p->next->data)
{
temp = p->data;
p->data = p->next->data;
p->next->data = temp;
}
p = p->next;
}
}
return head;
}
int length( node *head)
{
int n = 0;
node *p;
p = head;
while( p!=NULL)
{
p = p->next;
n++;
}
return n;
}
void print( node *head)
{
node *p;
int n;
n = length( head);
printf("\n now, these %d record are:\n", n);
p = head;
if( head!=NULL)
while( p!=NULL)
{
printf("\n uuu %d ", p->data);
p = p->next;
}
}
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <conio.h>
using namespace std;
typedef struct student
{
int data;
struct student *next;
struct student *pre;
}dnode;
dnode *creat();
void print( dnode *head);
int length( dnode *head);
dnode *del( dnode *head, int num);
dnode *insert( dnode *head, int num);
int main()
{
dnode *head =NULL;
int x;
head = creat();
print( head);
printf("input you want to del ");
scanf("%d", &x);
head = del( head,x);
print( head);
head = insert( head, x);
printf("%d is coming\n", x);
print( head);
system("pause");
return 0;
}
dnode *insert( dnode *head, int num)
{
dnode *p0, *p1;
p1 = head;
p0 = (dnode *)malloc( sizeof( dnode));
p0->data = num;
while( p0->data >p1->data && p1->next !=NULL)
{
p1 = p1->next;
}
if( p0->data <= p1->data)
{
if( head == p1)
{
p0->next = p1;
p1->pre = p0;
head = p0;
}
else
{
p1->pre->next = p0;
p0->next = p1;
p0->pre = p1->pre;
p1->pre = p0;
}
}
else
{
p1->next = p0;
p0->pre = p1;
p0->next = NULL;
}
return head;
}
dnode *del( dnode *head, int num)
{
dnode *p1, *p2;
p1 = head;
while( num!=p1->data && p1->next !=NULL)
{
p1 = p1->next;
}
if( num==p1->data)
{
if( p1 == head)
{
head = head->next;
head->pre = NULL;
free( p1);
}
else if( p1->next == NULL)
{
p1->pre->next = NULL;
free( p1);
}
else
{
p1->next->pre = p1->pre;
p1->pre->next = p1->next;
}
}
else
{
printf("\n %d could not been found", num);
}
return head;
}
void print( dnode *head)
{
dnode *p;
int n;
n = length( head);
printf("\n now, these %d records are :\n", n);
p = head;
if( head!=NULL)
while( p!=NULL)
{
printf("\n %d ", p->data);
p = p->next;
}
}
int length( dnode *head)
{
int n =0;
dnode *p;
p = head;
while( p!=NULL)
{
p = p->next;
n++;
}
return n;
}
dnode *creat()
{
dnode *head, *p, *s;
int x, cycle = 1;
head = ( dnode *)malloc( sizeof( dnode));
p = head;
while( cycle)
{
printf("\n please input the data:");
scanf("%d", &x);
if( x!=0)
{
s = ( dnode *)malloc( sizeof( dnode));
s->data = x;
printf("\n %d", s->data);
p->next = s;
s->pre = p;
p = s;
}
else
{
cycle = 0;
}
}
head = head->next;
head->pre = NULL;
p->next = NULL;
printf("\n %d", head->data);
return head;
}
循环链表代码，
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
typedef struct LNode{
int data;
struct LNode *link;
}LNode, *LinkList;
void JOSEPHUS( int n , int k, int m);
int main()
{
JOSEPHUS( 13, 0, 2);
system("pause");
return 0;
}
void JOSEPHUS( int n , int k, int m)
{
LinkList p , r, list, curr;
p = ( LinkList)malloc( sizeof(LNode));
p->data = 0;
p->link = p;
curr = p;
for( int i =1; i<n; i++)
{
LinkList t = ( LinkList)malloc(sizeof(LNode));
t->data = i;
t->link = curr->link;
curr->link = t;
curr = t;
}
r = curr;
while( k--) r=p, p=p->link;
while( n--)
{
for( int s = m-1; s--;r=p, p = p->link);
r->link = p->link;
printf("%d->", p->data);
free( p );
p = r->link;
}
}
队列的代码，
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <conio.h>
using namespace std;
typedef struct student
{
int data;
struct student *next;
}node;
typedef struct linkqueue
{
node *first, *rear;
}queue;
queue *insert( queue *HQ, int x)
{
node *s;
s = ( node *)malloc( sizeof( node));
s->data = x;
s->next = NULL;
if( HQ->rear == NULL)
{
HQ->first = s;
HQ->rear = s;
}
else
{
HQ->rear->next = s;
HQ->rear = s;
}
return HQ;
}
queue *del( queue *HQ)
{
node *p;
int x;
if( HQ->first == NULL)
{
printf("\n yichu");
}
else
{
x = HQ->first->data;
p = HQ->first;
if( HQ->first==HQ->rear)
{
HQ->first = NULL;
HQ->rear = NULL;
}
else
{
HQ->first = HQ->first->next;
free( p);
}
return HQ;
}
}
这是stack的代码，感觉有点问题啊，
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <conio.h>
using namespace std;
typedef struct student
{
int data;
struct student *next;
}node;
typedef struct stackqueue
{
node *zhandi, *top;
}stack;
stack *push( stack *HQ, int x)
{
node *s, *p;
s = ( node *)malloc( sizeof( node));
s->data = x;
s->next = NULL;
if( HQ->zhandi == NULL)
{
HQ->zhandi = s;
HQ->top = s;
}
else
{
HQ->top->next = s;
HQ->top = s;
}
return HQ;
}
stack *pop( stack *HQ)
{
node *p;
int x;
if( HQ->zhandi ==NULL)
{
printf("\n yi chu");
}
else
{
x = HQ->zhandi->data;
p = HQ->zhandi;
if( HQ->zhandi == HQ->top)
{
HQ->zhandi = NULL;
HQ->top = NULL;
}
else
{
while( p->next != HQ->top)
{
p = p->next;
}
HQ->top = p;
HQ->top->next =NULL;
}
return HQ;
}
}
我来说下我对D的排除，1234跑后面了，说明进栈了，可是顺序是没有逆序，说明就是错的，除非它又倒回左出口
用两个栈实现一个队列，为什么结果出来是错的，p191
排序那块，那个排序算法，想不起来了，要看，
逆序那块，中间有个小细节要注意，
那个只遍历一次就出结果的，while判断应该是问题的，
在双链表中，head就正好指向第一个数据节点，晕，我发现这里，单链表的head也是指向第一个数据节点，
字符串是重点，
assert宏的原型定义在<assert.h>中，其作用是如果它的条件返回错误，则终止程序执行，
int main()
{
//整数转换为字符串，
int num = 12345,j=0, i=0;
char temp[7], str[7];
while( num)
{
temp[i] = num%10+'0';
i++;
num = num/10;
}
temp[i] = 0;
cout<<temp<<endl;
i = i-1;
while( i>=0)
{
str[j] = temp[i];
j++;
i--;
}
str[j] = 0;
cout<<str<<endl;
system("pause");
return 0;
}
void LoopMove( char *pStr, int steps)
{ //字符串右移函数
int n = strlen(pStr) - steps;
char tmp[100];
memcpy( tmp, pStr+n, steps);
memcpy( pStr+steps, pStr, n);
memcpy( pStr, tmp, steps);
}
int main()
{
char s[] = "34512";
LoopMove( s, 2);//结果是123455
cout<<s<<endl;
system("pause");
return 0;
}
操作系统部分，和我需要的，关系也不大，
数据库部分，如果你觉得sql语句有必要的话，再来看看，
网络部分，也不知道该怎么记，
对等实体在一次交互作用中传送的信息单位称为（协议数据单元），
它包括控制信息和用户数据，
new和delete是运算符，
电话面试的组织方可能是第三方中介，因此问题多半是格式化的，单调的问题，
面试经历总结，
对于毕业生，那些要求本科且两年以上工作经验的，也可以试试，
招聘有工作经验的公司，多半会让你马上去上班，
公司招人多的时候，要求就会比较轻松，
需要人少的时候，相反，
一般来说，公司越大，管理制度越健全，分工越细，自己学到的东西也相对有限，
扫一扫
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
