import pandas as pd
data = pd.read_csv('ex1data1.txt', header=None, names=['Population', 'Profit'])
print(data.head())

import matplotlib.pyplot as plt
plt.scatter(x=data['Population'], y=data['Profit'], label='data', marker='.', color='b')
plt.legend()
plt.show()

import numpy as np
data.insert(0, 'ones', 1)  # 在第0列插入1，表头为ones 
x = data.iloc[:, 0:-1]  # 切片工具[几行到几行, 几列到几列]
y = data.iloc[:, -1:]
x, y = np.matrix(x.values), np.matrix(y.values)
theta = np.matrix(np.zeros(x.shape[1]))  # 初始化theta

import numpy as np
# 计算代价函数
def cost_function(x_, y_, theta_):
    ans = np.power(x_.dot(theta_.T)-y_, 2)
    return np.sum(ans)/(2*x_.shape[0])

print(cost_function(x, y, theta))

def gradient_descent(x_, y_, theta_, alpha_, inters_):
    temp = np.matrix(np.zeros(theta.shape))
    nums = int(theta_.shape[1])
    cost = np.zeros(inters_)
    for inter in range(inters_):
        ans = x_.dot(theta_.T)-y_
        for i in range(nums):
            temp[0, i] = theta_[0, i] - alpha_*np.sum(np.multiply(ans, x_[:, i]))/len(x_)
        theta_ = temp
        cost[inter] = cost_function(x_, y_, theta_)
    return theta_, cost

# 设置参数
alpha = 0.01
inters = 1500
g, cost = gradient_descent(x, y, theta, alpha, inters)
# 画出预测函数
x_test = np.linspace(data['Population'].min(), data['Population'].max(), data.shape[0])
# linspace(start,end,num=50)从间隔取出50个数
predict = g[0, 0]+g[0, 1]*x_test
plt.scatter(x=data['Population'], y=data['Profit'], label='data', marker='.', color='b')
plt.plot(x_test, predict, c='r', label='predict')
plt.xlabel('Population')
plt.ylabel('Profit')
plt.legend()
plt.show()

data2 = pd.read_csv('ex1data2.txt', header=None, names=['Size', 'Bedrooms', 'Price'])
print(data2.head())

data2 = (data2-data2.mean())/data2.std()
print(data2.head())

data2.insert(0, 'ones', 1)
x2 = data2.iloc[:, 0:-1]  
y2 = data2.iloc[:, -1:]
x2, y2 = np.matrix(x2.values), np.matrix(y2.values)
theta2 = np.matrix(np.zeros(x2.shape[1]))  

def normal_eqn(x_, y_):  # 正规方程
    return np.linalg.inv(x_.T.dot(x_)).dot(x_.T).dot(y_)

print(normal_eqn(x2, y2))

# 迭代3：标记法迭代（需要双倍的空间来存储访问状态）：
# 前、中、后、层序通用模板，只需改变进栈顺序或即可实现前后中序遍历，
# 而层序遍历则使用队列先进先出。0表示当前未访问，1表示已访问。
class Solution:
    def preOrd(self, root: TreeNode) -> List[int]:
        res = []
        stack = [(0, root)]
        while stack:
            flag, cur = stack.pop()
            if not cur: continue
            if flag == 0:
                # 前序，标记法
                stack.append((0, cur.right))
                stack.append((0, cur.left))
                stack.append((1, cur))
                
                # # 后序，标记法
                # stack.append((1, cur))
                # stack.append((0, cur.right))
                # stack.append((0, cur.left))
                
                # # 中序，标记法
                # stack.append((0, cur.right))
                # stack.append((1, cur))
                # stack.append((0, cur.left))  
            else:
                res.append(cur.val)  
        return res
        
        # # 层序，标记法
        # res = []
        # queue = [(0, root)]
        # while queue:
        #     flag, cur = queue.pop(0)  # 注意是队列，先进先出
        #     if not cur: continue
        #     if flag == 0:
                  # 层序遍历这三个的顺序无所谓，因为是队列，只弹出队首元素
        #         queue.append((1, cur))
        #         queue.append((0, cur.left))
        #         queue.append((0, cur.right))
        #     else:
        #         res.append(cur.val)
        # return res



# 莫里斯遍历
# 时间复杂度：O(n)，n为节点数，看似超过O(n)，有的节点可能要访问两次，实际分析还是O(n)
# 空间复杂度：O(1)，如果在遍历过程中就输出节点值，则只需常数空间就能得到中序遍历结果，空间只需两个指针。
# 如果将结果储存最后输出，则空间复杂度还是O(n)。

# PS：莫里斯遍历实际上是在原有二叉树的结构基础上，构造了线索二叉树，
# 线索二叉树定义为：原本为空的右子节点指向了中序遍历顺序之后的那个节点，把所有原本为空的左子节点都指向了中序遍历之前的那个节点

# 此处只给出中序遍历，前序遍历只需修改输出顺序即可
# 而后序遍历，由于遍历是从根开始的，而线索二叉树是将为空的左右子节点连接到相应的顺序上，使其能够按照相应准则输出
# 但是后序遍历的根节点却已经没有额外的空间来标记自己下一个应该访问的节点，
# 所以这里需要建立一个临时节点dump，令其左孩子是root。并且还需要一个子过程，就是倒序输出某两个节点之间路径上的各个节点。

# 莫里斯遍历，借助线索二叉树中序遍历（附前序遍历）
class Solution:
    def inOrd(self, root: TreeNode) -> List[int]:
        res = []
        # cur = pre = TreeNode(None)
        cur = root

        while cur:
            if not cur.left:
                res.append(cur.val)
                # print(cur.val)
                cur = cur.right
            else:
                pre = cur.left
                while pre.right and pre.right != cur:
                    pre = pre.right
                if not pre.right:
                    # print(cur.val) 这里是前序遍历的代码，前序与中序的唯一差别
                    pre.right = cur
                    cur = cur.left
                else:
                    pre.right = None
                    res.append(cur.val)
                    # print(cur.val)
                    cur = cur.right
        return res


# N叉树遍历
# 时间复杂度：时间复杂度：O(M)，其中 M 是 N 叉树中的节点个数。每个节点只会入栈和出栈各一次。
# 空间复杂度：O(M)。在最坏的情况下，这棵 N 叉树只有 2 层，所有第 2 层的节点都是根节点的孩子。
# 将根节点推出栈后，需要将这些节点都放入栈，共有 M−1个节点，因此栈的大小为 O(M)。


# N叉树简洁递归
class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        if not root: return []
        res = [root.val]
        for node in root.children:
            res.extend(self.preorder(node))
        return res

# N叉树通用递归模板
class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        res = []
        def helper(root):
            if not root:
                return
            res.append(root.val)
            for child in root.children:
                helper(child)
        helper(root)
        return res

# N叉树迭代方法
class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        if not root:
            return []
        s = [root]
        # s.append(root)
        res = []
        while s:
            node = s.pop()
            res.append(node.val)
            # for child in node.children[::-1]:
            #     s.append(child)
            s.extend(node.children[::-1])
        return res

# 定义核函数
   def kernel(self, x1, x2):
       m,n = x1.shape[0], x2.shape[0]
       dist_matrix = np.zeros((m,n), dtype=float)
       for i in range(m):
           for j in range(n):
               dist_matrix[i][j] = np.sum((x1[i]-x2[j])**2)
       return np.exp(-0.5/self.h**2*dist_matrix)

# 导入相关库
import numpy as np
import matplotlib.pyplot as plt
# 定义高斯过程类
class GPR:
   def __init__(self, h):
       self.is_fit = False
       self.train_x, self.train_y = None, None
       self.h = h
       
   def fit(self, x, y):
       self.train_x = np.asarray(x)
       self.train_y = np.asarray(y)
       self.is_fit = True
       
   def predict(self, x):
       if not self.is_fit:
           print("Sorry! GPR Model can't fit!")
           return
       
       x = np.asarray(x)
       kff = self.kernel(x,x)
       kyy = self.kernel(self.train_x, self.train_x)
       kfy = self.kernel(x, self.train_x)
       kyy_inv =  np.linalg.inv(kyy + 1e-8*np.eye(len(self.train_x)))
       
       mu = kfy.dot(kyy_inv).dot(self.train_y)
       return mu
       
       
   # 定义核函数
   def kernel(self, x1, x2):
       m,n = x1.shape[0], x2.shape[0]
       dist_matrix = np.zeros((m,n), dtype=float)
       for i in range(m):
           for j in range(n):
               dist_matrix[i][j] = np.sum((x1[i]-x2[j])**2)
       return np.exp(-0.5/self.h**2*dist_matrix)

# 创造训练集
train_x = np.arange(0,10).reshape(-1,1)
train_y = np.cos(train_x) + train_x
# 制造槽点
train_y = train_y + np.random.normal(0, 0.01, size=train_x.shape)
# 显示训练集的分布
plt.figure()
plt.scatter(train_x, train_y, label="train", c="red", marker="x")
plt.legend()
plt.show()

# 创建训练集
test_x = np.arange(0, 10, 0.1).reshape(-1,1)

# 针对不同h值得到拟合图像
h=0.1
for i in range(10):
    gpr = GPR(h)
    gpr.fit(train_x, train_y)
    mu = gpr.predict(test_x)
    test_y = mu.ravel()
    plt.figure()
    plt.title("h=%.2f"%(h))
    plt.plot(test_x, test_y, label="predict")
    plt.scatter(train_x, train_y, label="train", c="red", marker="x")
    plt.legend()
    plt.show()
    h += 0.1