2019.10.14刷题小结

1.数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方，保证base和exponent不同时为0。

借用一下大佬的图（侵权删）

要想明白一共有多少种情况。

a:如果base=0且exp<0,这种情况直接结束计算，并定义一个全局变量报错。注意判断浮点数相等得用a+0.00001>b&&a-0.00001<b.

b:不管exp是正是负，可以统一先计算正的，然后负的再计算一下倒数.

c:有个优化方法，a^8=(a^4)(a^4)=(a^2)(a^2)(a^2)(a^2)=(a*a)(a*a)(a*a)(a*a).

指数是奇数的话再乘一个base就好。a^15=a(a^7)(a^7)=a(a(a^3)(a^3))(a(a^3)(a^3))=a(a(a(a*a))(a(a*a))(a(a(a*a))(a(a*a))).

bool global_flag=false;
    double Power(double base, int exponent) {
        if(equal(base,0.0)&&exponent<0)
        {
            global_flag=true;
            return 0.0;
        }
        int absexp=exponent;
        if(exponent<0)
        {
            absexp=-exponent;
        }
        double res=power(base,absexp);
        if(exponent<0)
        {
            res=1.0/res;
        }
        return res;
    }
    double power(double base,int absexp)
    {
        if(absexp==0)
        {
            return 1.0;
        }
        else if(absexp==1)
        {
            return base;
        }
        double result=power(base,absexp>>1);
        result*=result;
        if(absexp&1==1)
        {
            result*=base;
        }
        return result;
    }
    bool equal(double a,double b)
    {
        if(a+0.000001>b&&a-0.000001<b)
        {
            return true;
        }
        return false;
    }

2.链表中倒数第K个节点。

定义两个指针，都等于第一个头结点，第一个指针走K步到第k+1个节点。这个过程注意判断是否走到链表尾，如果到的话，那么返回空指针。

两个指针一起走，第一个指针走到尾节点指向的空指针时，第二个指针正是倒数第K个节点。

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(!pListHead)
        {
            return nullptr;
        }
        int count=1;
        ListNode*node1=pListHead;
        ListNode*node2=pListHead;
        for(;count<=k;count++)
        {
            if(!node1)
            {
                return nullptr;
            }
            node1=node1->next;
        }
        while(node1)
        {
            node1=node1->next;
            node2=node2->next;
        }
        return node2;
    }

3.反转链表。

注意三个地方：

a：保存三个节点，一个当前节点node，一个当前节点的前一个节点pre，一个当前节点的后一个节点next。

b:循环的判断条件是node不为空节点

c:返回的是pre。

ListNode* ReverseList(ListNode* pHead) {
        if(!pHead||!pHead->next)
        {
            return pHead;
        }
        ListNode* pnode=pHead;
        ListNode* pre=nullptr;
        ListNode* pnext=pHead->next;
        while(pnode)
        {
            pnode->next=pre;
            pre=pnode;
            pnode=pnext;
            if(pnext)
            {
                pnext=pnode->next;
            }
            
        }
        return pre;
    }

4.二叉树的前序遍历（递归版）

vector<int> preorderTraversal(TreeNode *root) {
        vector<int>res;
        if(!root)
        {
            return res;
        }
        preorder(root,res);
        return res;
    }
    void preorder(TreeNode *root,vector<int>&res)
    {
        if(root)
        {
            res.push_back(root->val);
            preorder(root->left,res);
            preorder(root->right,res);
        }
    }