外太空的博客

给出TREE_INSERT过程的非递归版本（算法导论第三版12.3-1）template<typename T>void insert_recursive(BinaryTree<T>& tree,BinaryTreeNode<T>* root, BinaryTreeNode<T>* node){ if(tree.root == nullptr) { tree.root = node; return;

写出TREE-MINIMUM 和TREE-MAXIMUM的递归版本（算法导论第三版12.2-2）template<typename T>BinaryTreeNode<T>* tree_minimum_recursion(BinaryTreeNode<T>* node){ if(node == nullptr) return node; if(node->left != nullptr) return tree_minimum_r

写出TRERE-PREDECESSOR的伪代码（算法导论第三版12.2-3）TREE-PREDECESSOR(x) if x.left != NIL return TREE-MAXIMUM(x.left) y = x.p while y != NIL and x == y.left x = y y = y.p return y下面是c++代码template<typename T>BinaryTreeNod

算法导论第三版第十一章11.1-4我们希望在一个非常大的数组上，通过利用直接寻址的方式来实现一个字典。开始时，该数组中可能包含一些无用信息，但要堆整个数组进行初始化时不太实际的，因为该数组的规模太大。请给出在大数组上实现直接寻址字典的方案。每个存储对象占用O（1）空间；SEARCH INSERT 和 DELETE操作的时间均为O（1）；并且对数据结构初始化的时间为O（1）。template<typename T>KeyNode<T>* huge_array_search(Key

位向量(bit vector)位向量（bit vector）是一个仅包含0和1的数组。长度为m的位向量所占空间要比包含m个指针的数组少得多。说明如何用一个位向量来表示一个包含不同元素（无卫星数据）的动态集合。字典操作运行时间应为O（1）（算法导论第十一章11.1-2）//里面的用循环转换了数据 这个在严格要求时间的复杂度下可以移动外部操作int bit_search(char *array,int k){ if(array[k]) { int result = 1;

假设一动态集合S用一个长度为m的直接寻址表T来表示。请给出一个查找S中最大元素的过程。你所给的过程在最坏情况下的运行时间是多少。（算法导论第十一章11.1-1）#include "KeyNode.h"template<typename T>KeyNode<T>* direct_address_search(KeyNode<T>** array,int k){ return array[k];}template<typename T>vo

利用链表实现可合并堆（算法导论第三版思考题10-2）List全部代码链接地址a 链表已排序创建一个空堆： Θ(1)插入：Θ(n)，插入后依然保持排序最小值：Θ(1)，第一位便是取最小值：Θ(1)合并：Θ(n)，可以修改插入排序或者用归并排序的合并过程实现b 链表树为排序的创建一个空堆： Θ(1)插入：Θ(1)最小值：Θ(n)，循环遍历取最小值：Θ(n)，循环遍历合并：Θ(1)，如果不考虑深拷贝问题，考虑的话Θ(n)复制数据c 链表树未排序的，且待合并的动态合集是不相交的同b

非递归遍历二叉树（算法导论第三版第十章10.4-5）template<typename T>void TraverseBinaryTreeNonRecursive(BinaryTreeNode<T>* root){ BinaryTreeNode<T>* prev = nullptr; BinaryTreeNode<T>* current = root; while (current!= nullptr) {

给定一个n节点二叉树，写出一个O(n)时间的非递归的过程，将该树每个结点的关键字输出。要求除该树本树的存储空间外只能使用固定量的额外存储空间，且过程中不得修改该树，即使是暂时的修改也不允许。（算法导论第三版第十章10.4-5）template<typename T>void TraverseBinaryTreeNonRecursive(const BinaryTreeNodeIndex<T>* array,int index){ int prev = -1;

给定一个n节点的二叉树，写出一个O(n)时间非递归过程，将该树每个节点关键字输出，可以使用一个栈作为辅助数据结构（算法导论第十章10.4-3）template<typename T>void TraverseBinaryTreeByStack(const BinaryTreeNode<T>* array,const BinaryTreeNode<T>& root){ Stack<BinaryTreeNode<T>> stac

给定一个n节点的二叉树，写出一个O(n)时间递归过程，将该树每个节点关键字输出（算法导论第十章10.4-2）#include <iostream>template<typename T>class BinaryTreeNode{public: T key; int left; int right;public: BinaryTreeNode(){} BinaryTreeNode(const T key,int left = -1,

对一组同构对象用单数组表示法实现（算法导论第十章10.3-2）考虑到数据安全问题，多用了一个数组来处理安全问题。#ifndef C11LEARN_SINGULARGROUPSREPRESENTISOMORPHICOBJECTS_H#define C11LEARN_SINGULARGROUPSREPRESENTISOMORPHICOBJECTS_H#include <cstring>template<typename T>class SingularGroupsRepr

Θ(n)反转单链表(算法导论第三版第十章10.2-7)template<typename T>void reverses(Single_L<T> &l){ if(l.head == nullptr || l.head == l.tail) return; HalfNode<T> * tail = l.head; HalfNode<T>*pre = l.head; HalfNode<T>*current

使用单项循环链表实现字典操作(算法导论第十章10.2-5题)template<typename T>class SingleCycleL{public: HalfNode<T> *Nil;public: SingleCycleL(){ Nil = new HalfNode<T>(); Nil->next = Nil; } virtual ~SingleCycleL() {

算法导论10-2.4题template<typename T>typename List<T>::Node* List<T>::search01(const T &key) { Nil->key = key; Node * current = Nil->next; while (current->key!=key) { current = current->next; }

用一个单链表L实现一个队列（算法导论第十章10.2-3)template<typename T>class HalfNode{public: T key; HalfNode* next;public: HalfNode(){ next = nullptr; }; HalfNode(const T key):key(key){ next = nullptr; };};template<typenam

用一个单链表L实现一个栈（算法导论第十章10.2-2题）template<typename T>class HalfNode{public: T key; HalfNode* next;public: HalfNode(){ next = nullptr; }; HalfNode(const T key):key(key){ next = nullptr; };};template<typenam

Deque（双向队列 c++模版实现 ）算法导论第三版第十章10.1-5题#ifndef C11LEARN_DEQUE_H#define C11LEARN_DEQUE_Htemplate<typename T>class Deque{private: int capacity; T*array; int head; int tail;public: Deque(int capacity = 20); Deque(const Dequ

带权中位数-算法导论第三版第九章思考题9-2b时间复杂度O(nlgn)float find_median_with_weights_b(float *array,int length){ quick_sort<float>(array,0,length-1); float sum = 0; int index = 0; while (sum < 0.5) { sum += array[index]; index

有序序列中的i个最大数（算法导论思考题9-1）a时间复杂度O(nlgn+i)//总共时间复杂度O(nlgn+i)vector<int> i_largest_number_in_ordered_sequence_a(int *array,int length,int i){ vector<int>result; //时间复杂度O(nlgn) quick_sort_by_median_contains_equal_elements(array,0,len

找出有序数组X和Y中所有元素的中位数（X，Y分别含n个元素）（算法导论第三版9.3-8）时间复杂度O（lgn）int find_median_two_ordered_arrays(int *array_a,int *array_b,int length){ int a_start = 0,a_end = length - 1,b_start = 0,b_end = length - 1; while (true) { int median_a = array_

确定S中最接近中位数的k个元素（算法导论第三版9.3-7题）时间复杂度O(n)vector<int> k_elements_closest_to_median(int *array,int start,int end,int k){ vector<int> result; int median = select(array,start,end,(end - start + 1)/2 + (end - start + 1) % 2); int *arra

快速排序在最坏的情况下时间复杂度Ω(nlgn)1⃣️在元素各异时或者少量相等（元素个数n>70)时间复杂度Ω(nlgn)void quick_sort_by_median(int *array,int start,int end){ if(start<end) { int median = select(array,start,end,(end - start + 1)/2 + (end - start + 1) % 2); int mid

找出第i个小元素(算法导论第三版9.2-4题)期望时间复杂度：Θ(n)最坏情况的时间复杂度Θ(n^2)int randomized_select_based_loop(int *array,int start,int end,int index){ while (true) { if(start == end) return array[start]; int middle = randomized_partition(arra

找出最大值和最小值（算法导论第三版9.1-2)在最坏的情况下，比较次数下界是⌈3n/2⌉−2void find_maximum_and_minimum_element(int *array,int length,int &max,int &min){ int remainder = length % 2; int start_index = 0; if(remainder) { max = array[0]; min =

找出第二小元素（算法导论第三版9.1-1题）时间复杂度Θ(n)比较次数n+⌈lgn⌉−2次思路：将元素每次分成2部分，第一部分和第二部分元素成对比较。最终获得最小的元素，记录那些和最小元素比较后的失败的元素，第二小元素就在其中。原理：第二小元素只有和最小元素比才会失败，其他元素和其比都它都能胜出。所以，第二小元素一定在那些和最小元素比较后失败的元素中。第二小元素一定能和最小元素比较，因为除了和最小元素比以外它都能胜出。...

算法导论水壶问题（第三版8-4）本算法只适用于解题，不通用。期望的时间复杂度O（nlgn）Kettle.h文件#ifndef C11LEARN_KETTLE_H#define C11LEARN_KETTLE_H#include <iostream>#include <vector>#include "../tools/random.h"using namespace std;class Kettle {public: string color;

算法-排序-k排序算法导论第三版第八章思考题8-5利用最小堆完成k部分元素排序#include "k_sort_heap.h"int left_k_sort(int parent){ return (parent << 1) + 1;}int right_k_sort(int parent){ return (parent << 1) + 2;}void heapify_k_sort(int *array,int heap_size,int par