剑指offer-每日6题之第三天(java版)

原题链接：

 

 第一题：调整数组顺序使奇数位于偶数前面
 第二题：链表中倒数第K个节点
 第三题：反转链表
 第四题：合并两个排序的链表
 第五题：树的子结构
 第六题：二叉树的镜像

第一题：调整数组顺序使奇数位于偶数前面

题目描述

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

解析

 

由于相当位置不变，只能数序移动或相邻交换 每次将奇数插入到所有偶数前面，类似插入排序

public  class Solution {
    public void reOrderArray(int [] array) {
        if (array.length == 0)
              return;
         int temp = 0;
         for (int i = 0; i < array.length; i++)
         {
             if ((array[i] & 1) == 1)//对奇数进行操作，将奇数插到偶数前面
             {
                 for (int j = i; j>0; j--)
                 {
                     if ((array[j - 1] & 1) == 0)
                     {
                         temp = array[j];
                         array[j] = array[j - 1];
                         array[j - 1] = temp;
                     }
                 }
            }
         }
    }
}

第二题：链表中倒数第K个节点

题目描述

输入一个链表，输出该链表中倒数第k个结点。

解析

1.定义两个指针：pFirst,pSecond 2.pFirst先走k-1步，注意要判断 pFirst。next是否为空（可能存在K大于链表总长度） 3.pFirst,pSecond一起往后走，当pFirst走到链表尾，pSecond到达倒数第K个位置

public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(k<=0|| head==null)
		return null;
        ListNode pFirst=head;
        ListNode pSecond=head;
        for(int i=1;i<=k-1;i++){
            if(pFirst.next!=null)
            pFirst=pFirst.next;
            else
                 return null;
        }
        while(pFirst.next!=null){
             
            pFirst=pFirst.next;
            pSecond=pSecond.next;
                 
        }
        return pSecond;
    }
}

第三题：反转链表

题目描述

输入一个链表，反转链表后，输出新链表的表头。

解析

定义两个结点：pre(当前结点的前一个结点),next（储存下一个结点）

public class Solution {
    public ListNode ReverseList(ListNode head) {
      ListNode pre=null;
        ListNode next=null;
        while(head!=null){
            next=head.next;
            head.next=pre;
            pre=head;
            head=next;
        }
        return pre;
    }
}

第四题：合并两个排序的链表

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

解析

两个指针:    list1,list2分别指向第一个链表和第二个链表,初始两个为头结点    判断链表的当前值list1和list2的值大小,把较小的给当前链表的,较小的那个链表的指针并向下走一个,最后返回新的头结点

public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
         if(list1==null)return list2;
        if(list2==null)return list1;
        ListNode mergeHead=null;
         ListNode cur=null;
        while(list1!=null&&list2!=null){
                if(list1.val<=list2.val){
                    if(mergeHead==null){
                       mergeHead= cur=list1;
                    }else{
                        cur.next=list1;
                        cur=cur.next;
                    }
                    list1=list1.next;
                }else{
                     if(mergeHead==null){
                       mergeHead= cur=list2;
                    }else{
                        cur.next=list2;
                        cur=cur.next;
                    }
                    list2=list2.next;
                }      
            }
        if(list1!=null){
            cur.next=list1;
        }else if(list2!=null){
             cur.next=list2;
        }
        return mergeHead;
    }
}

第五题：树的子结构

题目描述

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

解析

递归( 分两个函数递归):      1.判断root1和root2的根节点是否相同      2.判断左右子树是否相同 注意:当1相等时,才能判断2,若1不相等,再去判断1的左和root2是否相等,若还不相等,在去判断1的右和root2是否相等,若树遍历完还没找         到相等的,返回false         在第二个函数中,当判断到root2==null,说明子树遍历完,返回true,如果root2没遍历完,root1已经遍历完,直接返回false,否则,继续         判断左右子树

public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        boolean res=false;
        if(root1!=null && root2!=null){
            if(root1.val==root2.val){
                res=HasSubtree2(root1,root2);
            }
            if(!res)res=HasSubtree(root1.left,root2);
             if(!res)res=HasSubtree(root1.right,root2);
        }
        return res;
    }
     public boolean HasSubtree2(TreeNode root1,TreeNode root2) {
     if(root2==null)return true;
         if(root1==null)return false;
         if(root1.val!=root2.val)return false;
         return HasSubtree2( root1.left, root2.left)&&HasSubtree2( root1.right, root2.right);
     }
}

第六题：二叉树的镜像

题目描述

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

解析

类似先序遍历:先交换当前节点的左右节点,在递归到左右节点    注意base条件:当当前节点为空,左右节点为空时,递归结束

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);
    }
}