java and python学习——第四周leetcode刷题

    本周按照顺序继续做leetcode中的题目，随着难度的递增，做题已经不能像之前那样非常快地想出算法了。虽然都是简单题，但是通过率也都缩小到了百分之三十多。最重要的是，这样的基础题会让我对于java和python的使用更加熟悉，起初那几周我要用到什么函数还要去查一下书，现在有些函数我就直接记住并且使用了。这一个月以来，我觉得我收获还是很大的，每周虽然只有五道题，但是通过练习，感觉对于java和python的理解都在每周加深。

13. Roman to Integer

    这道题目就是让我们将罗马数字转化为阿拉伯数字，说难起始也不难，说简单也不简单。因为不了解罗马数字，我上网查了一下。发现罗马数字的几个基本特性。首先就是罗马数字当中只有几种特殊的符号，通过排列顺序不同，组合出不同的数字。第二就是如果小数字在大数字的前面，那么这个数字所代表的就是大数字减去小数字的值。有了这两点，我们就可以很快想到算法。从前往后加，如果碰到下一位比当前位大的话，就加上后一位，减去当前位。算法复杂度为O(n)

java版本：

public class Solution 
{
    public int romanToInt(String s) 
    {
        HashMap<Character,Integer> pp=new HashMap<Character,Integer>();
        pp.put('I',1);
        pp.put('V',5);
        pp.put('X',10);
        pp.put('L',50);
        pp.put('C',100);
        pp.put('D',500);
        pp.put('M',1000);
        char[] ss=s.toCharArray();
        int answer=0;
        int i;
        for(i=0;i<ss.length-1;i++)
        {
            
            if(pp.get(ss[i])<pp.get(ss[i+1]))
            {
                i++;
                answer=answer+pp.get(ss[i])-pp.get(ss[i-1]);
            }
            else answer=answer+pp.get(ss[i]);
        }
        if(i==ss.length) return answer;
        else return answer+pp.get(ss[i]);
    }
}

python版本：

    python当中，如果按照java当中的算法来写，会出现问题。所以我换了另一种计算方法，就是先全加起来，最后再减去两倍那个小的数字。

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        answer=0
        p=[('I',1),('V',5),('X',10),('L',50),('C',100),('D',500),('M',1000)]
        pp=dict(p)
        for i in range(0,len(s)):
            answer=answer+pp[s[i]]
            if pp[s[i-1]]<pp[s[i]] and i>0:
                answer=answer-2*pp[s[i-1]]
        return answer

206. Reverse Linked List

    这道题目是靠我们对于链表的应用，给我们一个单向的链表，让我们实现反向功能。做这道题目首先想到的就是可以利用栈来实现反向，因为栈的特征就是先进后出，或者说是后进先出。这样我们就直接将这个链表进栈，然后再出栈构成新的链表就是以前链表的反向。复杂度为O(n)

java版本：

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

python版本：

    python当中没有直接的栈来给我们使用，但是我们可以利用list[]来模拟栈。即我们可以每次将元素插入列表头部，这样就实现了倒序。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        t=head
        tt=[]
        while t:
            tt.insert(0,t.val)
            t=t.next
        t=head
        for i in tt:
            t.val=i
            t=t.next
        return head

326. Power of Three

    这道题让我们做的事情也很简单，就是让我们判断给定数是否是3的幂。因为某个数mod3一定等于0，1，2，所以如果这个数模3不等于0的话，证明这个数就不是3的幂。但是有几种情况我们呢要进行特判。1、初始值等于0，返回false。2、初始值等于1，返回true。3、如果在循环当中出现n=1的情况，即3/3=1，1mod3=1，如果按照余数不等于0来算的话，那么3就不是3的幂了，所以如果在过程中出现n=1的情况，返回true。复杂度是O(log3n)

java版本：

public class Solution 
{
    public boolean isPowerOfThree(int n) 
    {
        if(n==1) return true;
        if(n==0) return false;
        while(n!=0)
        {
            if(n==1) return true;
            else if(n%3!=0) return false;
            n=n/3;
            
        }
        return true;
    }
}

python版本：

class Solution(object):
    def isPowerOfThree(self, n):
        """
        :type n: int
        :rtype: bool
        """
        if n==1:
            return True
        if n==0:
            return False
        while n!=0:
            if n==1:
                return True
            elif n%3!=0:
                return False
            n=n/3
        return True

202. Happy Number

    这道题目定义了一种新的数，叫做幸福数。怎么定义幸福数呢，就是将原来的数替换为每个位数字平方和，重复此过程，直到原来的数字为1，这样的数字就是幸福数。如果在重复过程中出现之前出现的数字，那么这个重复过程将是一个死循环，所以只要出现这种情况，就可以判断这个数不是幸福数。我们可以写一个函数，用来进行计算下一个数的过程，就是计算平方和的过程。然后还要专门开一个bool数组用来判断数字是否在之前出现过，如果出现过那就直接返回false。

java版本：

public class Solution 
{
    public boolean isHappy(int n) 
    {
        boolean[] pd=new boolean[100000];
        int sum=Happy(n);
        while(sum!=1)
        {
            if(pd[sum]==true)
            {
                return false;
            }
            pd[sum]=true;
            sum=Happy(sum);
        }
        return true;
    }
    public int Happy(int n)
    {
        int answer=0;
        while(n!=0)
        {
            int y=n%10;
            answer+=y*y;
            n/=10;
        }
        return answer;
    }
}

python版本：

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        pd={}
        sum=self.Happy(n)
        while sum!=1:
            if sum in pd:
                return False
            pd[sum]=True
            sum=self.Happy(sum)
        return True
        
    def Happy(self,n):
        answer=0
        while n!=0:
            i=n%10
            answer+=i*i
            n=n/10
        return answer

83. Remove Duplicates from Sorted List

    给定单向链表，删掉相同的节点，只保留一个，所以就是每个不同的元素只出现一次。如果当前结点的值和下一个节点的值相同，就将下下个节点链接到当前结点，重复此过程。然后，如果不相同，那么当前结点就是下一个节点。这样就可以将这个列表中的重复元素删掉。

java版本：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution 
{
    public ListNode deleteDuplicates(ListNode head) 
    {
        int value;
        if(head==null) return null;
        ListNode t=head;
        while(t.next!=null)
        {
            if(t.val!=t.next.val)
            {
                t=t.next;
            }
            while(t.next!=null&&t.next.val==t.val) 
            {
                 t.next=t.next.next;
            }
            
        }
        return head;
    }
}

python版本：

    java当中的空值是null，但是python中的空值是None，这点要记住。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head==None:
            return head
        t=head
        while t.next!=None:
            if t.next.val!=t.val:
                t=t.next
            while (t.next!=None) and (t.next.val==t.val):
                t.next=t.next.next
        return head