手写代码（总结）

最新推荐文章于 2023-12-11 13:33:34 发布

china1000

最新推荐文章于 2023-12-11 13:33:34 发布

阅读量2.4k

点赞数

分类专栏：基础知识C++

本文链接：https://blog.csdn.net/china1000/article/details/13016919

版权

基础知识C++ 专栏收录该内容

20 篇文章 2 订阅

订阅专栏

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

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

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

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

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

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

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

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;
}
};