ZDF0414的专栏

#includeusing namespace std;class BitMap{public: BitMap(size_t size) { _capacity = size / 32 + 1; _array = new int[_capacity]; memset(_array, 0, sizeof(int)*_capacity); } void SetBit(int

广义表是线性表的扩展，是有n个元素组成有限序列。广义表的定义是递归的，因为在表的描述中又得到了表，允许表中有表。 A = () B = (a,b) C = (a,b,(c,d)) D = (a,b,(c,d),(e,(f),h)) #includeusing namespace std;enum Type //结点类型{ HEAD_TYPE

void Radix_sort(int a[], int size ){ int *count = new int[10]; int *bucket = new int[size]; int radix = 1; for (int i = 1; i<=get_bit(a,10); i++)

int GetMid(int a[], int left, int right)//三数取中{ int mid = left + (right - left) / 2; if (a[left] <a[right]) { if (a[mid] < a[left]) { return left; } else { if (a[mid]>a[right])

void AdjustDown(int a[], int root, int size) //调整堆{ int left = root * 2 + 1; int right = left + 1; int key = left; while (left < size) { if (righta[right]) { key = right; } if (a[key

//合并两个有序数组void Merge(int a[], int left, int mid, int right){ assert(a); int* tmp = new int[right - left + 1](); int index = 0; int begin1 = left, end1 = mid; int begin2 = mid + 1, end2 = right

#include#includeusing namespace std;enum State{ EMPTY, DELETE, EXIST,};class HashTable{public: HashTable(int capacity) { v.reserve(capacity); v.assign(capacity, 0); s.reserve(capaci

题目描述：从上到下按层打印二叉树，同一层的结点按从左到右的顺序打印，每一层打印到一行，例如：void Print(){ if (_root == NULL) return; queueq; q.push(_root); int NextLevel = 0; //下一行结点的个数 int CurLevel = 1; //当前行结点的个数 while (!q.empty())

对于num1+num2可分为三步完成：（1）对num1与num2做二进制相加，不计进位（这一步可用异或实现）；（2）记录进位（可用位与运算,因为相同位都为1，才会向前产生进位;即得到进位的方法为(num1&num2)（3）把（1）与（2）的结果相加,方法同上,直到不再产生进位，即可得到结果；由于不能使用加减乘除，那么我们可以试着考虑位操作对两数进行运算：如：num1=5，num

void Count_sort(int a[], int size ){ int min = a [0]; int max = a [0]; for (int i = 1; i < size; i++) { if (a [i]>max)

//LIst.hpp#ifndef _LIST_H_#define _LIST_H_#includeusing namespace std;templatestruct Node{ T _value; Node* _next; Node(const T& value) : _value(value) , _next(NULL) {}};templatec

#include#include#includeusing namespace std;templatestruct Node{ K _key; V _value; Node*_next; Node(const K& key, const V& value) :_key(key) , _value(value) , _next(NULL) {}};templa

文件压缩与解压思想： （1）统计字符出现次数，结合最小堆的性质生成哈夫曼树； （2）对叶节点进行编码，结点左边编0，右边编1； （3）读取文件，用哈夫曼编码代替字符产生新的字符，即压缩； （4）读取压缩文件，进行哈夫曼编码的解读产生相应字符，即解压；例如，对以下数据生成哈夫曼树，以及产生相应的哈夫曼编码：//自己写的最小堆（因为在加强巩固，所以没用STL里的）

二叉搜索树的性质：（1）每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。（2）左子树上所有节点的关键码（key）都小于根节点的关键码（key）。（3）右子树上所有节点的关键码（key）都大于根节点的关键码（key）。（4）左右子树都是二叉搜索树。           缺陷：在特殊情况下，会退化成单链表的形式，若还以搜索树来看待问题，效率就会很低

AVL树：保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。AVL树的性质：（1）左子树和右子树的高度之差的绝对值不超过1                        （2）树中的每个左子树和右子树都是AVL树。

红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡红黑树是满足下面红黑性质的二叉搜索树：（1）每个节点，不是红色就是黑色的（2）根节点是黑色的（3）如果一个节点是红色的，则它的两个子节点是黑色的(没有连续的红节点)（4）对每个节点

//以下出现的_root标示二叉树的根节点//非递归先序遍历（根节点->左节点->右节点）思想：即用栈实现//遍历二叉树的前提条件是：该二叉树不为空。在满足该条件的情况下，进行以下步骤：//1.先将二叉树的根节点push进栈。//2.在该栈不为空的条件下，执行一个循环（先用top保存栈顶元素，再对栈进行pop操作，因为栈具有后进先出的特点// ，所以先对top->_right进行判断

迷宫问题求解思路：  1.在给定迷宫入口的情况下，先把该入口进行入栈操作，并将其值改为2。  2.然后以栈顶元素的位置作为试探点，向四个方向进行试探。  3.遇到0值，则为通路，将0值所在位置入栈，并将其值改为2（标识能走得通的）。当栈顶元素位置的行或列为N时，则走出迷宫,return true.否则转（2）。  4.遇到1值，则该路不通，将试探点的值改为3（标识走了，但走不通

一、栈逆序void Move_bottom_top(stack&s)//把栈底元素移动到栈顶位置{ if (s.empty()) { return; } int top1 = s.top(); s.pop(); if (!s.empty()) { Move_bottom_top(s); int top2 = s.top(); s.pop(); s.push(

设数组为a[0…n-1]。1.      初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=12.      将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。3.      i++并重复第二步直到i==n-1。排序完成。void InsertSort(int a[], int size){ int i, j; for (i

希尔排序的实质就是分组插入排序，该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。 该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的。分

思想：在一次遍历中同时选出最大数与最小数void SelectSort(int a[], int size){ assert(a); int left = 0; int right = size - 1; while (left < right) { int min = left; int max = right; for (int i = min; i <= max;

void BubbleSort(int a[], int size){ assert(a); int i = size - 1; int j = 0; while (i) { int exchange = 0; for (j = 0; j < i; j++) { if (a[j]>a[j + 1]) { swap(a[j], a[j + 1]);

#include#include#includeusing namespace std;struct BinaryTreeNode{ char _value; //节点值 BinaryTreeNode*_left; //左孩子 BinaryTreeNode*_right;//右孩子 BinaryTreeNode(const char value) :_val

二叉树是一种非线性结构，遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。用二叉树作为存储结构时，取到一个节点，只能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息。enumPointerTag {THREAD,LINK};

满二叉树与完全二叉树的区别：(1)完全二叉树，除最后一层可能不满以外，其他各层都达到该层节点的最大数；最后一层如果不满，该层所有                               节点都全部靠左排。(2)满二叉树，所有层的节点数都达到最大.满二叉树与完全二叉树的判断：(1)满二叉树：因为满二叉树的节点个数size与树的深度h的关系为：2^h - 1 = siz

#includeusing namespace std;enum PointTag{ LINK, THREAD,};struct BinTreeThingNode{ char _data; BinTreeThingNode*_left; BinTreeThingNode*_right; PointTag _leftTag; PointTag _rightTag; Bi

#includeusing namespace std;enum PointTag{ LINK, THREAD,};struct BinTreeThingNode{ char _data; BinTreeThingNode*_left; BinTreeThingNode*_right; PointTag _leftTag; PointTag _rightTag; Bi

#include#includeusing namespace std;enum Type{ ADD, SUB, MUL, DIV, OP_NUM,};struct Cell{ Type _type; int num;};Cell RPNexp[] = { OP_NUM, 12, OP_NUM, 3, OP_NUM, 4, ADD, 0, MUL, 0,

//两个栈实现一个队列的思想：//1.只要实现的是队列的push功能，就把数据push进_PushStack栈。//2.要实现队列的pop功能时，分两种情况：// (1):当_PopStack栈中有数据时，就把_PopStack的栈顶元素pop出去；// (2):当_PopStack栈中无数据时，就用一个循环（依次把_PushStack栈中的栈顶数据push进_PopStack，再对

//两个队列实现一个栈的思想：用_PushQ1队列作为push数据的队列，用_TmpQ2队列暂存数据////1.只要是对栈进行push操作，就将数据push入_PushQ1队列中。//2.要实现栈的pop操作，就要在_PushQ1队列或_TmpQ2队列不为空的情况下：// （1）若_PushQ1队列为空，而_TmpQ2队列不为空时，则swap（_TmpQ2, _PushQ1)，便得_Pus

//判断顺序栈出栈顺序的合法性思想：//给定一个入栈的字符串pushstr，再给定一个出栈的字符串popstr，根据栈的特性，判断该出栈顺序是否合法//1.先验证两个字符串的长度是否相等，不等，则肯定不合法；相等，再进行步骤2.//2.（1）判断pushstr与popstr当前所指向的字符的关系：// （2）当*pushstr != *popstr时，对*pushstr进行压栈操作后，p

返回栈中最小的元素，要求时间复杂度为O(1)思想：  以空间换时间，用两个栈DataStack栈中存储数据元素MinDataStack栈中存储最小的数据元素1.当两个栈都为空时，第一个数据元素在两个栈中都进行入栈操作2.再遇到元素时，先入DataStack栈3.将该元素与MinDataStack栈的栈顶元素比较，若小于MinDataStack栈的栈顶元素，则把该元素入M

因为稀疏矩阵的有效元素个数较少，所以以行优先的顺序把有效元素的信息封装在一个三元组中存储在顺序表里#include#includeusing namespace std;#define M 5#define N 6struct Tuple{ int _row; int _col; int _value;};class SparseMatrix{public: Sp

定义：一棵M（M>2）阶的平衡搜索树性质：以下出现的 M/2 均表示向上取整     （1）根节点至少有两个孩子     （2）每个非根节点有[M/2,M]个孩子     （3）每个非根节点有[M/2,M-1]个关键字，并且以升序排列     （4）key[i]和key[i+1]之间的孩子节点的值介于key[i]、key[i+1]之间     （5）所有的叶子节点都在同