王道日记 作业+leetCode思路

无奈多线程
又开始写文章了
哎
挺好的

想写的题目

591. 标签验证器
     LCP 04. 覆盖

不是很想写的题目

473. 火柴拼正方型
474. 最大兼容性评分和

LeetCode 473 写题记录

暴利查找感觉上时间没什么问题
可以优化成背包问题
背包问题和状态压缩问题之间天生好像有比较紧密的练习
背景
状态压缩知识不熟悉
对于写递归暴力搜索情绪上比较不愿意(累）
涉及比较多的改变和回复
没有新鲜感
二进制暴力搜索（比较有新鲜感）

给个思路把应该可以
枚举找edge
保存所有可能
参数设计 选过的边不好再选
继续枚举
继续枚举
继续枚举
枚举四次搞定
枚举函数参数设计（需要枚举的数组（int，int），不可以枚举的地方(限制条件）（int），） 返回类型（数组int /int[]）**
枚举数组结果包含所有的枚举
前面的枚举的结果会影响接下来的枚举
可能的枚举结果|当前枚举的结果 = 本次的枚举限制条件
可能代码组织
改进代码组织
不考虑减去枝条
递归枚举最大深度为4

优化思路一
排序后大于目标值的可以直接跳过

差不多了 时间有限兴趣有限写到这里可以了
状态压缩可以进一步优化时间复杂度+动态规划

上课笔记

基本没怎么听到
不过无所谓了的，思路跟一下，然后自己写就好了
一些点
1.要分成度为0度为1度2的点
对整个过程形成比较直观的想象

二叉搜索树的删除递归和循环两种方式

用自制的queue 来层序遍历树

2-3-4树

理论：

红黑树

排序实现

关键还是实现要点的记忆和推理和思考

如何找资资料

LLRB 维基百科–>论文作者-

循环转递归

作业

实现 BST 的下列 API:
typedef char K;
typedef struct tree_node {
K key;
struct tree_node left;
struct tree_node right;
} TreeNode;
typedef struct {
TreeNode* root;
} BST;
void bst_inorder(BST* tree);
void bst_postorder(BST* tree);
void bst_destroy(BST* tree);**

#pragma once
#include
#include
#include
typedef char K;
typedef struct tree_node {
	K key;
	struct tree_node* left;
	struct tree_node* right;
}TreeNode;
typedef struct {
	TreeNode* root;
}BST;
void bst_inorder_h(TreeNode* root) {
	if (root == NULL) {
		return;
	}
	bst_inorder_h(root->left);
	printf(" %c ", root->key);
	bst_inorder_h(root->right);
}
void bst_postorder_h(TreeNode* root) {
	if (root == NULL) {
		return;
	}
	bst_postorder_h(root->left);
	bst_postorder_h(root->right);
	printf(" %c ", root->key);
}
TreeNode* build_tree_h(const char* preorder, int s1, int e1, const char* inorder, int s2, int e2);
void bst_preorder(BST* tree);
void bst_inorder(BST* tree);
void bst_postorder(BST* tree);
void bst_destroy(BST* tree);
void bst_destroy_h(TreeNode* node);
void bst_inorder(BST* tree) {
	bst_inorder_h(tree->root);
}
void bst_postorder(BST* tree) {
	bst_postorder_h(tree->root);
}
void bst_destroy(BST* tree) {
	bst_destroy_h(tree->root);
	free(tree);

}
void bst_destroy_h(TreeNode* tree) {
	if (tree == NULL) {
		return;
	}
	bst_destroy_h(tree->left);
	bst_destroy_h(tree->right);
	free(tree);
}

(拓展题，不要求所有同学都做) 根据先序遍历序列和中序遍历序列构建 BST (元素类型为char)。
// 假定preorder和inorder能构建一颗二叉树，不需要校验参数
BST build_tree(const char preorder, const char* inorder);**

BST* build_tree(const char* preorder, const char* inorder) {
	int len1 = (sizeof(preorder) / sizeof(preorder[0]));
	int len2 = (sizeof(inorder) / sizeof(inorder[0]));
	printf("%d\n",sizeof(inorder));
	printf("%d", strlen(inorder));
	len1 = len1 + 1;
	len2 = len2 + 1;

	printf("%d", strlen(preorder));
	printf("\n");
	for (int i = 0; i < len1; i++) {
		printf("%c", preorder[i]);
	}
	printf("\n");
	for (int i = 0; i < len2; i++) {
		printf("%c", inorder[i]);
	}
	printf("\n");
	printf("长度: %d", len1);
	printf("\n");
	if (len1 != len2) {
		return NULL;
	}
	BST* bst =(BST*)malloc(sizeof(BST));
	TreeNode* temp = build_tree_h(preorder, 0, len1-1, inorder, 0, len2-1);
	bst->root = temp;
	return bst;
}

int find_same_char_index(char target, const char* inorder, int s1,int e1) {
	for (int i = s1; i <= e1; i++) {
		if (inorder[i] == target) {
			return i;
		}
	}
	return -1;
}
TreeNode* build_tree_h(const char* preorder,int s1,int e1,const char* inorder,int s2,int e2) {
	TreeNode* ret = NULL;
	if (s1 > e1) {
		return ret;
	}
	if (s2 > e2) {
		return ret;
	}
	int s = find_same_char_index(preorder[s1], inorder, s2,e2);
	if (s == -1) {
		return ret;
	}
	ret = (TreeNode*)malloc(sizeof(TreeNode));
	ret->key = preorder[s1];
	// 2 0 1 3 4 
	// 0 1 2 3 4
	printf("%c", ret->key);
	int len1 = s - s2;//左边的个数
	int len2 = e2 - s; // 右边的个数
		ret->left = build_tree_h(preorder, s1 + 1, s1 + len1, inorder, s - len1, s -1);

		ret->right = build_tree_h(preorder, s1 + len1 + 1, e1, inorder, s + 1, s+len2);
	
	return ret;
}

请实现选择排序和冒泡排序，并分析它们的时间复杂度，空间复杂度和稳定性。
void selection_sort(int arr[], int n);
void bubble_sort(int arr[], int n);

#pragma once
#include 
void selection_sort(int arr[], int n);
void bubble_sort(int arr[], int n);
void swap(int arr[], int index1, int index2);
void selection_sort(int arr[], int n) {
	int temp_index = 0;
	for (int i = 0; i < n-1; i++) {
		temp_index = i;
		for (int j = i + 1; j < n; j++) {
			if (arr[j] < arr[temp_index]) {
				temp_index = j;
		   }
		}
		if (arr[i] > arr[temp_index]) {
			swap(arr, i, temp_index);
			
		}
	
	}
}
void swap(int arr[], int index1, int index2) {
	int t = arr[index2];
	arr[index2] = arr[index1];
	arr[index1] = t;
}
void bubble_sort(int arr[], int n) {
	int len = 0;
	for (int i = 0; i < n-1; i++) {
		for (int j = 0; j < n - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				swap(arr, j, j + 1);
				len++;
			}
		}
		if (len == 0) {
			return;
		}
   }

}