手写代码 （总结）

首先总结问题，我把注意力过多的放到编写代码的规范上了。舍本逐末，忘记了正确性。其实这是一个绝佳的机会，再次错过了，以后就要更多的向软件开发的书籍多看和多阅读的了。一直在懊悔中，错过了好机会。

切记尊重规则，利用规则。切记认真小心，代码就是一个程序员的最简单最基础的功能，也是程序员的面子。

后面编写代码，首先看功能，随后找测试样例，随后找边界条件。随后编写完毕代码之后可以测试一下再提交的。循环多轮迭代，第一步和每一步的检查。

所有我所说的东西，一定要自己的提前准备。所有的原理，所有的词语，所有的方法的适用条件。

还有就是如果面试官问道你已经准备的题目你最好就默不作声的把这个问题做好，不要告诉他你已经准备过了。这个真是很不礼貌也很不利于你自己的评分的选择。

一定要做到万无一失，珍惜任何一个机会。

该文章总结了常用的基础问题的实现：

1. atoi实现：

int atoi(char *nptr1)

{

char * nptr=nptr1;

bool is_positive=true;

int sum=0;

if(*nptr=='-'){

is_posotive=false;

nptr++;

}

for(;nptr!='\0';nptr++)

{

sum = sum*10 + (*nptr-'0');

}

if(is_posotive=false)

sum=-sum;

return sum;

}

2. 快速排序实现：

int Partition(int a[],int l,int r)

{

int left=l;

int tem=a[l];

int tem1;

for(int i=l+1;i<r;i++){

if(a[i]<=tem){

left++;

tem1=a[left];

a[left]=a[i];

a[i]=tem1;

}

}

tem1=a[left];

a[left]=a[l];

a[l]=tem1;

return left;

}

void Qsort(int a[],int l,int r)

{

int split=Partition(a,l,r);

if(split-1>l){

Qsort(a,l,split-1);

}

if(split+1<r)

Qsort(a,split+1,r);

}

3. 堆排序实现：

int HeapAdjust(int a[],int i,int n){

int tem;

int min_p=2*i;

if(2*i<n){

min_p=2*i;

}

if(2*i+1<n){

if(a[2*i+1]>a[2*i])

{

min_p=2*i+1;

}

}

if(a[min_p]>a[i]){

tem=a[min_p];

a[min_p]=a[i];

a[i]=tem;

if(2*min_p<n)

HeapAdjust(a,min_p,n);

}

}

int Heap_sort(int a[],int n){

int i,tem;

for(i=n/2;i>=0;i--){

HeapAdjust(a,i,n);

}

for(i=0;i<n-1;i++){

tem=a[0];

a[0]=a[n-i];

a[n-i]=tem;

HeapAdjust(a,0,n-i-1);

}

}

3. 字符串子串查找实现：

int strstr(char *str_parent, char *str_substring){

char *str_parent_ori=str_parent;

char *p_parent,*p_substring;

for(;*str_parent!='\0';){

p_parent=str_parent;

for(p_substring=str_substring;*p_substring!='\0';){

if(*p_substring==*p_parent){

p_substring++;

p_parent++;

if(*p_substring=='\0'){

return (str_parent-str_parent_ori);

}

}

else

break;

}

str_parent++;

}

return -1;

}

4. 数组最大值数组和。

int Max_subArray(int array[],int length){

int max_sum=0;

int tem_sum;

int i,j;

for(i=0;i<length;i++)

{

for(j=i,tem_sum=0;j<length;j++){

tem_sum += array[j];

if(max_sum<tem_sum)

max_sum=tem_sum;

}

}

return max_sum;

}

5. 整数数字高低位反转：

int Inverse_Int(int source){

source = ( ((source&0xffff0000)>>16) | ((source&0x0000ffff)<<16) );

source = ( ((source&0xff00ff00)>>8) | ((source&0x00ff00ff)<<8) );

source = ( ((source&0xf0f0f0f0)>>4) | ((source&0x0f0f0f0f)<<4) );

source = ( ((source&0xcccccccc)>>2) | ((source&0x33333333)<<2) );

source = ( ((source&0xaaaaaaaa)>>1) | ((source&0x55555555)<<1) );

return source;

}

6. KMP实现：

kmp这个问题确实比较难，我在努力编写。我只是处在刚刚理解kmp代码中。。。

7. 设计实现双向循环队列（囧这个太囧了）：

class Mutual_Rotate_List{

int head;

int tail;

int *array1;

int _length;

Mutual_List(int length):_length(length){

array1=new int[length];

head=tail=0;

}

~Mutual_List(){

delete(array1);

}

bool Push_head(int data){

head=(head+1)%_length;

if(head==tail)

return false;

array1[head]=data;

return true;

}

int Pop_head(){

if(head==tail)

return -1;

int tem=array1[head];

head=(head-1+_length)%_length;

return tem;

}

bool Push_tail(int data){

tail=(tail-1+_length)%_length;

if(tail==head)

return false;

array1[tail]=data;

return true;

}

int Pop_tail(){

int tem=array1[tail];

tail=(tail+1)%_length;

if(tail>head)

return false;

return tem;

}

};

8. 模版：

template<typename T1, typename T2>

class myClass{

private:

T1 I;

T2 J;

public:

myclass(T1 a, T2 b);

void show();

};

template <typename T1, typename T2>

myCass<T1, T2>::myClass(T1 a, T2 b):I(a),J(b){}

myClass<int,int> class1(3,5);



如果你要找软件开发相关的职位，那么基础是第一位的，其次是coding的能力，可以写出正确和高效的代码（正确优先），第三便是算法能力。切勿粉末倒置。

无论是什么原因、什么结果，一定要认真准备，一定要保持自己学习和探索的能力，不断提升自己。

功能-》鲁棒性-》可读性-》健壮性。多注意 一点一点的加油。