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

    学习java和python的第二周，感觉学习到了好多，收获了好多。当然，还是要一步一个脚印走，稳扎稳打，把基本功练好再去做更高级的事情。本周选择了比上周稍微难了一点的题目，通过率都是百分之四十。

389. Find the Difference

    这道题给我们两个字符串，第二个字符串只比第一个多一个小写字母，让我们把这个“异类”找出来。我的算法是这样的，用两层循环，如果对于第一个字符串中的一个字符，第二个字符串中存在一个字符和它相同，我们就把第二个字符串中的那个字符标记。直到最后，除了那个新加进去的元素，所有元素都因为和第一个字符串中的字符相同而被标记。我们只需要找到那个未被标记的元素，返回即可。这样做的复杂度为O(n^2)。

java版本：

public class Solution 
{
    public char findTheDifference(String s, String t) 
    {
        char[] ss=s.toCharArray();
        char[] tt=t.toCharArray();
        boolean[] pp= new boolean[1000];
        for(int i=0;i<ss.length;i++)
        {
            int j=0;
            while(j<tt.length)
            {
                if((pp[j]==false)&(tt[j]==ss[i]))
                {
                    pp[j]=true;
                    break;
                }
                j++;
            }
        }
        int ii;
        for(ii=0;ii<tt.length;ii++)
        {
            if(pp[ii]==false)
            {
                break;
            }
        }
        return tt[ii];
    }
}

python版本：

    用python的时候，我又突然想到了另一种算法。如果说我们采用位运算的方法，不适合我们上周所做的136.single number相同了么。所以对于每一个元素，我们都进行异或运算，这样得到的字母就是那个新加的字母。其中len函数是求长度的函数，ord函数是字母转换数字的函数。

class Solution(object):
    def findTheDifference(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        answer=0;
        for i in range(len(s)):
            answer=answer^(ord(s[i]));
            answer=answer^(ord(t[i]));
        answer=answer^(ord(t[len(t)-1]));
        return chr(answer)

283. Move Zeroes

    这道题目也很简单，给定一个数组，其中有0也有其他数字。要求我们在不另外开辟数组的情况下，将这个数组中的所有0全部移到数组的末尾。我的算法就是用两个变量模拟指针，在初始化的时候都指向数组的开头，其中一个按照顺序寻找原来数组当中的非零数，另一个指向下一个非零数应该放的位置。这样做的时间复杂度为O(n).

java版本：

public class Solution 
{
    public void moveZeroes(int[] nums) 
    {
        int i=0;
        int j=0;
        while(j<nums.length)
        {
            if(nums[j]!=0)
            {
                nums[i]=nums[j];
                i++;
            }
            j++;
        }
        while(i<nums.length) 
        {
            nums[i]=0;
            i++;
        }
    }
}

python版本：

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        j=0
        i=0
        while i<len(nums):
            if nums[i]!=0:
                nums[j]=nums[i]
                j=j+1
            i=i+1
        while j<len(nums):
            nums[j]=0;
            j=j+1
            

237. Delete Node in a Linked List

    这道题很简单，就是考察我们指针的应用，让我们删除一个节点。算法就是让后一个节点的值覆盖给定节点的值，然后再让指点节点的指针指向下下个节点。

java版本：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution 
{
    public void deleteNode(ListNode node) 
    {
        node.val=node.next.val;
        node.next=node.next.next;
    }
}

python版本：

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

class Solution(object):
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val=node.next.val
        node.next=node.next.next

383. Ransom Note

    这道题的题目是勒索信，其实就是写勒索信的时候是不可以用自己的笔迹的，所以要从杂志上剪下来字母进行粘贴，避免被警察抓到。所以这道题就是给我们两个字符串，一个是勒索信上的，一个是我们从杂志上剪下来的字母。当从杂志上的字母可以拼成勒索信的时候，就返回True代表成功，否则返回False。我的算法是这样的，先统计杂志上字母的数量和种类，用一个数组储存，然后如果勒索信上出现一个字母，我们就相应地从数组中减去那个字母。如果有某个字母的数量小于0，那么就说明出错了。

java版本：

public class Solution 
{
    public boolean canConstruct(String ransomNote, String magazine) 
    {
        int[] number=new int[100];
        for(int i=0;i<magazine.length();i++)
        {
            number[magazine.charAt(i)-'a']++;
        }
        for(int j=0;j<ransomNote.length();j++)
        {
            number[ransomNote.charAt(j)-'a']--;
            if(number[ransomNote.charAt(j)-'a']<0)
            {
                return false;
            }
        }
        return true;
    }
}

python版本：

    因为python中没有像java和C++中那样的数组，所以我们用字典来代替数组进行统计。相应的，我们的算法就要发生改变。我们先分别统计出来两个字符串中出现的每个字母和它们的数量，然后进行比较。如果在勒索信中出现了杂志上没有的字母种类，或者勒索信中某个字母的数量大于杂志中相同字母的数量，就返回False。

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        a={}
        b={}
        for i in magazine:
            a[i]=a.get(i,0)+1
        for j in ransomNote:
            b[j]=b.get(j,0)+1
        for k,v in b.items():
            if k not in a.keys():
                return False
            if v>a[k]:
                return False
        return True

349. Intersection of Two Arrays

    这道题目的描述很简单，就是给我们两个数组，让我们求出这两个数组的并集，并且不能有重复元素出现。我的算法是这样的，首先我们选择一个数组，扫描其中的每个元素，如果元素的数目等于0，我们就将这个元素的数量变为1。当然，我们肯定要声明一个数组，来进行记录每个出现元素的数量。这第一步做了什么工作呢？相当于我们将第一个数组当中的所有重复元素删去了，保证我们记录下来的数字都是互不相同的。接下来，我们就按照同样的方法来统计第二个数组当中的元素，当然，这回的判断条件是如果该元素的个数是1，我们就加一，否则就什么都不做。第二步的意义是将第一个数组和第二个数组当中都出现的元素的数量记为2，只在第一个数组当中出现的元素数量仍然是1。这样做还有一个好处就是可以剔除掉第二个数组当中的重复元素。如果有重复元素出现，因为我们已经把这个元素的数量记为2了，所以程序会自动略过这个重复出现的元素。最后一步就是将数量为2的数字合并到一个数组中，返回即可。这样做，我们保证了返回的数组当中不会有重复元素出现，而且保证了数量为2的所有元素就是我们想要的，满足题意。

java版本：

public class Solution 
{
    public int[] intersection(int[] nums1, int[] nums2) 
    {
           int[] a=new int[100000];
           for(int i=0;i<nums1.length;i++)
           {
               if(a[nums1[i]]==0) 
               {
                   a[nums1[i]]++;
               }
           }
           for(int j=0;j<nums2.length;j++)
           {
               if(a[nums2[j]]==1) 
               {
                   a[nums2[j]]++;
               }
           }
           int jj=0;
           int count=0;
           for(int ii=0;ii<100000;ii++)
           {
               if(a[ii]==2) 
               {
                   count++;
               }
           }
           int[] answer=new int[count];
           for(int ii=0;ii<100000;ii++)
           {
               if(a[ii]==2) 
               {
                   answer[jj]=ii;
                   jj++;
               }
           }
           return answer;
    }
}

python版本：

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        a={}
        result=list()
        for i in nums1:
            if a.has_key(i)==False:
                a[i]=a.get(i,0)+1
        for j in nums2:
            if a.get(j)==1:
                a[j]=a[j]+1
        for k,v in a.items():
            if v==2:
                result.append(k)
        return result

    这就是我第二周完成的题目，虽然不是很难，但是我都有用心去做，都认真思考了，感到很有成就感。