[2016/07/01] LeetCode / Java - Day 09 -

下半年加油~不要问我为啥今天这么早→ →

206. Reverse Linked List

Reverse a singly linked list.

思路：逆序链表，呃我一下子就想到了堆栈。。其实这个O(2n)的时间复杂度+O(n)的空间复杂度不太好的。。看了一下别人的程序，昨晚有点头昏，就没有仔细看，大概是循环，然后首尾交换，就是改next关系，而我是直接改的val。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
 import java.util.Stack;
public class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null) return head;
        Stack<Integer> s = new Stack<Integer>();
    	ListNode p = head;
    	while(p!=null){
    		s.push(p.val);
    		p = p.next;
    	}
    	p = head;
    	while(p!=null){
    		p.val = s.pop();
    		p = p.next;
    	}
		return head;
    }
}

94. Binary Tree Inorder Traversal

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

For example:
Given binary tree [1,null,2,3],

   1
    \
     2
    /
   3

return [1,3,2].

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

思路：这个和昨天的那个没啥区别啊，就是把前根遍历改成了中根遍历。。（关键在于我不肯动脑子想怎么用迭代来解决！）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
 import java.util.ArrayList;
import java.util.List;
public class Solution {
    
	List<Integer> l = new ArrayList<Integer>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root==null) return l;
        if(root.left!=null){
    		l = inorderTraversal(root.left);
    	}
    	l.add(root.val);
    	if(root.right!=null){
    		l = inorderTraversal(root.right);
    	}
    	
		return l;        
    }
}

13. Roman to Integer

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

思路：挺喜欢这样有意思的题~然后百度了下，发现很多罗马数字我不知道的知识。。。我原来只会1~10的罗马数字，现在我可以自由到无限啦哈哈哈。

规则主要（我记得的）有以下几个：

1、基本数字代表

I      V     X     L     C     D       M

1    5     10    50   100  500   1000

2、重复规则

一个字母最多重复三次，重复表示相加

3、左右规则

小数在大数左边，表示相减，且在大数左边最多只能有一位，比如你不能IIV

小数在大数右边，表示相加，在右边的位数不超过3位，VIII是可以的~

好像有些左边的限制条件，但记不得了

4、其它 编程不涉及我就不啰嗦了

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public int romanToInt(String s) {
        //l 存放涉及到的字母，并且与i数组中的数字一一对应	
        List<Character> l = new ArrayList<Character>();
    	l.add('I');l.add('V');l.add('X');l.add('L');l.add('C');l.add('D');l.add('M');
        int[] i = new int[]{1,5,10,50,100,500,1000};
        int[] num = new int[s.length()];//新建一个数组，用于存放字符串处理后的数字
        if(s.length()==1) return i[l.indexOf(s.charAt(0))];//如果s只有一位，就直接对应字母返回数字（这一行应该在上一行上面的。。没仔细看）
        for(int k=0;k<s.length();k++){
        	num[k]=i[l.indexOf(s.charAt(k))];
        }
        int sum=0;int k=0;//和，指针
        while(k<s.length()){
        	//检测连续
        	int lianxu=1;
        	while(k+1<s.length()){
            	if(num[k]==num[k+1])
            	{	lianxu++;
            		k++;
            	}
            	else break;
        	}
        	//连续的部分的值是有讲究的。如果后面跟着个大数，就只能算一个减，别的加。如果后面跟着的不是大数，那么就加所有的 
        	if(k+1==s.length()-1){
            	if(num[k]<num[k+1] )
            		sum=sum-num[k]+(lianxu-1)*num[k]+num[k+1];
            	else  sum=sum+lianxu*num[k]+num[k+1];
        		break;
        	}else if(k+1>s.length()-1){
        		sum=sum+lianxu*num[k];
        		break;
        	}
        	if(num[k]<num[k+1] )
        		sum=sum-num[k]+(lianxu-1)*num[k];
        	else  sum=sum+lianxu*num[k];
        	k++;
        }
        
        return sum;
    }
}