剑指offer-第三章-高质量的代码

面试题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;
}