面试题算法题总结 二

字符串处理

给定一个字符串，找到最长子字符串的长度，要求子字符串中所有字符不重复。
Example:
Input: “abcabcbb”
Output: 3
Explanation: 满足条件的最长子字符串为 “abc”, 长度为3.

使用暴力破解法，这是一种比较容易理解的方法，但是执行效率偏低
 - 思路是我们遍历整个字符串，依次找出所有符合条件的字串，
 - 找到满足条件的最大长度的字串
 - 判断字串中元素是否重复，可以对这个元素放入字串循环判断，也可以使用set集合
 
 def computeSubString(s):
     # 定义2个set集合，用于判断元素是否重复
     subSet = set([])
     curSet = set([])
     max = 0 # 用于纪录每次比较得出的最大长度
     for i in range(len(s)):
         # 循环遍历s中所有可能的字串，步长为1
         # 每遍历一次，都需要给存贮字串的set集合重新赋值
         subSet = set([s[i]])
         curSet = set([s[i]])
         # 从i的后一位开始检索字串
         for j in range(i+1,len(s)):
             subSet.add(s[j])
             # 如果s[j]不重复,添加成功，进入if，否则break
             if len(subSet) > len(curSet):
                  curSet.add(s[j])
            else:
                 break
         # 纪录下此时的最大值
         if len(curSet) > max:
             max = len(curSet)
    return max
 
 
 if __name__ == '__main__':
     print(computeSubString('abcabcbb')) # 3

链表

有两个有序链表A和B，合并A和B成为一个新的有序列表C，并去除其中的重复元素。尽量不要开辟新的存储空间，时间复杂度O(n)。

思路：
- 既然是有序列表，先合并两个列表中的数值较小的列表，在合并过程中，使用set判断元素是否会重复，一直合并到较小的那一方没有元素为止，假设合并之后的列表为列表C。
- 然后对于剩下的那一方较大的链表，判断其元素是否重复，将其不重复的元素添加到列表C中，完成最后合并

# 定义链表
class ListNode(object):
    def __init__(self,x):
        self.val = x
        self.next = None
        
class Merge(object):
    def __init__(self):
        # 用于判断元素是否重复
        self.values = set([])
        self.curValues = set([])

    def mergeList(self,head1,head2):
        
        # 设置一个临时的节点，保存最初的节点
        newHead = ListNode(0)
        pre = newHead
        
        # 开始合并
        while(head1 and head2):
            # 判断元素大小，谁小就添加谁
            if head1.val > head2.val:
                # 判断待添加的元素是否会重复
                if self.checkValue(head2.val):
                    pre.next = head2
                    head2 = head2.next
                else:
                    # 如果元素重复，head2前进一格，跳过本次循环
                    head2 = head2.next
                    continue
            else:
                if  self.checkValue(head1.val):
                     pre.next = head1
                     head1 = head1.next
                else:
                     head1 = head1.next
                     continue
             pre = pre.next
             
        # 合并剩余的节点
        if head1:
            self.mergeLeft(head1,pre)
            
        if head2:
            self.mergeLeft(head2,pre)
            
        return newHead.next
            
    
    # 检查待元素是否重复
    def checkValue(self,value):
        self.values.add(value)
        if len(self.values) > len(self.curValues):
            self.curValues.add(value)
            return True
        else:
            return False
            
    def mergeLeft(self,head,pre):
        if not head.next:
            pre.next = head
            return
        
        while head.next:
            if head.val == head.next.val:
                head = head.next
                
                if not head.next:
                    pre.next = head
                continue
            else:
                pre.next = head
                head = head.next
                
                
if __name__ == '__main__':
    head = ListNode(10)
    p1 = ListNode(20)
    p2 = ListNode(31)
    p3 = ListNode(40)
    p4 = ListNode(50)
    p5 = ListNode(60)
    p6 = ListNode(76)
    p7 = ListNode(76)
    p8 = ListNode(78)
    p9 = ListNode(78)
    p10 = ListNode(78)
    
   head.next = p1
   p1.next = p2
   p2.next = p3
   p3.next = p4
   p4.next = p5
   p5.next = p6
   p6.next = p7
   p7.next = p8
   p8.next = p9
   p9.next = p10
   
   
   head2 = ListNode(11)
   p11 = ListNode(21)
   p12 = ListNode(31)
   p13 = ListNode(31)
   p14 = ListNode(41)
   p15 = ListNode(71)
   p16 = ListNode(76)
   
   head2.next = p11 
   p11.next = p12
   p12.next = p13
   p13.next = p14
   p14.next = p15
   p15.next = p16
   
  m = Merge()
  h = m.mergeList(head,head2)
  
  while h:
      print(h.val)
      h = h.next

二进制

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

def getOneCount(num):
    if num > 0:
        b_num = bin(num)
        count = b_num.count('1')
        return count
    elif num < 0:
        b_num = bin(~num)
        count = 8 - b_num.count('1')
        return count
    else:
        return 8


if __name__ == '__main__':
    print(getOneCount(5))
    print(getOneCount(-5))
    print(getOneCount(0))