算法小解--剑指offer（二）

12.题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

public class Solution {    public double Power(double base, int exponent) {        if(base==0){return 0;}        if(exponent==0){return 1;}        double result=1;        if(exponent>0){            for(int i=exponent;i>0;i--){                result*=base;            }            return result;        }else{            exponent=-exponent;            for(int i=exponent;i>0;i--){                result*=base;            }            return 1/result;        }  }}

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

public class Solution {    public void reOrderArray(int [] array) {        int count=array.length;        int[] jishu=new int[1000];        int[] oushu=new int[1000];        int j=0,o=0,i=0;        for(i=0;i<count;i++){            if ((array[i]%2)==0){                oushu[o]=array[i];                o++;            }else{                jishu[j]=array[i];                j++;            }        }        for(i=0;i<j;i++){            array[i]=jishu[i];        }        for(i=0;i<o;i++){            array[i+j]=oushu[i];        }           }}

交换：

public class Solution {    public void reOrderArray(int [] array) {       for(int i= 0;i<array.length-1;i++){            for(int j=0;j<array.length-1-i;j++){                if(array[j]%2==0&&array[j+1]%2==1){                    int t = array[j];                    array[j]=array[j+1];                    array[j+1]=t;                }            }        }    }}

14.题目描述
输入一个链表，输出该链表中倒数第k个结点。

public ListNode FindKthToTail(ListNode list,int k) {         if (list == null)   return list;         ListNode node = list;         int count = 0;         while (node != null) {             count++;             node = node.next;         }         if (count < k)  return null;         ListNode p = list;         for (int i = 0; i < count - k; i++) {             p = p.next;         }         return p;     }

15.题目描述
输入一个链表，反转链表后，输出链表的所有元素。

public class Solution {    public ListNode ReverseList(ListNode head) {        if(head==null)            return null;        //head为当前节点，如果当前节点为空的话，那就什么也不做，直接返回null；        ListNode pre = null;        ListNode next = null;        //当前节点是head，pre为当前节点的前一节点，next为当前节点的下一节点        //需要pre和next的目的是让当前节点从pre->head->next1->next2变成pre<-head next1->next2        //即pre让节点可以反转所指方向，但反转之后如果不用next节点保存next1节点的话，此单链表就此断开了        //所以需要用到pre和next两个节点        //1->2->3->4->5        //1<-2<-3 4->5        while(head!=null){            //做循环，如果当前节点不为空的话，始终执行此循环，此循环的目的就是让当前节点从指向next到指向pre            //如此就可以做到反转链表的效果            //先用next保存head的下一个节点的信息，保证单链表不会因为失去head节点的原next节点而就此断裂            next = head.next;            //保存完next，就可以让head从指向next变成指向pre了，代码如下            head.next = pre;            //head指向pre后，就继续依次反转下一个节点            //让pre，head，next依次向后移动一个节点，继续下一次的指针反转            pre = head;            head = next;        }        //如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点        //直接输出pre就是我们想要得到的反转后的链表        return pre;    }}

16.题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
递归：

/*public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}*/public class Solution {    public ListNode Merge(ListNode list1,ListNode list2) {        if(list1==null){            return list2;        }        if(list2==null){            return list1;        }        if(list1.val<=list2.val){            list1.next=Merge(list1.next,list2);            return list1;        }else{            list2.next=Merge(list1,list2.next);            return list2;        }    }}

非递归：

/*public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}*/public class Solution {    public ListNode Merge(ListNode list1,ListNode list2) {        //新建一个头节点，用来存合并的链表。        ListNode head=new ListNode(-1);        head.next=null;        ListNode root=head;        while(list1!=null&&list2!=null){            if(list1.val<list2.val){                head.next=list1;                head=list1;                list1=list1.next;            }else{                head.next=list2;                head=list2;                list2=list2.next;            }        }        //把未结束的链表连接到合并后的链表尾部        if(list1!=null){            head.next=list1;        }        if(list2!=null){            head.next=list2;        }        return root.next;    }}

17.题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/**public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}*/public class Solution {    public boolean HasSubtree(TreeNode root1,TreeNode root2) {       boolean result = false;            if(root1 != null && root2 != null){                if(root1.val == root2.val){                    result = DoesTree1HaveTree2(root1,root2);                }                if(!result){result = HasSubtree(root1.left, root2);}                if(!result){result = HasSubtree(root1.right, root2);}            }            return result;    }    public boolean DoesTree1HaveTree2(TreeNode root1,TreeNode root2){            if(root1 == null && root2 != null) return false;            if(root2 == null) return true;            if(root1.val != root2.val) return false;            return DoesTree1HaveTree2(root1.left, root2.left) && DoesTree1HaveTree2(root1.right, root2.right);     }}

18.题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5

/**public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}*/public class Solution {    public void Mirror(TreeNode root) {         if(root == null)            return;        if(root.left == null && root.right == null)            return;        TreeNode pTemp = root.left;        root.left = root.right;        root.right = pTemp;        if(root.left != null)            Mirror(root.left);        if(root.right != null)            Mirror(root.right);    }}

19.题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

import java.util.ArrayList;public class Solution {    public ArrayList<Integer> printMatrix(int [][] array) {        ArrayList<Integer> result = new ArrayList<Integer> ();        if(array.length==0) return result;        int n = array.length,m = array[0].length;        if(m==0) return result;        int layers = (Math.min(n,m)-1)/2+1;//这个是层数        for(int i=0;i<layers;i++){            for(int k = i;k<m-i;k++) result.add(array[i][k]);//左至右            for(int j=i+1;j<n-i;j++) result.add(array[j][m-i-1]);//右上至右下            for(int k=m-i-2;(k>=i)&&(n-i-1!=i);k--) result.add(array[n-i-1][k]);//右至左            for(int j=n-i-2;(j>i)&&(m-i-1!=i);j--) result.add(array[j][i]);//左下至左上        }        return result;           }}

20.题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

import java.util.Stack;public class Solution {    private Stack<Integer> mStack = new Stack<Integer>();    int min=Integer.MAX_VALUE;    int minarr[]=new int[100];    public void push(int node) {        mStack.push(node);        if(node<min){            minarr[mStack.size()-1]=node;            min=node;        }else{            minarr[mStack.size()-1]=min;        }    }    public void pop() {        mStack.pop();    }    public int top() {        return mStack.pop();    }    public int min() {        return minarr[mStack.size()-1];    }}

21题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

import java.util.ArrayList;import java.util.Stack;public class Solution {    public boolean IsPopOrder(int [] pushA,int [] popA) {         if(pushA.length == 0 || popA.length == 0){return false;}        int size=pushA.length;        Stack<Integer> s = new Stack<Integer>();        //用于标识弹出序列的位置        int popIndex = 0;        for(int i = 0; i< size;i++){            s.push(pushA[i]);            //如果栈不为空，且栈顶元素等于弹出序列            while(!s.empty() &&s.peek() == popA[popIndex]){                //出栈                s.pop();                //弹出序列向后一位                popIndex++;            }        }        return s.empty();    }}

22.题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。

public class Solution {    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {        ArrayList<Integer> list = new ArrayList<Integer>();        if(root==null){            return list;        }        Queue<TreeNode> queue = new LinkedList<TreeNode>();        queue.offer(root);        while (!queue.isEmpty()) {            TreeNode treeNode = queue.poll();            if (treeNode.left != null) {                queue.offer(treeNode.left);            }            if (treeNode.right != null) {                queue.offer(treeNode.right);            }            list.add(treeNode.val);        }        return list;    }}