外太空的博客

红黑树实现（C++模板实现）

lua实现stack（lua程序设计21.7 练习21.1题）Stack = {}function Stack:new(o) o = o or {} self.__index = self setmetatable(o,self) return oendfunction Stack:push(v) table.insert(self,v)endfunction Stack:pop() local v = self[#self] table.

二叉搜索树#ifndef C11LEARN_BINARYSEARCHTREE_H#define C11LEARN_BINARYSEARCHTREE_H#include "../chapter10/BinaryTreeNode.h"template<typename T>class BinarySearchTree{protected: BinaryTreeNode<T>* root; int size;public: BinarySearch

写出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

写出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

二叉树的中序遍历非递归方法（算法导论第三版12.1-3）1⃣️用栈实现template<typename T>void inorder_tree_walk_non_recursion_by_stack(BinaryTreeNode<T> *node){ Stack<BinaryTreeNode<T>*> stack; stack.push(node); while (!stack.empty()) { B

二叉树的遍历(算法导论第三版12.1-4)1⃣️先序遍历template<typename T>void preorder_tree_wald(BinaryTreeNode<T> *node){ if(node!= nullptr) { std::cout<<node->key<<" "; preorder_tree_wald(node->left); preorder_tre

hash table(完全散列实现的哈希表)完全散列特点：静态的，创建时候完成了散列表的生成。不可以删，也不可以增加数据。只可以修改数据。内部用全域散列生成#ifndef C11LEARN_HASHPERFECT_H#define C11LEARN_HASHPERFECT_H#include "KeyNode.h"#include "HashUniversal.h"template<typename T>class HashPerfect{protected:

hash table(全域散列法实现的哈希表）利用每次重建哈希表时随机生成散列函数#ifndef C11LEARN_HASHUNIVERSAL_H#define C11LEARN_HASHUNIVERSAL_H#include "Chain.h"#include "../tools/random.h"template<typename T>class HashUniversal{protected: Chain<T>** array; int ca

hash table(开放寻址法-双重散列实现的哈希表）#ifndef C11LEARN_HASHDOUBLE_H#define C11LEARN_HASHDOUBLE_H#include "HashLiner.h"template<typename T>class HashDouble:public HashLiner<T>{protected: virtual int hashing(int key,int index); virtual int a

hash table(开放寻址法-二次探查实现的哈希表）#ifndef C11LEARN_HASHQUADRATIC_H#define C11LEARN_HASHQUADRATIC_H#include "HashLiner.h"template<typename T>class HashQuadratic:public HashLiner<T>{public: HashQuadratic(int c1 = 1,int c2 = 2);protected:

hash table(开放寻址法-线性探查实现的哈希表）//// Created by 许加权 on 2021/7/17.//#ifndef C11LEARN_HASHLINER_H#define C11LEARN_HASHLINER_H#include "KeyNode.h"template<typename T>class HashLiner{public: HashLiner(); HashLiner(const HashLiner<T>

hash table(乘法实现）#ifndef C11LEARN_HASHMULTI_H#define C11LEARN_HASHMULTI_H#include "HashDivision.h"template<typename T>class HashMulti:public HashDivision<T>{private: long w; long p; long long s; long long two_32;public:

辅助类Chain#ifndef C11LEARN_CHAIN_H#define C11LEARN_CHAIN_Htemplate<typename T>class Chain{public: int key; T value; Chain<T> *prev; Chain<T> *next;public: Chain(){} Chain(int key,const T value):key(key),value

Hash-table（用除法散列法实现）关键字只支持int型，初学者版本//// Created by 许加权 on 2021/7/16.//#ifndef C11LEARN_HASHDIVISION_H#define C11LEARN_HASHDIVISION_H#include "Chain.h"template<typename T>class HashDivision{private: int capacity; Chain<T>**a

辅助类BinaryTreeNodeLeftChildRightSibling(左孩子右兄弟，二叉树结点）template<typename T>class BinaryTreeNodeLeftChildRightSibling{public: T key; BinaryTreeNodeLeftChildRightSibling<T>* parent; BinaryTreeNodeLeftChildRightSibling<T>* left_

非递归遍历二叉树（算法导论第三版第十章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;

辅助类BinaryTreeNode(二叉树节点)template<typename T>class BinaryTreeNode{public: T key; BinaryTreeNode<T>* parent; BinaryTreeNode<T>* left; BinaryTreeNode<T>* right;public: BinaryTreeNode(){} BinaryTreeNode(T k

给定一个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

对象的单数组表示（用单数组实现链表-不一样的链表实现）#ifndef C11LEARN_SINGULARGROUPSREPRESENTOBJECTS_H#define C11LEARN_SINGULARGROUPSREPRESENTOBJECTS_H#include "cmath"#include "../tools/tool.h"template<typename T>class SingularGroupsRepresentObjects{private: int

对象的多数组表示(不一样的链表-多数组表示链表）//// Created by xxx on 2021/7/12.//#ifndef C11LEARN_MOSTGROUPSREPRESENTOBJECTS_H#define C11LEARN_MOSTGROUPSREPRESENTOBJECTS_Htemplate<typename T>class MostGroupsRepresentObjects{private: int capacity; int *n

Θ(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

单项循环链表//// Created by 许加权 on 2021/7/12.//#ifndef C11LEARN_SINGLECYCLELINK_H#define C11LEARN_SINGLECYCLELINK_H#include "chapter10.h"template<typename T>class SingleCycleL{public: HalfNode<T> *Nil;public: SingleCycleL(){

使用单项循环链表实现字典操作(算法导论第十章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

List(C++模版实现的带哨兵的双向链表）#ifndef C11LEARN_LIST_H#define C11LEARN_LIST_Htemplate<typename T>class List{protected: class Node { public: Node *pre; Node *next; T key; Node(){} Node(const T key):key(

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

Queue（队列 C++模版实现）#ifndef C11LEARN_QUEUE_H#define C11LEARN_QUEUE_Htemplate<typename T>class Queue{private: int tail; int head; int capacity; T *array;public: Queue(int capacity = 50); Queue(const Queue<T> &queu

Stack(栈 c++模版实现）#ifndef C11LEARN_STACK_H#define C11LEARN_STACK_Htemplate<typename T>class Stack{private: int capacity; int top; T *array;public: Stack(int capacity = 50); Stack(const Stack<T>& stack); Stack<