剑指offer（数值的整数次方、删除链表中的重复节点、调整数组顺序使奇数位于偶数前面）

九、代码的完整性

1. 数值的整数次方

题目描述：

​ 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0。

思路：

需要考虑以下4种情形：

1）底数为0，指数<0；

2）底数不为0，指数<0；

3）底数不为0，指数>0；

4）底数不为0，指数=0。

代码：

public class Solution {
    public double Power(double base, int exponent) {
        if (base == 0 && exponent < 0) {
            throw new RuntimeException("非法数据！");
        }
        double result = 0;
        if (exponent < 0) {
            result = pow(base, -1 * exponent);
            return 1.0 / result;
        } else if (exponent > 0) {
            result = pow(base, exponent);
            return result;
        } else {
            return 1;
        }
    }
    public static double pow(double base, int exponent) {
        double result = 1;
        for (int i = 1; i <= exponent; i++) {
            result *= base;
        }
        return result;
    }
}

3. 删除链表中重复的节点

题目描述：

​ 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。

思路：

​ 见代码。时间复杂度O(n)，空间复杂度O(1)。

代码：

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if (pHead == null || pHead.next == null) {
            return pHead;
        }
        //自己构造一个头结点，可以避免单独讨论当第一二两个节点便开始重复的情况
        ListNode h = new ListNode(-1);
        h.next = pHead;
        ListNode pre = h;
        ListNode p = pre.next;
        while (p != null) {
            if (p.next != null && p.val == p.next.val) {
                while (p.next != null && p.val == p.next.val) {
                    p = p.next;
                }
                //退出循环时，p.next指向第一个不重复的节点
                p = p.next;
                pre.next = p;
            } else {
                pre = pre.next;
                p = p.next;
            }
        }
        return h.next;
    }
}

6. 调整数组顺序使奇数位于偶数前面

题目描述：

​ 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

思路：

时间复杂度O(n)，空间复杂度O(n)。

代码：

import java.util.ArrayList;
public class Solution {
    public void reOrderArray(int [] array) {
        ArrayList<Integer> odd = new ArrayList<>();
        ArrayList<Integer> even = new ArrayList<>();
        for (int num : array) {
            if (num % 2 == 1) {
                odd.add(num);
            } else {
                even.add(num);
            }
        }
        int j = 0;
        for (int i = 0; i < odd.size(); i++) {
            array[j++] = odd.get(i);
        }
        for (int i = 0; i < even.size(); i++) {
            array[j++] = even.get(i);
        }
    }
}