la, lb均为非递减有序线性表现要由la, lb构造非递减有序线性表lc算法如下：void mergelist(list la, list lb, &list lc){ init(lc); i = j = 1; k = 0; len_a = length(la); len_b = length(lb); while(i <= len_a && j <= len_b

树的定义：树是n（n >= 0）个结点的有限集(当n = 0时，称为空树)。任意一棵非空树满足以下条件：1.有且仅有一个特定的称为根的结点;2.当n＞1时，除根结点外的其余结点被分成m（m > 0）个互不相交的有限集合T1, T2, ... , Tm，其中每个集合又是一棵树，并称为这个根节点的子树。显然树的定义也是递归的。树的基本术语：结点拥有的子树数称为结点的

RB-tree（红黑树）：平衡的二叉搜索树

#include #include using namespace std;int main(){ string s; cin >> s; for(int i = s.length() - 1; i >= 0; i--){ cout << s[i]; } cout << endl; return 0;}

iterative（重复的，反复的，迭代的）：var i, a = 0 // 迭代前初始化for i from 1 to 3{ // 循环3次 a = a + i // a的值增加i}print a // 打印出数字6recursion（递归）：public s

递归：void inOrder1(BinTree *root) //递归中序遍历{ if(root!=NULL) { inOrder1(root->lchild); coutdata<<" "; inOrder1(root->rchild); }}非递归：void inOrder2(BinTree

串是由零个或多个字符组成的有限序列。Index(S, T, pos)子串的定位操作通常称作串的模式匹配(T称为模式串)。

#include using namespace std;void RemoveNumber(char * str){ if (NULL == str) { return; } char *read = str; char *write = str; while (*read != '\0') { i

一个楼梯有50个台阶，每一步可以走一个台阶，也可以走两个台阶，请问走完这个楼梯共有多少种方法？

定义：线段树是一棵二叉树，记为T(a, b)，参数a,b表示区间[a,b]，其中b-a称为区间的长度，记为L。线段树T(a,b)也可递归定义为：

trie树后缀数组B树B+树

int listdelete (linklist &l, int i){ p = l; j = 0; while (p -> next && j < i - 1){ //p指向第i个节点的前驱 p = p -> next; j++; } if(!(p -> next) || i <= 0){ return error; } node * q = p ->

“二叉树的第i层至多有2^(i − 1)个结点；深度为k的二叉树至多有2^k − 1个结点（根结点的深度为1）”因为2^9-1 完全二叉树的深度是10，前9层是一个满二叉树，这样的话，前九层的结点就有2^9-1=511个；而第九层的结点数是2^(9-1)=256所以第十层的叶子结点数是700-511=189个；现在来算第九层的叶子结点个数。由于第十层的叶子结点是从第九层延伸的，所

平衡二叉树（balanced binary tree）--AVL tree：它或者是一棵空树；或者具有下列性质：左右子树均为平衡二叉树，且左右子树的深度之差的绝对值不超过1

#include void bubble_sort(int a[], int n){ for(int i = 0; i < n - 1; i++){ for(int j = 0; j < n - i -1; j++){ if(a[j+1] < a[j]){ int temp = a[j+1]; a[j+1] = a[j]; a[j] = temp; }

类似于整理扑克的过程#include using namespace std;void insertion_sort(int a[], int n){ for(int i = 1; i <= n - 1; i++){ int x = a[i]; int j = i - 1; while(j >= 0 && a[j] > x){ a[j+1] = a[j]; j-

二叉排序树--二叉查找树--二叉搜索树（binary sort tree）：或者是一棵空树;或者具有下列性质:1.左子树不空，左子树所有节点值均小于根的值2.右子树不空，右子树所有节点值均大于根的值3.左右子树分别为二叉排序树

la和lb均为非递减单链表，现由la, lb合并出lc（lc非递减），算法如下：void mergelist(&la, &lb, &lc){ pa = la -> next; pb = lb -> next; lc = pc = la; while(pa && pb){ if(pa -> data data){ pc -> next = pa; pc = pa;

void Insertsort(int a[], int n){ int i, j; for (i = 1; i < n; i++) if (a[i] < a[i - 1]) { int temp = a[i]; for (j = i - 1; j >= 0 && a[j] > temp; j--) a[j + 1] = a[j]; a[j + 1] = t

void Bubble_Sort(int a[], int n){ for(int i = n - 1,bool change = true; i >= 1 && change; i--){ change = false; for(int j = 0; j < i; j++){ if(a[j] > a[j+1]){ Swap(a[j], a[j+1]); chan

int Search_Binary(int a[], int n, int key){ int low = 0; int high = n - 1; while(low <= high){ int mid = (low + high) / 2; if(key == a[mid]) return mid; else if(key > a[mid]) low = mi

功能：把从src开始的且含有NULL的字符串复制到以dest开头的地址空间。char* strcpy(char *d, const char *s){ char *r=d; while((*d++=*s++)); return r;}/* while((*d++=*s++)); 的解释：赋值表达式返回左操作数，所以在复制NULL后，循环停止 */

功能：把从src开始的n个字节数据复制到以dest开头的地址空间。void * memcpy(void * dest, const void * src, size_t count){ char * tmp = (char *)dest; const char * s = (char *)src; while (count--){ *tmp++ = *s++ ;

建立在比较基础上的查找：顺序查找，比较结果"=" "!="二分查找，比较结果">" "理想情况，一次访问，无须比较。那就需要将KEY和LOC建立联系。KEY -> F(KEY) = LOCF为哈希函数哈希函数构造方法：直接定址法：LOC = A * KEY + B处理冲突方法：线性探测再散列:LOC(i) = (F(KEY) + i) M

void DFS(GRAPH G,int v){ visited[v] = true; visit(v); for (w = firstAdjVex(G, v); w != 0; w = nextAdjVex(G, v, w)){ if (!visited[w]){ DFS(G, w); } }}//递归过深可能造成栈溢出

void preOrder(BinTree *root) { stack s; BinTree *p=root; while(p!=NULL||!s.empty()) { while(p!=NULL) { coutdata<<" "; s.push(p);

a = a + b;b = a - b;a = a - b;

int listinsert(linklist &l, int i, int e){ //typedef node * linklist p = l; j = 0; while (p && j < i - 1){ p = p -> next; j++; } if (!p || i <= 0){ return error; } s = new node(); s

程序 = 逻辑结构 + 物理结构 + 策略贪心法就是

void creatlist(linklist &l, int n){ l = new node(); l -> next = NULL; while (int i = 1; i <= n; i++){ p = new node(); cin >> p -> data; p -> next = l -> next; l -> next = p; }}

External sorting is a term for a class of sorting algorithms that can handle massive amounts of data. External sorting is required when the data being sorted do not fit into the main memory of a c

#include using namespace std;char *revstr(char *str, size_t len) //typedef unsigned int size_t{ char *start = str; char *end = str + len - 2; char ch; if (str != NULL)

typedef int DataType; //类型定义typedef struct node{ //单链表定义 DataType data; struct node *next;}LinkedNode, *LinkList;void ReverseList(LinkList &ListHead){ if( (NULL == ListHead) || (NUL