20190724算法题存档

题目描述

 

Sort a linked list in O(n log n) time using constant space complexity.

public class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode slow = head;
        ListNode quick = head;
        while(quick.next != null && quick.next.next != null) {
            slow = slow.next;
            quick = quick.next.next;
        }
        ListNode mid = slow;
        ListNode midNext = mid.next;
        mid.next = null;
        return merge(sortList(head), sortList(midNext));
    }

   private ListNode merge(ListNode node1, ListNode node2) {
        ListNode temp = new ListNode(0);
        ListNode cur = temp;
        while(node1 != null && node2 != null) {
            if(node1.val < node2.val) {
                cur.next = node1;
                node1 = node1.next;
            } else {
                cur.next = node2;
                node2 = node2.next;
            }
            cur = cur.next;
        }
        cur.next = node1 == null ? node2 : node1;
        return temp.next;
    }
}

题目描述

 

Sort a linked list using insertion sort.

public class Solution {
      public ListNode insertionSortList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode temp = new ListNode(Integer.MIN_VALUE);
        ListNode cur = head;
        while(cur != null) {
            ListNode next = cur.next;
            ListNode pre = temp;
             while(pre.next != null && pre.next.val < cur.val ) {
                pre = pre.next;
            }
            cur.next = pre.next;
            pre.next = cur;
            cur = next;
        }

        return temp.next;
    }
}

题目描述

 

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree{1,#,2,3},

   1
    \
     2
    /
   3

 

return[3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

import java.util.*;
public class Solution {
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
         ArrayList<Integer> result = new ArrayList<>();

        if(root == null) {
            return result;
        }

        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        stack.push(root);
        TreeNode pre = null;
        while(!stack.isEmpty()) {
            TreeNode temp = stack.peek();
            if(temp.left == null && temp.right == null) {
                result.add(temp.val);
                stack.pop();
                pre = temp;
            } else if((pre != null && (pre == temp.left || pre == temp.right))) {
                result.add(temp.val);
                stack.pop();
                pre = temp;
            } else {
                if(temp.right != null) {
                    stack.push(temp.right);
                }
                if(temp.left != null) {
                    stack.push(temp.left);
                }
            }
        }

        return result;
    }
}

题目描述

 

Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree{1,#,2,3},

   1
    \
     2
    /
   3

 

return[1,2,3].

Note: Recursive solution is trivial, could you do it iteratively?

import java.util.*;
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        if(root == null) {
            return result;
        }

        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode temp = stack.pop();
            result.add(temp.val);
            if(temp.right != null)
                stack.push(temp.right);
            if(temp.left != null)
                stack.push(temp.left);
        }

        return result;
    }
}