面试题11:数值的整数次方
实现函数double Power(double base,int exponent),求base的exponent次方。不适用库函数,同时无需考虑大数问题。
思路:(抠细节、如何实现细节!)
题目简单,但要考虑周全,并且如何实现周全的方法也是关键。
考虑的问题:(1)base为0 (2)exponent<=0
因此这样写比较完备:
计算次方时,不考虑exponent的正负情况,而是直接计算base的|exponent|次方,再根据exponent的正负看是否需要取倒数。
还有一点,就是double情况下,判断是否为0,不能用==。而是应该计算与0.0的差,看是否在一个很小的范围内(例如:差的绝对值小于0.0000001,即该小数为0)
最后,需要注意强制类型转换。(将exponent的类型由int转为unsigned int)
#include <iostream>
using namespace std;
double Power(double base,int exponent);
double Power_Unsigned(double base,unsigned int exponent);
bool Equal(double a,double b);
int main()
{
cout<<Power(1.1,2)<<endl;
return 0;
}
double Power(double base,int exponent)
{
if(Equal(base,0.0)&&(exponent<0))
{
cout<<"Error!"<<endl;
return 0;
}
unsigned int absExponent;
if(exponent<0)
absExponent=(unsigned int)(-exponent);
else absExponent=(unsigned int)exponent;
double result=Power_Unsigned(base,absExponent);
if(exponent<0)
result=1.0/result;
return result;
}
double Power_Unsigned(double base,unsigned int exponent)
{
double result=1.0;
for(int i=0;i<exponent;i++)
{
result=result*base;
}
return result;
}
bool Equal(double a,double b)
{
if((a-b<0.0000001)||(a-b>-0.0000001))
return true;
else return false;
}
面试题12:打印1到最大的n位数(大数陷阱)
输入数字n,按顺序打印出从1到n最大的n位十进制数。比如输入3,则打印出1,2,3....999。
思路:
通常会想到计算出最大的n位数,可以直接计算10的n次方=max,按顺序输出1到max-1即可
然而,考虑到大数问题,就没这么简单了。
具体实现:
使用char数组模拟加法,每次加1,实现递增打印。
首先,将字符数组初始化为全'0',然后每次为字符串表示的数字模拟加1,打印出来,同时应判断是否达到最高位。
#include <iostream>
#include <cstring>
using namespace std;
bool If_Max(char* arr);
void Print_to_Max(int n);
void Print(char* arr);
int main()
{
int n;
cin>>n;
Print_to_Max(n);
return 0;
}
void Print_to_Max(int n)
{
if(n<=0) return;
char* arr=new char[n+1];
memset(arr,'0',n);
arr[n]='\0';
while(!If_Max(arr))
{
Print(arr);
}
}
bool If_Max(char* arr)
{
bool flag=false;
int jw=0;
int len=strlen(arr);
for(int i=len-1;i>=0;i--)//对所有位进行处理,但如果最低位没有进位的话,应该及时跳出循环。
{
int temp=arr[i]-'0'+jw;//第i位上值的大小(整数),用于判断该位是否有进位
if(i==len-1)//只有最后一位才+1
temp++;
if(temp>=10)
{
if(i==0) flag=true;//最高位产生进位则溢出!
else
{
temp-=10;
jw=1;
arr[i]='0';
}
}
else
{
arr[i]='0'+temp;
break;//如果最低位没有进位的话,则直接跳出循环,无需为高位进行处理!
}
}
return flag;
}
void Print(char* arr)
{
int len=strlen(arr);
bool start=false;
for(int i=0;i<len;i++)
{
if(arr[i]!='0')
start=true;
if(start)
cout<<arr[i];
}
cout<<'\t';
}
面试题13:在O(1)时间删除链表结点
思路:
通常情况,一般先遍历到被删除结点的前一个结点,在进行删除,但这样的时间复杂度是O(n),因此不能使用。
可以这样解决:
将被删除结点pNode的后一个结点pNext的值复制给pNode,改为删除pNext即可。
同时应考虑几个特殊情况:pNode为头结点,pNode为尾结点,该链表只有一个结点;
#include <iostream>
using namespace std;
struct ListNode
{
int m_nValue;
ListNode* m_pNext;
};
ListNode* CreateList(){ListNode* head=NULL; return head;}
void Insert(ListNode** head,int val);
void Print(ListNode* head);
void Delete(ListNode** head,ListNode* del);
int main()
{
ListNode* head=CreateList();
int val;
while(cin>>val)
Insert(&head,val);
Print(head);
Delete(&head,head);
Print(head);
return 0;
}
void Insert(ListNode** head,int val)
{
ListNode* temp=new ListNode();
temp->m_nValue=val;
temp->m_pNext=NULL;
if(*head==NULL)
*head=temp;
else
{
ListNode* p=*head;
while(p->m_pNext)
p=p->m_pNext;
p->m_pNext=temp;
}
}
void Print(ListNode* head)
{
if(head)
{
ListNode* p=head;
while(p)
{
cout<<p->m_nValue<<" ";
p=p->m_pNext;
}
}
cout<<endl;
}
void Delete(ListNode** head,ListNode* del)
{
if(!*head||!del)
return;
if(del->m_pNext)
{
ListNode* temp=del->m_pNext;
del->m_nValue=temp->m_nValue;
del->m_pNext=temp->m_pNext;
delete temp;
temp=NULL;
}
else if(*head==del)
{
delete del;
del=NULL;
*head=NULL;
}
else
{
ListNode *p=*head;
while(p->m_pNext!=del)
{
p=p->m_pNext;
}
p->m_pNext=del->m_pNext;
delete del;
del=NULL;
}
}
面试题14:调整数组顺序使奇数位于偶数前面
输入一个整数数组,实现一个函数来调整数组中数字的顺序,使得所有奇数位于数组的前半部分,偶数位于数组的后半部分。
思路1:
使用辅助数组temp,遍历数组arr,将遍历到所有奇数逐个放入temp中,再遍历一遍,将所有偶数放入temp剩余部分中;
最后同时遍历temp和arr,将arr中的元素用temp中的元素替换
思路2:
使用两个指针,分别指向第一个和最后一个元素,设为i,j(i<j),向后移动i,直到i指向的为偶数,开始向前移动j,直到指向的位奇数。若满足(i<j)则互换数据。直到i==j;
思路3:(一个扩展性的解法)在思路2的基础上进行修改
将思路2中,循环语句中的判断条件使用一个函数表示即可
#include <iostream>
using namespace std;
void Change1(int* arr,int len);
void Change2(int* arr,int len);
void Change3(int* arr,int len);
bool func(int i);
int main()
{
int arr[]={1,2,3,4,5};
int len=sizeof(arr)/sizeof(arr[0]);
// Change1(arr,len);
Change3(arr,len);
for(int i=0;i<len;i++)
cout<<arr[i]<<" ";
return 0;
}
void Change1(int* arr,int len)
{
if(!arr||len<=0)
return;
int temp[len];
int j=0;
for(int i=0;i<len;i++)
{
if(arr[i]%2==1)
temp[j++]=arr[i];
}
for(int i=0;i<len;i++)
{
if(arr[i]%2==0)
temp[j++]=arr[i];
}
for(int i=0;i<len;i++)
arr[i]=temp[i];
}
void Change2(int* arr,int len)
{
if(!arr||len<=0)
return;
int i=0,j=len-1;
while(i<j)
{
while(i<j&&arr[i]%2!=0)
i++;
while(i<j&&arr[j]%2!=1)
j--;
if(i<j)
{
int temp;
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
void Change3(int* arr,int len)
{
if(!arr||len<=0)
return;
int i=0,j=len-1;
while(i<j)
{
while(i<j&&!func(arr[i]))
i++;
while(i<j&&func(arr[j]))
j--;
if(i<j)
{
int temp;
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
bool func(int i)
{
if(i%2==0)
return true;
else return false;
}
面试题15:链表中倒数第k个结点
输入一个链表,输出该链表中倒数第k个结点。为了符合大多数人的习惯,从1开始数,即链表最后一个结点为倒数第一个结点。例如:一个链表有6个结点,从头开始的值为:1、2、3、4、5、6。这个链表的倒数第3个结点的值是4。
思路1:
首先,遍历一遍链表,得到链表的长度len;
然后,从头遍历链表,第len-i+1即为倒数第i个结点。
思路2:(这种思路在链表中很常见!)
思路1的效率还不够高;
可以设置两个指针,均指向head结点。然后第一个指针后移k个结点后,两个指针同时后移,直到第一个指针指向尾结点,这样第一个指针和第二个指针之间的距离为k。因此第二个指针恰好指向倒数第k个结点。
<pre name="code" class="cpp">#include <iostream>
using namespace std;
struct ListNode
{
int m_nValue;
ListNode* m_pNext;
};
ListNode* CreateList(){ListNode* head=NULL; return head;}
void Insert(ListNode** head,int val);
ListNode* Find1(ListNode* head,int k);
ListNode* Find2(ListNode* head,int k);
void Print(ListNode* head);
int main()
{
ListNode* head=CreateList();
int val;
while(cin>>val)
Insert(&head,val);
cin.clear();
cin.sync();
int k;
cin>>k;
// ListNode* result=Find1(head,k);
ListNode* result=Find2(head,k);
cout<<result->m_nValue;
return 0;
}
void Insert(ListNode** head,int val)
{
ListNode* temp=new ListNode();
temp->m_nValue=val;
temp->m_pNext=NULL;
if(!*head)
*head=temp;
else
{
ListNode* p=*head;
while(p->m_pNext)
p=p->m_pNext;
p->m_pNext=temp;
}
}
void Print(ListNode* head)
{
if(!head) return;
ListNode* p=head;
while(p)
{
cout<<p->m_nValue<<" ";
p=p->m_pNext;
}
cout<<endl;
}
ListNode* Find1(ListNode* head,int k)
{
if(!head) return NULL;
int len=0;
ListNode* p=head;
while(p)
{
len++;
p=p->m_pNext;
}
if(len<k) return NULL;
int i=0;
p=head;
while(i!=len-k)
{
p=p->m_pNext;
i++;
}
return p;
}
//注意鲁棒性!
ListNode* Find2(ListNode* head,int k)
{
if(!head||k==0) return NULL;
ListNode* p1=head,* p2=head;
int i=0;
while(i<k)
{
p1=p1->m_pNext;
if(p1==NULL)//这是当k大于链表长度时,返回空指针
return NULL;
i++;
}
while(p1)
{
p1=p1->m_pNext;
p2=p2->m_pNext;
}
return p2;
}