算法题（十一）

1、快乐数

　　本质可以将快乐数问题转变成一个隐式链表判环的问题，如果是快乐数，则快指针一定会变成1，如果不是慢指针一定会和快指针相遇（佛洛依德算法）

 

2、反转链表

　　用两个指针，快指针记住后一个节点位置，慢指针作为反转的下一个节点。

 

3、字符串异构

　　构造一个函数，使用哈希映射，将每个字符串翻译成‘aacd’型，判断翻译之后的结果是否相等。

 

4、移除链表元素

　　简单题

5、重复的元素

　　使用滑动窗口。

 

def count1(n):
    res = 0
    while n:
        res +=1
        n &= (n-1)   #n 和 n-1相与，可以消除n二进制数中，最后一位1，知道所有的值全部变成0
    return res

def count2(n):
    res = 0
    while n:
        temp = n&1
        n = n >> 1  #n每次右移一位，只有当n的最后一位是1是，temp才会为1
        res = res + temp
    return res

def happyNum(num):  #快乐数
    def get_next(n):  #获取下一个数
        sum = 0
        while n != 0:
            n,m = divmod(n,10)
            sum += m**2
        return sum
    faster_p = get_next(num)
    slow_p = num
    while faster_p != 1 and faster_p != slow_p:
        print(faster_p,slow_p)
        faster_p = get_next(get_next(faster_p))
        slow_p = get_next(slow_p)
    return faster_p == 1

def drop_same_node(pHead,val):  #删除链表重复元素
    nHead = pre = pHead
    p = pre.next
    while p.next != None:
        if p.val == val:
            p = p.next
            pre.next = p
        else:
            p = p.next
            pre = pre.next
    return nHead

def same_structure_string(S,T):  #同构字符串
    def decode(stringA):
        stringlist = list(stringA)
        res = ''
        temp = {}
        for i in range(len(stringlist)):
            if stringlist[i] not in temp.keys():
                res += chr(97+i)
                temp[stringlist[i]] = i
                continue
            res += chr(97+temp[stringlist[i]])
        return res
    print(decode(S),decode(T))
    return decode(S) == decode(T)

def reverseNode(pHead):  #反转链表
    cur = None
    pre = pHead
    while pre:
        temp = pre.next
        pre.next = cur
        pre = temp
        cur = pre
    return pre



    pass
if __name__ == '__main__':
    a = 1000
    # print(count1(a),count2(a))
    # print(happyNum(20))
    # print(same_structure_string('paperper','titletle'))
    print(1|2|3)