lintcode--剑指offer---21--30道

(21)Binary Tree Postorder Traversal

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Postorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        //1.边界判断
        ArrayList<Integer> arrList = new ArrayList<>();
        if (root == null) {
            return arrList;
        }
        //2.定义一个stack
        LinkedList<Integer> result = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        //3.循环体
        while (!stack.isEmpty()) {
            TreeNode cur = stack.pop();
            result.addFirst(cur.val); //关键代码：只有LinkedList才有addFirst这个操作
            if (cur.left != null) {
                stack.push(cur.left);
            }
            if (cur.right != null) {
                stack.push(cur.right);
            }
        }
        for (int i = 0; i < result.size(); i++) {
            arrList.add(result.get(i));
        }
        return arrList;
    }
}

 Binary Tree Preorder Traversal（补充）

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Preorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        //1.进行边界判断
        ArrayList<Integer> arrList = new ArrayList<>();
        if (root == null) {
            return arrList;
        }
        //2.根据题目要求定义stack或者queue
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        //3.开始进行循环
        while (!stack.isEmpty()) {
            TreeNode head = stack.pop();
            arrList.add(head.val);
            if (head.right != null) {
                stack.push(head.right);
            }
            if (head.left != null) {
                stack.push(head.left);
            }
        }
        return arrList;
    }
}

Binary Tree Inorder Traversal（补充）

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Inorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        //1.边界判断
        ArrayList<Integer> arrList = new ArrayList<>();
        if (root == null) {
            return arrList;
        }
        //2.定义一个stack
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        //3.循环体
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            arrList.add(cur.val);
            cur = cur.right;
        }
        return arrList;
    }
}

 （22）Copy List with Random Pointer

/**
 * Definition for singly-linked list with a random pointer.
 * class RandomListNode {
 *     int label;
 *     RandomListNode next, random;
 *     RandomListNode(int x) { this.label = x; }
 * };
 */
public class Solution {
    /**
     * @param head: The head of linked list with a random pointer.
     * @return: A new head of a deep copy of the list.
     */
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        cloneNodes(head);
        cloneRandomPointer(head);
        return splitList(head);
    }
    //1.将所有节点复制并置于节点后面
    public void cloneNodes(RandomListNode head) {
        RandomListNode cur = head;
        while (cur != null) {
            //初始化cloned
            RandomListNode cloned = new RandomListNode(cur.label);
            cloned.label = cur.label;
            cloned.next = cur.next;
            cloned.random = null;
            //将指针连起来
            cur.next = cloned;
            cur = cloned.next;
        }
    }
    //2.复制所有的random指针
    public void cloneRandomPointer(RandomListNode head) {
        RandomListNode cur = head;
        while (cur != null) {
            RandomListNode cloned = cur.next;
            if (cur.random != null) {
                cloned.random = cur.random.next;
            }
            cur = cloned.next;
        }
    }
    //3.将两个链表分开
    public RandomListNode splitList(RandomListNode head) {
        RandomListNode cur = head;
        RandomListNode clonedHead = null;
        RandomListNode clonedCur = null;
        //保存头结点并将指针移动一次
        clonedHead = cur.next;
        clonedCur = cur.next;
        cur.next = clonedCur.next;
        cur = cur.next;
        //循环体
        while (cur != null) {
            clonedCur.next = cur.next;
            clonedCur = clonedCur.next;
            cur.next = clonedCur.next;
            cur = cur.next;
        }
        return clonedHead;
    }
}

(23)Spiral Matrix

public class Solution {
    /**
     * @param matrix a matrix of m x n elements
     * @return an integer list
     */
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<>();
        if (matrix == null || matrix.length == 0) {
            return list;
        }
        int rows = matrix.length;
        int columns = matrix[0].length;
        int start = 0;
        while (rows > start * 2 && columns > start * 2) {
            int endX = columns - start - 1;
            int endY = rows - start - 1;
            for (int i = start; i <= endX; i++) { //第一步肯定是要进行的
                list.add(matrix[start][i]);
            }
            if (endY > start) { //判断是否进行第二步（第二步不进行，则不进行第三步，以下同理）
                for (int i = start + 1; i <= endY; i++) {
                    list.add(matrix[i][endX]);
                }
                if (endX > start) { //判断第三步
                    for (int i = endX - 1; i >= start; i--) {
                        list.add(matrix[endY][i]);
                    }
                    if (endY > start + 1) { // 判断第四步
                        for (int i = endY - 1; i > start; i--) {
                            list.add(matrix[i][start]);
                        }
                    }
                }
            }
            start++;
        }
        return list;
    }
}

(24)Min Stack

public class MinStack {
    //定义两个栈，分别保存栈的数据以及栈中的最小元素
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    public MinStack() {
        //初始化
        stack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }

    // public void push(int number) { //push version1
    //     stack.push(number);
    //     if (minStack.size() == 0 || minStack.peek() > number) {
    //         minStack.push(number);
    //     } else {
    //         minStack.push(minStack.peek());
    //     }
    // }
    
    public void push(int number) { //push version2
        stack.push(number);
        if (minStack.isEmpty()) {
            minStack.push(number);
        } else {
            minStack.push(Math.min(number, minStack.peek()));
        }
    }

    public int pop() {
        minStack.pop();
        return stack.pop();
    }

    public int min() {
        return minStack.peek();
    }
}

(25)Convert Binary Search Tree to Doubly Linked List

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 * Definition for Doubly-ListNode.
 * public class DoublyListNode {
 *     int val;
 *     DoublyListNode next, prev;
 *     DoublyListNode(int val) {
 *         this.val = val;
 *         this.next = this.prev = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of tree
     * @return: the head of doubly list node
     */
    class ConnectType { //一个双链表的起点和终点
        DoublyListNode first;
        DoublyListNode last;
        public ConnectType(DoublyListNode first, DoublyListNode last) {
            this.first = first;
            this.last = last;
        }
    }
    public DoublyListNode bstToDoublyList(TreeNode root) {
        if (root == null) { //两个函数中的边界判断代表的意思不一样，因此不能删除任何一个
            return null;
        }
        ConnectType result = dfsHelper(root);
        return result.first;
    }
    public ConnectType dfsHelper(TreeNode root) { //获取一个树转化为双链表的起点和终点
        if (root == null) {
            return null;
        }
        ConnectType left = dfsHelper(root.left); //代表左子树转化为双链表，参数有起点和终点
        ConnectType right = dfsHelper(root.right); //代表右子树转化为双链表，参数有起点和终点
        //node代表此时的根节点
        DoublyListNode node = new DoublyListNode(root.val);
        ConnectType result = new ConnectType(null, null);
        if (left == null) {
            result.first = node;
        } else {
            //返回起点
            result.first = left.first;
            //建立双链
            left.last.next = node;
            node.prev = left.last;
        }
        if (right == null) {
            result.last = node;
        } else {
            //返回终点
            result.last = right.last;
            //建立双链
            right.first.prev = node;
            node.next = right.first;
        }
        return result;
    }
}

(26)Majority Number

public class Solution {
    /**
     * @param nums: a list of integers
     * @return: find a  majority number
     */
    public int majorityNumber(ArrayList<Integer> nums) {
        //整体思路：用count记录次数，用number记录当前的数字，对数组进行遍历，
        //如果跟number相同，count就加1.如果不同count减1，由于要找的数字次数大于一半，也就大于其他所有数字的次数之和，那么最后保存的数字必然就是要找的数字。
        if (nums == null || nums.size() == 0) {
            return 0;
        }
        int count = 0; //用于保存次数
        int number = 0; //用于保存当前的数字
        for (int i = 0; i < nums.size(); i++) {
            if (count == 0) {
                number = nums.get(i);
            }
            if (nums.get(i) == number) {
                count++;
            } else {
                count--;
            }
        }
        return number;
    }
}

public class Solution {
    /**
     * @param nums: a list of integers
     * @return: find a  majority number
     */
    public int majorityNumber(ArrayList<Integer> nums) {
        //整体思路：用count记录次数，用number记录当前的数字，对数组进行遍历，
        //如果跟number相同，count就加1.如果不同count减1，由于要找的数字次数大于一半，也就大于其他所有数字的次数之和，那么最后保存的数字必然就是要找的数字。
        if (nums == null || nums.size() == 0) {
            return 0;
        }
        int count = 0; //用于保存次数
        int number = 0; //用于保存当前的数字
        for (int i = 0; i < nums.size(); i++) {
            if (count == 0) {
                number = nums.get(i);
            }
            if (nums.get(i) == number) {
                count++;
            } else {
                count--;
            }
            if (count == 0) {
                number = nums.get(i);
            }
        }
        return number;
    }
}

(27)Maximum Subarray

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: A integer indicate the sum of max subarray
     */
    public int maxSubArray(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int curSum = 0; //用于记录当前的总和
        int maxSum = nums[0]; //用于记录最大的和
        for (int i = 0; i < nums.length; i++) {
            if (curSum <= 0) { //如果当前的和为负的，则从下一个数重新加
                curSum = nums[i];
            } else {
                curSum += nums[i];
            }
            if (curSum > maxSum) {
                maxSum = curSum;
            }
        }
        return maxSum;
    }
}

 

(28)Spiral Matrix II

public class Solution {
    /**
     * @param n an integer
     * @return a square matrix
     */
    public int[][] generateMatrix(int n) {
        if (n <= 0) {
            return new int[0][0];
        }
        int[][] result = new int[n][n];
        int number = 1;
        int start = 0; //由于是正方形的矩阵，所以只需要一个start
        while (n > 0) {
            for (int i = start; i < n; i++) {
                result[start][i] = number++;
            }
            if (n - start >= 2) { //这句判断很重要，同Spiral Matrix这个程序一样，第一步必要做，但是后面的需要判断
                for (int i = start + 1; i < n - 1; i++) {
                    result[i][n - 1] = number++;
                }
                for (int i = n - 1; i >= start; i--) {
                    result[n - 1][i] = number++;
                }
                for (int i = n - 2; i > start; i--) {
                    result[i][start] = number++;
                }
            }
            n = n - 1;
            start++;
        }
        return result;
    }
}

 (29)Intersection of Two Linked Lists

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param headA: the first list
     * @param headB: the second list
     * @return: a ListNode
     */
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //整体思路：首先获得两个链表的长度，然后将长的链表遍历到跟短的一样，然后两个链表同时遍历，找到共同的节点
        if (headA == null || headB == null) {
            return null;
        }
        int aLen = getListLength(headA);
        int bLen = getListLength(headB);
        ListNode aCur = headA;
        ListNode bCur = headB;
        if (aLen > bLen) {
            for (int i = 0; i < aLen - bLen; i++) {
                aCur = aCur.next;
            }
        } else {
            for (int i = 0; i < bLen - aLen; i++) {
                bCur = bCur.next;
            }
        }
        while (aCur != null) {
            if (aCur.val == bCur.val && aCur.next == bCur.next) {
                return aCur;
            }
            aCur = aCur.next;
            bCur = bCur.next;
        }
        return null;
    }
    public int getListLength(ListNode head) {
        if (head == null) {
            return 0;
        }
        int len = 0;
        while (head != null) {
            head = head.next;
            len++;
        }
        return len;
    }
}

 (30)Ugly Number II

class Solution {
    /**
     * @param n an integer
     * @return the nth prime number as description.
     */
    public int nthUglyNumber(int n) {
        //思路：丑数必然是前面的丑数乘以2,3,5的结果,那么下一个丑数必然是之前的丑数
        //乘以2，3，5中的最小数
        if (n <= 0) {
            return 0;
        }
        //保存排序好的丑数
        List<Integer> arrList = new ArrayList<>();
        arrList.add(1);
        //p2,p3,p5的位置为它所在位置的丑数乘以2，3，5第一次大于当前的最大丑数
        int p2 = 0;
        int p3 = 0;
        int p5 = 0;
        //
        for (int i = 1; i < n; i++) {
            int lastUglyNum = arrList.get(i - 1);
            while (arrList.get(p2) * 2 <= lastUglyNum) {
                p2++;
            }
            while (arrList.get(p3) * 3 <= lastUglyNum) {
                p3++;
            }
            while (arrList.get(p5) * 5 <= lastUglyNum) {
                p5++;
            }
            arrList.add(Math.min(arrList.get(p2) * 2, Math.min(arrList.get(p3) * 3, arrList.get(p5) * 5)));
        }
        return arrList.get(n - 1);
    }
};

Ugly Number

public class Solution {
    /**
     * @param num an integer
     * @return true if num is an ugly number or false
     */
    public boolean isUgly(int num) {
        if (num < 1) {
            return false;
        }
        while (num % 2 == 0) {
            num = num / 2;
        }
        while (num % 3 == 0) {
            num = num / 3;
        }
        while (num % 5 == 0) {
            num = num / 5;
        }
        if (num == 1) {
            return true;
        }
        return false;
    }
}