【convert-sorted-list-to-binary-search-tree】

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.


题意;将排序链表转换成平衡二叉树;

每次取中间节点,自然就是平衡二叉树了;

思路:自顶向下递归解决,先找到中间节点作为根节点,然后递归左右两部分,所以我们先需要连找到中间节点,对于单链表来说,

必须要遍历一遍,可以使用快慢指针加速查找速度;

class Solution {
public:
	TreeNode* sortedListToBST(ListNode* head)
	{
		if (head==NULL)
		{
			return NULL;
		}

		//用快慢指针来找中间节点
		ListNode* slow = head;
		ListNode* fast = head;
		ListNode* preSlow = NULL;

		while (fast!=NULL && fast->next!=NULL)
		{
			preSlow = slow;
			slow = slow->next;
			fast = fast->next->next;
		}

		TreeNode* mid = new TreeNode(slow->val);
		//分别递归左右部分
		if (preSlow!=NULL)
		{
			preSlow->next = NULL;
			mid->left = sortedListToBST(head);
		}

		if (slow->next!=NULL)
		{
			mid->right = sortedListToBST(slow->next);
		}

		return mid;
	}
};



  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FP-Tree算法用于发现频繁项集,是一种基于树结构的算法。以下是一个简单的Python实现: 首先,需要定义一个类来表示FP-Tree中的每个节点: ```python class TreeNode: def __init__(self, name, count, parent): self.name = name self.count = count self.parent = parent self.children = {} self.next = None ``` 其中,name表示节点的名称,count表示节点的出现次数,parent表示节点的父节点,children表示节点的子节点,next表示节点的下一个节点(用于连接FP-Tree的相同项)。 接下来,需要定义一个函数来构建FP-Tree: ```python def build_tree(data, min_support): # 第一遍扫描数据,统计每个项的出现次数 item_counts = {} for trans in data: for item in trans: if item in item_counts: item_counts[item] += 1 else: item_counts[item] = 1 # 删除不满足最小支持度的项 freq_items = {k: v for k, v in item_counts.items() if v >= min_support} # 如果没有频繁项,则返回空 if not freq_items: return None, None # 对频繁项按照出现次数进行排序 sorted_items = sorted(freq_items.items(), key=lambda x: (-x[1], x[0])) # 构建根节点 root = TreeNode(None, 0, None) # 第二遍扫描数据,构建FP-Tree for trans in data: # 按照出现次数排序后的项 ordered_items = [item for item, _ in sorted_items if item in trans] # 从根节点开始,添加每个项到FP-Tree curr_node = root for item in ordered_items: if item in curr_node.children: # 如果项已存在,则增加计数 child = curr_node.children[item] child.count += 1 else: # 否则,添加新的节点 child = TreeNode(item, 1, curr_node) curr_node.children[item] = child # 连接FP-Tree的相同项 if item in freq_items: if freq_items[item][1] is None: freq_items[item][1] = child else: curr = freq_items[item][1] while curr.next is not None: curr = curr.next curr.next = child curr_node = child return root, freq_items ``` 其中,data表示数据集,min_support表示最小支持度。该函数首先统计每个项的出现次数,并删除不满足最小支持度的项。然后,按照出现次数排序后的项,从根节点开始,添加每个项到FP-Tree中。如果项已存在,则增加计数;否则,添加新的节点,并连接FP-Tree的相同项。 最后,可以使用递归来挖掘频繁项集: ```python def find_patterns(tree, freq_items, prefix): patterns = [] # 对于每个频繁项,生成其对应的频繁项集 for item, node in freq_items.items(): support = node[0] # 如果项集包含前缀,则添加到结果集 curr_prefix = prefix + [item] patterns.append((curr_prefix, support)) # 递归地挖掘以该项为结尾的频繁项集 cond_tree, cond_freq_items = build_tree(get_conditional_data(node[1]), min_support) if cond_tree is not None: patterns.extend(find_patterns(cond_tree, cond_freq_items, curr_prefix)) return patterns def get_conditional_data(node): # 从当前节点追溯到根节点,生成条件模式基 cond_data = [] while node is not None: path = [] curr = node while curr.parent is not None: path.append(curr.name) curr = curr.parent cond_data.append(path) node = node.next return cond_data ``` 其中,find_patterns函数从每个频繁项生成其对应的频繁项集,并递归地挖掘以该项为结尾的频繁项集。get_conditional_data函数从当前节点追溯到根节点,生成条件模式基。 这样,就可以用Python实现FP-Tree算法了。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值