剑指offer练习刷题16~20

第十六题

题目描述

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

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

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.LinkedList;
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null && list2==null) return null;
        LinkedList<ListNode> list3=new LinkedList<>();
		while(list1!=null && list2!=null) {
			 if(list1.val<=list2.val) {
				 list3.add(list1);
				 list1=list1.next;
			 }
			 else {
				 list3.add(list2);
				 list2=list2.next;
			 }
		}
        while(list1!=null) {
        	list3.add(list1);
        	list1=list1.next;
        }
        while(list2!=null) {
        	list3.add(list2);
        	list2=list2.next;
        }
        for (int i=0;i<list3.size()-1;i++) {
        	list3.get(i).next=list3.get(i+1);
		}
        list3.get(list3.size()-1).next=null;
        return list3.get(0);
    }
}

运行时间：25ms

占用内存：8736k

思路：这是归并排序算法中的归并操作。可借助集合，比较两个链表的头结点的大小，小者入集合，再将链表头指向下一个节点，大者不动，继续与另一链表的新表头比较，如此循环操作即可。最后其中一个链表的节点已经全部进入集合后，另一链表剩余节点可全部直接进入集合。

第十八题

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树 
    	    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 {
    TreeNode index=null;
    public void Mirror(TreeNode root) {
        if(root==null) return;
        if(root.left!=null || root.right!=null){
			index=root.left;
			root.left=root.right;
			root.right=index;
			if(root.left!=null) Mirror(root.left);
			if(root.right!=null) Mirror(root.right);
		}
    }
}

运行时间：29ms

占用内存：8952k

思路：由于无法预知二叉树的长度，所以本题一定使用了递归的方法。主要操作是将某一根节点的左右两节点交换，然后分别将其左右节点作为根节点再次操作，如此递归下去直到某一根节点无叶节点为止。

第十九题

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 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 {
    ArrayList<Integer> array=new ArrayList<>();
	public ArrayList<Integer> printMatrx(int[][] matrx){
		if(matrx==null) return null;
		for (int i : matrx[0]) {
			array.add(i);
		}
		for(int i=1;i<matrx.length;i++){
			array.add(matrx[i][matrx[0].length-1]);
		}
		for(int i=matrx[0].length-2;i>=0;i--){
			array.add(matrx[matrx.length-1][i]);
		}
		for(int i=matrx.length-2;i>=1;i--){
			array.add(matrx[i][0]);
		}
		if(matrx.length-2<=0||matrx[0].length-2<=0) return array;
		int[][] doublearray=new int[matrx.length-2][matrx[0].length-2];
		for(int i=0;i<matrx.length-2;i++) {
			for(int j=0;j<matrx[0].length-2;j++) {
				doublearray[i][j]=matrx[i+1][j+1];
			}
		}
		printMatrx(doublearray);
		return array;
	}
}

这个代码没有通过，我暂时还不明白为什么，我在eclipse上自己写main函数测试的时候都是对的，如下图：

思路：每次将矩阵最外一周的元素按照顺时针顺序加入集合中，再将最外一层元素剥去，将中间的数组存入另一个新的二维数组，递归执行新数组，直到不存在中间数组。

第二十题

题目描述

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

import java.util.Stack;

public class Solution {

    Stack<Integer> s=new Stack<>();
    public void push(int node) {
        s.push(node);
    }
    
    public void pop() {
        s.pop();
    }
    
    public int top() {
        return s.get(s.size()-1);
    }
    
    public int min() {
    	int min=s.get(0);
        for (Integer integer : s) {
	    if(integer<min) min=integer;
	}
        return min;
    }
}

运行时间：11ms

占用内存：9264k