july算法课笔记

# coding=utf-8

# 第一题
'''
给定某字符串S，该字符串中有若干空格，
删除这些空格，并返回修改后的字符串；要
求时间复杂度O(N)，空间复杂度O(1)。
如：“I_have_a___dream!”，返回“Ihaveadream”
注：有可能两个单词间存在若干空格。
'''
import copy
import pprint
import random
import re
import collections


def is_remove(a_str):
    pattern = re.compile(r"[\u4e00-\u9fa5]")
    find_list = pattern.findall(a_str)
    if find_list:
        return False
    else:
        return True


def remove_blank(a_in_str, is_remove):
    size = len(a_in_str)
    str_list = list(a_in_str)
    i = 0  # 遍历所有的字符
    j = 0  # 遍历所有的有效字符，因此j<=i
    while (i < size):
        if is_remove(str_list[i]):
            i += 1
        else:
            if j < i:
                str_list[j] = str_list[i]
            i += 1
            j += 1
    return "".join(str_list[:j])   


# print remove_blank("asdb   dfd",is_remove)

# 第二题：
'''
给定一个数组，找出该数组最大的数。
'''


def find_max(a_int_list):
    if not a_int_list:
        return
    max = a_int_list[0]
    for i in a_int_list:
        if i > max:
            max = i
    return max


# print find_max([1,3,4,5,6,4,5])

# 第三题
'''
给定一个数组，找出该数组最大和次大的两
个数。
'''


def find_two_max(a_int_list):
    if not a_int_list:
        return
    if len(a_int_list) < 2:
        return
    max = a_int_list[0]
    max_2 = a_int_list[1]
    for i in a_int_list:
        if i > max:
            max = i
        elif i > max_2:
            max_2 = i
    return max, max_2


# print find_two_max([1,3,4,5,6,4,5])
# 哈夫曼编码
'''
Huffman编码
Huffman编码是一种无损压缩编码方案。
思想：根据源字符出现的(估算)概率对字符
编码，概率高的字符使用较短的编码，概率
低的使用较长的编码，从而使得编码后的字
符串长度期望最小。
Huffman编码是一种贪心算法：每次总选择
两个最小概率的字符结点合并。
称字符出现的次数为频数，则概率约等于频数
除以字符总长；因此，概率可以用频数代替。
'''


# 计算给定字符串中每个字符的个数
def calc_frequency(a_in_str):
    counter = collections.defaultdict(lambda: 0)
    for a_char in a_in_str:
        counter[a_char] += 1
    return counter


# 定义树节点
class HuffmanNode():
    def __init__(self):
        self.value = 0
        self.parent = None
        self.left_child = None
        self.right_child = None


def select_two_mini(hn_list):
    # 选出两个较小的节点
    #
    if not hn_list:
        return
    mini_1 = None
    mini_2 = None
    i = 0
    for node in hn_list:
        if not node.value or node.parent is not None:
            # 如果已经在树的叶子节点,则continue
            i = i + 1
            continue
        else:
            if mini_1 is None:
                mini_1 = i
                i += 1
                continue
            if mini_2 is None:
                mini_2 = i
                i += 1
                continue
            elif node.value < hn_list[mini_1].value:
                mini_1 = i
            elif node.value < hn_list[mini_2].value:
                mini_2 = i
        i += 1
    return mini_1, mini_2