import smtplib
from email.mime.text import MIMEText
from email.header import Header

"""
    回溯算法（试探法）
    在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

    回溯算法解决问题的
    针对所给问题，定义问题的解空间，它至少包含问题的一个（最优）解。
    确定易于搜索的解空间结构,使得能用回溯法方便地搜索整个解空间 。
    以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。
"""


class StockTest(object):
    """
        栈练习
    """

    def queen(self, A, cur=0):
        """
            八皇后问题
        :param A:
        :param cur:
        :return:
        """
        if cur == len(A):
            print(A)
            # return 0
        else:
            for col in range(len(A)):
                A[cur], flag = col, True
                # 判断当前与之前的所有是否规则冲突
                for row in range(cur):
                    if A[row] == col or abs(col - A[row]) == cur - row:
                        flag = False
                        break
                if flag:
                    self.queen(A, cur + 1)

    def movingCount(self, threshold, rows, cols):
        "产生 0 矩阵 "
        board = [[0 for i in range(cols)] for j in range(rows)]
        global acc
        acc = 0
        "下标之和,若大于threshold则TRUE,否则Folse"

        def block(r, c):
            s = sum(map(int, str(r) + str(c)))
            return s > threshold

        def traverse(r, c):
            global acc
            if not (0 <= r < rows and 0 <= c < cols):  # 超出角标范围挑出
                return
            if board[r][c] != 0:  # 不等于0 跳出
                return
            if board[r][c] == -1 or block(r, c):
                board[r][c] = -1  # 超出门限的点记录-1
                return

            board[r][c] = 1  # 符合规定的点记录1，并计数加一
            acc += 1
            traverse(r + 1, c)
            traverse(r - 1, c)
            traverse(r, c + 1)
            traverse(r, c - 1)

        traverse(0, 0)
        return acc

    def bubble_sort(self, numbers):
        """
            时间复杂度：O(n^2)
        :param numbers:
        :return:
        """
        n = len(numbers)
        for i in range(n):
            for j in range(0, n - i - 1):
                if numbers[j] > numbers[j + 1]:
                    numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

        return numbers

    def choose_sort(self, numbers):
        """
            选择排序，时间复杂度O(n^2)
        :param numbers:
        :return:
        """
        n = len(numbers)
        for i in range(n):
            min_index = i
            min_value = numbers[i]
            for j in range(i + 1, n):
                if min_value > numbers[j]:
                    min_value = numbers[j]
                    min_index = j
            if min_index != i:
                numbers[min_index] = numbers[i]
                numbers[i] = min_value

        return numbers

    def insert_sort(self, numbers):
        """
            插入排序,时间复杂度O(n^2)
        :return:
        """
        n = len(numbers)
        for i in range(1, n):
            insert_index = i - 1
            insert_value = numbers[i]
            while insert_index >= 0 and insert_value < numbers[insert_index]:
                numbers[insert_index + 1] = numbers[insert_index]
                insert_index -= 1
            if insert_index + 1 != i:
                numbers[insert_index + 1] = insert_value
        return numbers

    def shell_sort(self, numbers):
        """
            希尔排序，时间复杂度O(n^2)
        :param numbers:
        :return:
        """
        n = len(numbers)
        gap = int(n / 2)
        while gap > 0:
            for i in range(gap, n):
                temp = numbers[i]
                j = i
                while j >= gap and numbers[j - gap] > temp:
                    numbers[j] = numbers[j - gap]
                    j -= gap
                numbers[i] = temp
            gap = int(gap / 2)
        return numbers

    def quick_sort(self, numbers):
        """
            快速排序,时间复杂度O(n^2)
        :param numbers:
        :return:
        """
        if len(numbers) <= 1:
            return numbers
        pivot = numbers[int(len(numbers) / 2)]
        left = [x for x in numbers if x < pivot]
        middle = [pivot]
        right = [x for x in numbers if x > pivot]
        return self.quick_sort(left) + middle + self.quick_sort(right)

    def merge_sort(self, numbers):
        """
            归并排序
        :param numbers:
        :return:
        """

        pass

    def radix_sort(self, numbers):
        """
            基数排序,时间复杂度O(n*k)
        :param number:
        :return:
        """
        # 记录当前正在排拿一位，最低位为1
        i = 0
        max_num = max(numbers)
        # 记录最大值的位数
        j = len(str(max_num))
        while i < j:
            # 初始化桶数组
            bucket_list = [[] for _ in range(10)]
            for x in numbers:
                # 找到位置放入桶数组
                bucket_list[int(x / (10 ** i)) % 10].append(x)

            numbers.clear()
            # 放回原序列
            for x in bucket_list:
                numbers.extend([a for a in x])
            i += 1
        return numbers

    def send_mail(self):
        sender = '1285211525@qq.com'
        receivers = '1285211525@qq.com'
        message = MIMEText('Python 邮件发送测试...', 'plain', 'utf-8')
        message['From'] = Header('binren')
        message['To'] = Header('zhangbr')
        subject = 'test mail'
        message['Subject'] = Header(subject, 'utf-8')
        try:
            stmp_obj = smtplib.SMTP('localhost')
            stmp_obj.sendmail(sender, receivers, message.as_string())
            print('send successful')
        except Exception as e:
            print(e)

if __name__ == '__main__':
    st = StockTest()
    nums = [1, 2, 5, 3, 1, 101, 10, 1111, 2]
    print(st.send_mail())