Leetcode(python)——24两两交换链表中的结点，27移除元素，35搜索插入位置，49字母异位词分组

题号24

原链表：有一个head指针指向表头元素：

定义一个新的链表res，让其next指针指向old链表，并定义一个指向新链表表头元素的指针Cur：

对new链表进行元素交换：
首先定义一个指向head.next的指针nxt
一个指向nxt.next的指针temp

新链表的头指针cur的next指向头结点的next，即nxt;
nxt的next指向head；

经过上面步骤，链表被划分成了两部分（因为2,3之间的链被断开了）

连接断链：head.next=temp

第一波的交换完成。更新交换完位置后的新链表的cur指针：cur指向当前完成交换后的最后一个结点1，对应的指针为head（虽然3也连接到了表里，但是3还没有交换完成，所以当前交换完毕的链表cur标记到1），每次交换始终从head开始，下一波交换的3,4指针分别对应1,2的指针head和nxt，只要指定了head，nxt自动获取为head的下一个，所以再执行一步更新head的指针操作head=head.next(试了一下head=temp也一样的)

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        res = ListNode()
        res.next=head  #指向head链表
        cur = res      #指向新建链表
        while cur.next!=None and cur.next.next!=None:
            nxt = head.next #指向第二个结点
            temp = nxt.next #指向第三个结点
            cur.next = nxt
            nxt.next = head
            head.next = temp
            cur = head
            head = head.next
        return res.next

题号27

如果不要求原地操作，可以新建一个数组然后把不等于val的元素加到新数组中并返回新数组的长度，但是此题要求不能有额外的空间，考虑双指针。
左边一个指针l，右边一个指针r，l从头找符合val的元素，r从后找不符合val的元素，然后交换l,r，把所有val元素都放到数组的后半部分，然后返回前半部分的长度。

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
      #双指针
      l = 0
      r = len(nums)-1
      while l < r :
          while (l<r and nums[l]!=val):
              l+=1
          while (l<r and nums[r]==val):
              r-=1
          nums[l],nums[r] =nums[r],nums[l]
      return l

这里有报错，是因为没有区分遍历结束时l所指元素的取值情况，如果l所指的是val，返回l,如果不是，返回l+1,因为数组下标是从0开始的，l计算的是l之前不包括l位置元素的长度

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
      #双指针
      l = 0
      r = len(nums)-1
      while l < r :
          while (l<r and nums[l]!=val):
              l+=1
          while (l<r and nums[r]==val):
              r-=1
          nums[l],nums[r] =nums[r],nums[l]
      return l if nums[l] == val else l+1

题号35

注意前提条件，数组已经有序。有序说明啥？看见有序就想到二分查找啊！！！！
不过这里还是继续先说暴力法：从头到尾遍历，因为有序，那么遇到比他小的就往后走，遇到等于他的就输出，遇到比他大的说明你再后面也不可能有了那么这就是你的插入位置。大于target和等于的情况返回的都是i，否则就是遍历完也找不到这个值，那就在末尾插入，返回数组长度

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        for i   in range(len(nums)):
            if nums[i]>=target:
                return i
        return len(nums)

二分查找法：

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        l = 0
        r = len(nums)-1
        while l<r:
            mid = l+(r-l)//2 #防止溢出
            if nums[mid]==target:
                return mid
            elif nums[mid]>target:
                r=mid
            else:
                l=mid+1
        return l if nums[r]>=target else l+1

当l和r相邻差一个位置或者相等时，距离很近时，要比较是插入到l还是插入到r位置，如果l的值大于等target，那么插入到l位置，否则要向后一位

题号49

用哈希表来实现，对应在Python中就是用字典实现。
通过观察可以知道字母异位词的字母相同且每个字母出现的次数相同，如果对所有的字母异位词进行内部的一个排序会发现他们的排序结果是一致的，那么就可以通过一个排序，把排序结果相同的字母异位词形成键值对放入字典中，输出字典中的键值对就可以了。

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dict ={}
        for s in strs:
             #Python提供的Python方法返回的是一个列表形式的，str=‘adc’，返回[a,c,d]
            temp = ''.join(sorted(s)) #将（seq）序列中的元素以‘’中指定的字符连接生成一个新的字符串
            dict[temp] = dict.get(temp,[])+[s] 
            #python dict.get()，如果输入的值在dict中，会返回其对应的key值，否则返回一个定义的参数
        return dict.values()

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dict ={}
        for s in strs:
            temp = ''.join(sorted(s)) 
            dict[temp] = dict.get(temp,[])+[s]    
        return list(dict.values())

改最后一行，我也不知道为啥