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