我钟爱的数据结构大复习
来源:互联网 发布:互联网it服务 编辑:程序博客网 时间:2024/06/02 12:08
https://visualgo.net/
https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
闲着无聊可以来个自测
https://pta.patest.cn/pta/test
1.好久不用C语言补充一下基础语法
#include<stdio.h> #include<math.h> int main() { int n,m,i,j,t; char sign; scanf("%d %c",&n,&sign); n-=1; m=1;/*开始必有一行是一个点的*/ while(n-2*(m+2)>=0) { m+=2; n-=2*m; } t=m/2; for(i=0;i<m;i++) { for(j=0;j<t-abs(i-t);j++) printf(" "); for(j=0;j<abs(i-t)*2+1;j++) printf("%c",sign); printf("\n"); } printf("%d\n",n); return 0; }
2.1 线性表的顺序表示和实现
Common.h
#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status;
SqList.h
//------线性表的动态分配顺序存储结构-------- #include <stdlib.h> #include "Common.h" #define ElemType int #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LISTINCREMENT 10 //线性表存储空间的分配增量 typedef struct{ ElemType* elem; //存储空间基址 int length; //当前长度 int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位) } SqList; //基本操作 Status InitList(SqList &L); //操作结果:构造一个空的线性表L。 Status DestroyList(SqList &L); //初始条件:线性表L已存在。 //操作结果:销毁线性表L。 Status ClearList(SqList &L); //初始条件:线性表L已存在。 //操作结果:将L重置为空表。 bool ListEmpty(SqList L); //初始条件:线性表L已存在。 //操作结果:若L为空表,则返回TRUE,否则返回FALSE。 int ListLength(SqList L); //初始条件:线性表L已存在。 //操作结果:返回L中数据元素的个数。 Status GetElem(SqList L, int i, ElemType &e); //初始条件:线性表L已存在,1<=i<=ListLength(L)。 //操作结果:用e返回L中第i个数据元素的值。 int LocateElem(SqList L, int e, bool (*equal)(ElemType, ElemType)); //初始条件:线性表L已存在,compare()是数据元素判定函数。 //返回L中第一个与e满足关系compare()的数据元素的位序。若这样的数据元素不存在,则返回值为0. Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e); //初始条件:线性表L已存在。 //操作结果:若cur_e是L中的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义。 Status NextElem(SqList L, ElemType cur_e, ElemType &next_e); //初始条件:线性表L已存在。 //操作结果:若cur_e是L中的数据元素,且不是最后一个,则用next_e返回它的后继,否则操作失败,next_e无定义。 Status ListInsert(SqList &L, int i, ElemType e); //初始条件:线性表L已存在,1<=i<=ListLength(L)+1. //操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1. Status ListDelete(SqList &L, int i, ElemType &e); //初始条件:线性表L已存在且非空,1<=i<=ListLength(L). //操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1. Status ListTraverse(SqList L, bool (*visit)(ElemType)); //初始条件:线性表L已存在 //操作结果:依次对L的每个元素调用函数visit().一旦visit()失败,则操作失败。
SqList.cpp
#include <malloc.h> #include "SqList.h" Status InitList(SqList &L){ //操作结果:构造一个空的线性表L。 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType)); if(!L.elem) exit(OVERFLOW); //存储分配失败 L.length = 0; L.listsize = LIST_INIT_SIZE; return OK; }//InitList Status DestroyList(SqList &L){ //操作结果:销毁线性表L。 // free(&L); free(L.elem) return OK; } Status ClearList(SqList &L) { //操作结果:将L重置为空表。 L.length = 0; return OK; } bool ListEmpty(SqList L){ //操作结果:若L为空表,则返回TRUE,否则返回FALSE。 if(0 == L.length) return true; else return false; } int ListLength(SqList L){ //操作结果:返回L中数据元素的个数。 return L.length; } Status GetElem(SqList L, int i, ElemType &e){ //1<=i<=ListLength(L)。 //操作结果:用e返回L中第i个数据元素的值。 if(i < 1 || i>=L.length) return ERROR; e = L.elem[i-1]; return OK; } int LocateElem(SqList L, ElemType e, bool (*equal)(ElemType, ElemType)){ //compare()是数据元素判定函数。 //返回L中第一个与e满足关系compare()的数据元素的位序。若这样的数据元素不存在,则返回值为0. int i = 1; ElemType* p = L.elem; while(i <= L.length && !(*equal)(*p++, e)) ++i; if(i <= L.length) return i; else return 0; } Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e){ //操作结果:若cur_e是L中的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义。 int i=1; while(i <= L.length && !(cur_e==L.elem[i-1])) ++i; if(i<2 || i>L.length) return ERROR; pre_e = L.elem[i-2]; return OK; } Status NextElem(SqList L, ElemType cur_e, ElemType &next_e){ //操作结果:若cur_e是L中的数据元素,且不是最后一个,则用next_e返回它的后继,否则操作失败,next_e无定义。 int i=1; while(i <= L.length && !(cur_e==L.elem[i-1])) ++i; if(i<2 || i>L.length) return ERROR; next_e = L.elem[i]; return OK; } Status ListInsert(SqList &L, int i, ElemType e){ //1<=i<=ListLength(L)+1. //操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1. if(i < 1 || i>L.length+1) return ERROR; //i值不合法 if(L.length >= L.listsize) { ElemType * newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType)); if(!newbase) exit(OVERFLOW); L.elem = newbase; L.listsize += LISTINCREMENT; } ElemType * q = &(L.elem[i-1]); //q为插入位置 ElemType * p; for(p=&(L.elem[L.length-1]);p>=q;--p) *(p+1) = *p; //右移 *q = e; ++L.length; return OK; }//ListInsert Status ListDelete(SqList &L, int i, ElemType &e){ //1<=i<=ListLength(L). //操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1. if(i<1 || i>L.length) return ERROR; ElemType* p = &(L.elem[i-1]); e = *p; ElemType* q = L.elem + L.length - 1; for(++p;p<=q;++p) *(p-1) = *p; --L.length; return OK; } Status ListTraverse(SqList L, bool (*visit)(ElemType)){ //操作结果:依次对L的每个元素调用函数visit().一旦visit()失败,则操作失败。 int i=1; ElemType* p = L.elem; while(i <= L.length && (*visit)(*p++)) ++i; return OK; }
main.cpp
#include <stdio.h> #include "SqList.h" bool equal(int a, int b){ if(a == b) return true; return false; } bool visit(ElemType e){ printf(" %d", e); return true; } int main() { SqList L; ElemType e; ElemType pre_e; ElemType next_e; InitList(L); if(ListEmpty(L)) printf("kong\n"); for(int i=0;i<30;i++){ e = i+1; ListInsert(L, i+1, e); } e = 15; printf("15所在的位置为: %d\n", LocateElem(L, 15, equal)); PriorElem(L, e, pre_e); NextElem(L, e, next_e); printf("e的前驱为:%d\n", pre_e); printf("e的后驱为:%d\n", next_e); GetElem(L, 22, e); printf("第22个数为:%d\n", e); printf("遍历:"); ListTraverse(L, visit); printf("\n"); printf("List length is:%d\n", ListLength(L)); ClearList(L); printf("清空\n"); printf("List length is:%d\n", ListLength(L)); if(ListEmpty(L)) printf("kong\n"); ListInsert(L, 1, 3); ListInsert(L, 2, 7); ListInsert(L, 3, 9); ListInsert(L, 4, 1); ListInsert(L, 5, 44); printf("List length is:%d\n", ListLength(L)); printf("遍历:"); ListTraverse(L, visit); printf("\n"); ListDelete(L, 3, e); printf("所删除的值为: %d\n", e); printf("遍历:"); ListTraverse(L, visit); printf("\n"); printf("xiaohui:\n"); DestroyList(L); system("pause"); return 0; }
2.2 堆栈
定义:堆栈是一个在计算机科学中经常使用的抽象数据类型。堆栈中的物体具有一个特性: 最后一个放入堆栈中的物体总是被最先拿出来, 这个特性通常称为后进先出(LIFO)队列。 堆栈中定义了一些操作。 两个最重要的是PUSH和POP。 PUSH操作在堆栈的顶部加入一 个元素。POP操作相反, 在堆栈顶部移去一个元素, 并将堆栈的大小减一。
详细理论知识百度百科“堆栈”
2.3 队列
队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。
队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队,从队列中删除一个队列元素成为出队。因为队列只允许在一段插入,在另一端删除,所以只有最早进入队列的元素才能最先从队列中删除,故队列又称为先进先出(FIFO—first in first out)线性表。[1]
(1)初始化队列:Init_Queue(q) ,初始条件:队q 不存在。操作结果:构造了一个空队;(2)入队操作: In_Queue(q,x),初始条件: 队q 存在。操作结果: 对已存在的队列q,插入一个元素x 到队尾,队发生变化;(3)出队操作: Out_Queue(q,x),初始条件: 队q 存在且非空,操作结果: 删除队首元素,并返回其值,队发生变化;(4)读队头元素:Front_Queue(q,x),初始条件: 队q 存在且非空,操作结果: 读队头元素,并返回其值,队不变;(5)判队空操作:Empty_Queue(q),初始条件: 队q 存在,操作结果: 若q 为空队则返回为1,否则返回为0。在STL中,对队列的使用很是较完美下面给出循环队列的运算算法:(1)将循环队列置为空//将队列初始化SeQueue::SeQueue(){ front=0;rear=0;cout<<"init!"<<endl;}(2)判断循环队列是否为空int SeQueue::Empty(){ if(rear==front) return(1);else return(0);}(3)在循环队列中插入新的元素xvoid SeQueue::AddQ(ElemType x){ if((rear+1) % MAXSIZE==front) cout<<" QUEUE IS FULL! "<<endl;else{ rear=(rear+1) % MAXSIZE;elem[rear]=x;cout<<" OK!";}}(4)删除队列中队首元素ElemType SeQueue::DelQ(){ if(front==rear){ cout<<" QUEUE IS EMPTY! "<<endl; return -1;}else{ front=(front+1) % MAXSIZE;return(elem[front]);}}(5)取队列中的队首元素ElemType SeQueue::Front(){ ElemType x;if(front== rear)cout<<"QUEUE IS EMPTY "<<endl;else x= elem[(front+1)%MAXSIZE];return (x);}
详细理论知识和方法同 百度百科“队列”
http://www.cnblogs.com/kaituorensheng/archive/2013/02/28/2937865.html同参考
3.1 树与树的表示
父节点表示法
存储结勾
/* 树节点的定义 */#define MAX_TREE_SIZE 100typedef struct{ TElemType data; int parent; /* 父节点位置域 */} PTNode;typedef struct{ PTNode nodes[MAX_TREE_SIZE]; int n; /* 节点数 */} PTree;
基本操作
设已有链队列类型LinkQueue的定义及基本操作(参见队列)。
构造空树
清空或销毁一个树也是同样的操作
void ClearTree(PTree *T){ T->n = 0;}
构造树
void CreateTree(PTree *T){ LinkQueue q; QElemType p,qq; int i=1,j,l; char c[MAX_TREE_SIZE]; /* 临时存放孩子节点数组 */ InitQueue(&q); /* 初始化队列 */ printf("请输入根节点(字符型,空格为空): "); scanf("%c%*c",&T->nodes[0].data); /* 根节点序号为0,%*c吃掉回车符 */ if(T->nodes[0].data!=Nil) /* 非空树 */ { T->nodes[0].parent=-1; /* 根节点无父节点 */ qq.name=T->nodes[0].data; qq.num=0; EnQueue(&q,qq); /* 入队此节点 */ while(i<MAX_TREE_SIZE&&!QueueEmpty(q)) /* 数组未满且队不空 */ { DeQueue(&q,&qq); /* 节点加入队列 */ printf("请按长幼顺序输入节点%c的所有孩子: ",qq.name); gets(c); l=strlen(c); for(j=0;j<l;j++){ T->nodes[i].data=c[j]; T->nodes[i].parent=qq.num; p.name=c[j]; p.num=i; EnQueue(&q,p); /* 入队此节点 */ i++; } } if(i>MAX_TREE_SIZE){ printf("节点数超过数组容量\n"); exit(OVERFLOW); } T->n=i; } else T->n=0; }
判断树是否为空
Status TreeEmpty(PTree *T){ /* 初始条件:树T存在。操作结果:若T为空树,则返回TRUE,否则返回FALSE */ return T->n==0;}
获取树的深度
int TreeDepth(PTree *T){ /* 初始条件:树T存在。操作结果:返回T的深度 */ int k,m,def,max=0; for(k=0;k<T->n;++k){ def=1; /* 初始化本节点的深度 */ m=T->nodes[k].parent; while(m!=-1){ m=T->nodes[m].parent; def++; } if(max<def) max=def; } return max; /* 最大深度 */}
获取根节点
TElemType Root(PTree *T){ /* 初始条件:树T存在。操作结果:返回T的根 */ int i; for(i=0;i<T->n;i++) if(T->nodes[i].parent<0) return T->nodes[i].data; return Nil;}
获取第i个节点的值
TElemType Value(PTree *T,int i){ /* 初始条件:树T存在,i是树T中节点的序号。操作结果:返回第i个节点的值 */ if(i<T->n) return T->nodes[i].data; else return Nil;}
改变节点的值
Status Assign(PTree *T,TElemType cur_e,TElemType value){ /* 初始条件:树T存在,cur_e是树T中节点的值。操作结果:改cur_e为value */ int j; for(j=0;j<T->n;j++) { if(T->nodes[j].data==cur_e) T->nodes[j].data=value; } return ERROR; }
获取节点的父节点
TElemType Parent(PTree *T,TElemType cur_e){ /* 初始条件:树T存在,cur_e是T中某个节点 */ /* 操作结果:若cur_e是T的非根节点,则返回它的父节点,否则函数值为"空"*/ int j; for(j=1;j<T->n;j++) /* 根节点序号为0 */ if(T->nodes[j].data==cur_e) return T->nodes[T->nodes[j].parent].data; return Nil; }
获取节点的最左孩子节点
TElemType LeftChild(PTree *T,TElemType cur_e){ /* 初始条件:树T存在,cur_e是T中某个节点 */ /* 操作结果:若cur_e是T的非叶子节点,则返回它的最左孩子,否则返回"空"*/ int i,j; for(i=0;i<T->n;i++) /* 找到cur_e,其序号为i */ break; /* 根据树的构造函数,孩子的序号>其父节点的序号 */ if(T->nodes[j].parent==i) /* 根据树的构造函数,最左孩子(长子)的序号<其它孩子的序号 */ return T->nodes[j].data; return Nil; }
获取节点的右兄弟节点
TElemType RightSibling(PTree *T,TElemType cur_e){ /* 初始条件:树T存在,cur_e是T中某个节点 */ /* 操作结果:若cur_e有右(下一个)兄弟,则返回它的右兄弟,否则返回"空"*/ int i; for(i=0;i<T->n;i++) if(T->nodes[i].data==cur_e) /* 找到cur_e,其序号为i */ break; if(T->nodes[i+1].parent==T->nodes[i].parent) /* 根据树的构造函数,若cur_e有右兄弟的话则右兄弟紧接其后 */ return T->nodes[i+1].data; return Nil; }
输出树
void Print(PTree *T){ /* 输出树T。加 */ int i; printf("节点个数=%d\n",T->n); printf(" 节点 父节点\n"); for(i=0;i<T->n;i++) { printf(" %c",Value(T,i)); /* 节点 */ if(T->nodes[i].parent>=0) /* 有父节点 */ printf(" %c",Value(T,T->nodes[i].parent)); /* 父节点 */ printf("\n"); }}
向树中插入另一棵树
Status InsertChild(PTree *T,TElemType p,int i,PTree c){ /* 初始条件:树T存在,p是T中某个节点,1≤i≤p所指节点的度+1,非空树c与T不相交 */ /* 操作结果:插入c为T中p节点的第i棵子树 */ int j,k,l,f=1,n=0; /* 设交换标志f的初值为1,p的孩子数n的初值为0 */ PTNode t; if(!TreeEmpty(T)) /* T不空 */ { for(j=0;j<T->n;j++) /* 在T中找p的序号 */ if(T->nodes[j].data==p) /* p的序号为j */ break; l=j+1; /* 如果c是p的第1棵子树,则插在j+1处 */ if(i>1) /* c不是p的第1棵子树 */ { for(k=j+1;k<T->n;k++) /* 从j+1开始找p的前i-1个孩子 */ if(T->nodes[k].parent==j) /* 当前节点是p的孩子 */ { n++; /* 孩子数加1 */ if(n==i-1) /* 找到p的第i-1个孩子,其序号为k1 */ break; } l=k+1; /* c插在k+1处 */ } /* p的序号为j,c插在l处 */ if(l<T->n) /* 插入点l不在最后 */ for(k=T->n-1;k>=l;k--) /* 依次将序号l以后的节点向后移c.n个位置 */ { T->nodes[k+c.n]=T->nodes[k]; if(T->nodes[k].parent>=l) T->nodes[k+c.n].parent+=c.n; } for(k=0;k<c.n;k++) { T->nodes[l+k].data=c.nodes[k].data; /* 依次将树c的所有节点插于此处 */ T->nodes[l+k].parent=c.nodes[k].parent+l; } T->nodes[l].parent=j; /* 树c的根节点的父节点为p */ T->n+=c.n; /* 树T的节点数加c.n个 */ while(f) { /* 从插入点之后,将节点仍按层序排列 */ f=0; /* 交换标志置0 */ for(j=l;j<T->n-1;j++) if(T->nodes[j].parent>T->nodes[j+1].parent) {/* 如果节点j的父节点排在节点j+1的父节点之后(树没有按层序排列),交换两节点*/ t=T->nodes[j]; T->nodes[j]=T->nodes[j+1]; T->nodes[j+1]=t; f=1; /* 交换标志置1 */ for(k=j;k<T->n;k++) /* 改变父节点序号 */ if(T->nodes[k].parent==j) T->nodes[k].parent++; /* 父节点序号改为j+1 */ else if(T->nodes[k].parent==j+1) T->nodes[k].parent--; /* 父节点序号改为j */ } } return OK; } else /* 树T不存在 */ return ERROR; }
删除子树
Status deleted[MAX_TREE_SIZE+1]; /* 删除标志数组(全局量) */void DeleteChild(PTree *T,TElemType p,int i){ /* 初始条件:树T存在,p是T中某个节点,1≤i≤p所指节点的度 */ /* 操作结果:删除T中节点p的第i棵子树 */ int j,k,n=0; LinkQueue q; for(j=0;j<=T->n;j++) /* 置初值为0(不删除标记) */ pq.name='a';InitQueue(&q); /* 初始化队列 */ for(j=0;j<T->n;j++) break; /* j为节点p的序号 */ for(k=j+1;k<T->n;k++) { if(T->nodes[k].parent==j) n++; if(n==i) break; /* k为p的第i棵子树节点的序号 */ } if(k<T->n) /* p的第i棵子树节点存在 */ { n=0; pq.num=k; deleted[k]=1; /* 置删除标记 */ n++; EnQueue(&q,pq); while(!QueueEmpty(q)) { DeQueue(&q,&qq); for(j=qq.num+1;j<T->n;j++) if(T->nodes[j].parent==qq.num) { pq.num=j; deleted[j]=1; /* 置删除标记 */ n++; EnQueue(&q,pq); } } for(j=0;j<T->n;j++) if(deleted[j]==1) { for(k=j+1;k<=T->n;k++) { deleted[k-1]=deleted[k]; T->nodes[k-1]=T->nodes[k]; if(T->nodes[k].parent>j) T->nodes[k-1].parent--; } j--; } T->n-=n; /* n为待删除节点数 */ } }
层序遍历树
void TraverseTree(PTree *T,void(*Visit)(TElemType)){ /* 初始条件:二叉树T存在,Visit是对节点操作的应用函数 */ /* 操作结果:层序遍历树T,对每个节点调用函数Visit一次且仅一次 */ int i; for(i=0;i<T->n;i++) Visit(T->nodes[i].data); printf("\n");}
孩子链表表示法
存储结构[5]
/*树的孩子链表存储表示*/ typedef struct CTNode { // 孩子节点 int child; struct CTNode *next; } *ChildPtr; typede
3.2 二叉树及存储结构
(1)顺序存储方式typenode=recorddata:datatypel,r:integer;end;vartr:array[1..n]ofnode;(2)链表存储方式,如:typebtree=^node;node=recorddata:datatye;lchild,rchild:btree;end;
3.3 二叉树的遍历
先序遍历首先访问根,再先序遍历左(右)子树,最后先序遍历右(左)子树,C语言代码如下:void XXBL(tree*root){//DoSomethingwithrootif(root->lchild!=NULL)XXBL(root->lchild);if(root->rchild!=NULL)XXBL(root->rchild);}中序遍历首先中序遍历左(右)子树,再访问根,最后中序遍历右(左)子树,C语言代码如下void ZXBL(tree*root){if(root->lchild!=NULL)ZXBL(root->lchild);//DoSomethingwithrootif(root->rchild!=NULL)ZXBL(root->rchild);}后序遍历首先后序遍历左(右)子树,再后序遍历右(左)子树,最后访问根,C语言代码如下void HXBL(tree*root){if(root->lchild!=NULL)HXBL(root->lchild);if(root->rchild!=NULL)HXBL(root->rchild);//DoSomethingwithroot}层次遍历即按照层次访问,通常用队列来做。访问根,访问子女,再访问子女的子女(越往后的层次越低)(两个子女的级别相同)
例子:
范例二叉树:AB CD E此树的顺序结构为:ABCD##Eintmain(){node*p=newnode;node*p=head;head=p;stringstr;cin>>str;creat(p,str,0)//默认根节点在str下标0的位置return0;}//p为树的根节点(已开辟动态内存),str为二叉树的顺序存储数组ABCD##E或其他顺序存储数组,r当前结点所在顺序存储数组位置void creat(node*p,stringstr,intr){p->data=str[r];if(str[r*2+1]=='#'||r*2+1>str.size()-1)p->lch=NULL;else{p->lch=newnode;creat(p->lch,str,r*2+1);}if(str[r*2+2]=='#'||r*2+2>str.size()-1)p->rch=NULL;else{p->rch=newnode;creat(p->rch,str,r*2+2);}}
http://www.jianshu.com/p/45dd59940323
4.1 二叉搜索树
Size Balanced Tree(SBT)
AVL树
红黑树
Treap(Tree+Heap)
这些均可以使查找树的高度为O(log(n))
4.2 平衡二叉树
5.1 堆
堆中某个节点的值总是不大于或不小于其父节点的值;
堆总是一棵完全二叉树。
将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
堆的定义如下:n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时,称之为堆。
(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)
若将和此次序列对应的一维数组(即以一维数组作此序列的存储结构)看成是一个完全二叉树,则堆的含义表明,完全二叉树中所有非终端结点的值均不大于(或不小于)其左、右孩子结点的值。由此,若序列{k1,k2,…,kn}是堆,则堆顶元素(或完全二叉树的根)必为序列中n个元素的最小值(或最大值)。[1]
支持的基本操作
堆支持以下的基本:
build:建立一个空堆;insert:向堆中插入一个新元素;update:将新元素提升使其符合堆的性质;get:获取当前堆顶元素的值;delete:删除堆顶元素;heapify:使删除堆顶元素的堆再次成为堆。
5.2 哈夫曼树与哈夫曼编码
二叉树中有一种特别的树——哈夫曼树(最优二叉树),其通过某种规则(权值)来构造出一哈夫曼二叉树,在这个二叉树中,只有叶子节点才是有效的数据节点(很重要),其他的非叶子节点是为了构造出哈夫曼而引入的!
哈夫曼编码是一个通过哈夫曼树进行的一种编码,一般情况下,以字符:‘0’与‘1’表示。编码的实现过程很简单,只要实现哈夫曼树,通过遍历哈夫曼树,规定向左子树遍历一个节点编码为“0”,向右遍历一个节点编码为“1”,结束条件就是遍历到叶子节点!因为上面说过:哈夫曼树叶子节点才是有效数据节点!
首先就定义一个二叉树结构:
struct tree{ char date;//数据 bool min;//叶子节点 int quanzhi;//权值 struct tree *zuo,*you;//左右孩子}*tre;
其中权值是我们最需要关心的,因为我们就是要通过权值来构造,但权值怎么规定呢?当然是根据实际情况来!其中叶子节点是为了标记是叶子节点,便于后期编码!
为了简单说明,第一个例子就直接定义多个哈夫曼树节点,然后通过这些节点来构造出最终的哈夫曼树!
tree tr[9]={{'a',true,5},{'b',true,2},{'c',true,9},{'d',true,3},{'e',true,6}};
tr是一个哈夫曼数组,其中每个元素都是一个哈夫曼树,我们的任务就是将这些元素“整合”起来,使它们联系起来构成一个哈夫曼树。初始时,数组每个元素都是没有联系的,我们的任务就是把它们通过struct tree *zuo,*you;//左右孩子 来连接起来,形象上就是构成一棵二叉树。
我们先通过语言叙述的方法来构造一棵哈夫曼二叉树:
a 权值5
b权值2
c权值9
d权值3
e权值6
首先,取权值最小的两个节点“整合”出一个新的节点,该节点的权值为最小两个节点权值之和。如下图:
哈夫曼树详解、实现代码及哈夫曼编码实例
然后,将这个新的节点与剩下元素进行权值比较,依旧取最小的两个权值节点构造 新的节点,反复这个过程,直到取完所有元素,本例的哈夫曼树如下图:
哈夫曼树详解、实现代码及哈夫曼编码实例
其中叶子节点(也就是2,3,5,6,9)是有效的数据节点!构造时节点的左右顺序并不影响哈
曼树的构造,但会导致出现不同的编码,当然编码只要不出现前缀码就是正确的编码。
实现算法:
实现算法有很多种,关键是要理解它构造的原理。
通过上面的例子,我们知道构造一个哈夫曼树,需要的节点数数有效数据节点的2*n-1,其中
n是有效数据的个数,如上面例子,有效数据个数有5个,但最终构造出的哈夫曼树有2*5-1=9
个节点,所以根据这个性质就可写出一种算法:
tree tr[9]={{'a',true,5},{'b',true,2},{'c',true,9},{'d',true,3},{'e',true,6}};
5个数据所以需要9个空间,其中9-5=4个空间是给那些无效节点使用的(哈夫曼树种非叶子节点)。
首先,我们遍历这个数组,找到最小的两个元素。
然后,将他们移动到前面,并将权值求和构造出新的节点,新的节点左右子树指向最小的两个元素,将这个新节点插入有效数据后面。
最后,从第2+1个元素(前面两个无需遍历了)开始重新遍历。
重复上述过程,直到数组填满,填满后的最后一个元素就是最终的哈夫曼树。
如第一次遍历后数组tr[9]状态就变为:
tree tr[9]={ {'d',true,3},{'b',true,2},{'c',true,9}, {'a',true,5},{'e',true,6},{‘’,false,5,tr[0],tr[1]}}
最小的两个元素移到了前面,有效数据增加了一个,并且新节点左右子树指向前面两个元素。
完整哈夫曼实现代码如下;
// hfm.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#includestatic int hfmb=0;struct tree{ char date;//数据 bool min;//叶子节点 int quanzhi;//权值 struct tree *zuo,*you;//左右孩子}*tre;struct shfm{ char date;//字符数据 char bianm[11];//哈夫曼编码,最大编码数为11(可根据实际修改!)}hfm[100];//哈夫曼编码对应真实数据表void gettree(tree tr[],int shij,int youx)//构造哈夫曼树,tr树集合,shij集合实际数据个数,youx集合有效数据个数{ //模拟动态增长数组,每次构造新的树就插入有效数据后面 if (2*youx-1!=shij) { printf("参数不符合!"); return; } int c=0; while(youx!=shij)//当有效个数==实际个数时,构造完成! { for (int i=c;i { //每次循环取两个最小值并将两个最小值放置在当前循环起始两位 if (tr[i].quanzhi { tree p=tr[i]; tr[i]=tr[c]; tr[c]=p; } if (tr[i].quanzhi { tree p=tr[i]; tr[i]=tr[c+1]; tr[c+1]=p; } } //以下为通过最小值构造的新树 tr[youx].quanzhi=tr[c].quanzhi+tr[c+1].quanzhi; tr[youx].you=&tr[c];//新树右孩子指向当前循环的最小值之一 tr[youx].zuo=&tr[c+1];//新树左孩子指向当前循环的最小值之一 youx++;//新树插入当前有效数据个数后面 并使有效数据个数+1 c=c+2; }}void bianltree(tree *tr,char ch[])//哈夫曼编码{ //通过遍历树,得到每个节点的编码 static int i=0; if (!tr->min)//叶子节点 { ch[i]='0'; i++; bianltree(tr->zuo,ch);//左节点编码为"0" ch[i]='1'; i++; bianltree(tr->you,ch);//右节点编码为"1" } if (tr->min) { ch[i]='\0';//结束标记() printf("%c %s \n",tr->date,ch); hfm[hfmb].date=tr->date; int j=0; while(j!=i||i>10) { hfm[hfmb].bianm[j]=ch[j]; j++; }//保存编码映射表 hfmb++; } i--;//递归走入右叶子节点时,取消当前赋值(当前必为左边叶子节点)}int _tmain(int argc, _TCHAR* argv[]){ tree tr[9]={{'a',true,5},{'b',true,2},{'c',true,9},{'d',true,3},{'e',true,6}};// printf("%d \n",sizeof(tr)/sizeof(tree)); gettree(tr,9,5); char ch[100]; //printf("%s\n",ch); bianltree(&tr[8],ch); return 0;}
哈夫曼树详解、实现代码及哈夫曼编码实例
其中gettree()函数是构造哈夫曼过程,bianltree()是通过哈夫曼树编码过程,struct shfm
结构体是保存字符数据与它的哈夫曼编码的映射表,可用也可不用,这里之所以使用,是因为通过一次遍历就可得到所有元素的编码,以后要编码只需查表即可,以空间换时间。
下面介绍哈夫曼的应用举例:
通过上文的介绍,下面就介绍哈夫曼的实际运用。
本例的模拟效果是:通过传入一串字符串,返回该字符串的编码。并且通过传入一个有效的编码得到一个字符串!
下面给出完整代码,该代码基于上述代码之上进行修改,并优化上述代码。
// hfm.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#includestatic int hfmb=0;struct tree{ char date;//数据 bool min;//叶子节点 int quanzhi;//权值 struct tree *zuo,*you;//左右孩子}*tre;struct shfm{ char date;//字符数据 int len;//编码长度 char bianm[11];//哈夫曼编码,最大编码数为11(可根据实际修改!)}hfm[100];//哈夫曼编码对应真实数据表void gettree(tree tr[],int shij,int youx)//构造哈夫曼树,tr树集合,shij集合实际数据个数,youx集合有效数据个数{ //模拟动态增长数组,每次构造新的树就插入有效数据后面 if (2*youx-1!=shij) { printf("参数不符合!"); return; } int c=0; while(youx!=shij)//当有效个数==实际个数时,构造完成! { for (int i=c;i { //每次循环取两个最小值并将两个最小值放置在当前循环起始两位 if (tr[i].quanzhi { tree p=tr[i]; tr[i]=tr[c]; tr[c]=p; } if (tr[i].quanzhi { tree p=tr[i]; tr[i]=tr[c+1]; tr[c+1]=p; } } //以下为通过最小值构造的新树 tr[youx].quanzhi=tr[c].quanzhi+tr[c+1].quanzhi; tr[youx].you=&tr[c];//新树右孩子指向当前循环的最小值之一 tr[youx].zuo=&tr[c+1];//新树左孩子指向当前循环的最小值之一 youx++;//新树插入当前有效数据个数后面 并使有效数据个数+1 c=c+2; } return ;}void bianltree(tree *tr)//哈夫曼编码{ //通过遍历树,得到每个节点的编码 static char ch[100]; static int i=0; if (!tr->min)//叶子节点 { ch[i]='0'; i++; bianltree(tr->zuo);//左节点编码为"0" ch[i]='1'; i++; bianltree(tr->you);//右节点编码为"1" } if (tr->min) { ch[i]='\0';//结束标记() printf("%c %s \n",tr->date,ch); hfm[hfmb].date=tr->date; hfm[hfmb].len=i; int j=0; while(j!=i||i>10) { hfm[hfmb].bianm[j]=ch[j]; j++; }//保存编码映射表 hfmb++; } i--;//递归走入右节点时,取消当前赋值(当前必为左边叶子节点)}void chushihuahmf(tree *hfmtree,char *str,int i){//初始化哈夫曼树数组!参数:含哈夫曼树数组,待编码数据串,数据串长度 int j=0; while(*str) {//初始化有效的数组元素 hfmtree->date=*str;//待编码数据 hfmtree->min=true;//是否叶子节点 hfmtree->quanzhi=*str;//权值 str++; hfmtree++; j++; } while(j<=2*i-2) { //初始化非有效数组元素 hfmtree->min=false;//全部非叶子节点 j++; hfmtree++; }//注:本函数权值是根据字符ascll码判断!可根据实际情况重新定义初始化函数!}char * hfmbm(char *str){//哈夫曼编码函数 参数:待编码字符串! int i=0;//统计字符串字符数 int j=i; char *p=str;//备份字符串首地址 while(*str)//统计字符数 { i++; str++; } //printf("%d",i); tree *hfmtree=(tree *)malloc(sizeof(tree)*(2*i-1));//根据字符数开辟可用空间 str=p; tree *pp=hfmtree;//备份哈夫曼数组首地址 chushihuahmf(hfmtree,str,i);//根据ascll码制定权值并依此构造数组(根据实际情况可自行修改) hfmtree=pp; gettree(hfmtree,2*i-1,i);//构造一个哈夫曼树 tre=&hfmtree[2*i-2];//得到哈夫曼树 bianltree(tre);//通过哈夫曼树编码 并保存在编码 char *restr=(char *)malloc(sizeof(char)*i*11);//开辟编码后的字符串地址 int k=0; p=restr; while(k {//通过遍历 编码映射表 编码字符 通过映射表的字符匹配后返回编码 int b=0; while(b { if (hfm[b].date==str[k]) { for (int j=0;j { *restr=hfm[b].bianm[j]; restr++; } break; } b++; } k++; } *restr='\0'; restr=p; printf("编码完成:\n%s\n",restr); return restr;}void hfmjm(char *hmf){//哈夫曼解码 参数哈夫曼编码后的数据串 tree *p=tre;//得到哈夫曼树 while(*hmf) { if (*hmf=='0')//编码为0走左子树 { tre=tre->zuo; if (tre->min)//为叶子节点 { printf("%c",tre->date);//输出编码 tre=p; } hmf++; continue; } if (*hmf=='1')//编码为1走右子树 { tre=tre->you; if (tre->min) { printf("%c",tre->date); tre=p; } hmf++; continue; } printf("不能识别编码:%c\n",*hmf); return; } printf("\n"); tre=p;//还原哈夫曼树 //注:本解码是根据哈夫曼树解码 本程序还可以根据编码映射表解码}int _tmain(int argc, _TCHAR* argv[]){ char *ch="abcd@#$3456asd"; printf("待编码数据位:%s\n",ch); printf("编码格式:\n"); char *str=hfmbm(ch); printf("解码:\n"); hfmjm(str); //////解码测试:只要输入编码映射表(struct shmf结构体)有的编码 就能实现解码! printf("\n解码测试:请根据已有编码格式输入编码\n"); char hmf[100]; gets(hmf); printf("解码:\n"); hfmjm(hmf); return 0;}
函数说明:
char * hfmbm(char *str)函数是完成哈夫曼树构造的函数,用户只需传入一个带编码的字符串就可,本函数就可根据字符串开辟数组空间,并构造哈夫曼树。
void chushihuahmf(tree *hfmtree,char *str,int i)函数是初始化哈夫曼树权值的函数,因为我们构造时需要指定构造规则(即权值),本函数为了方便,直接使用ascll码作为权值构造,本函数可根据实际情况修改。
void hfmjm(char *hmf)函数是解码函数,通过传入有效编码解码出字符串!
我们发现相同元素有不同的编码,不过这不影响编码与解码,但从空间、时间角度应该避免这种情况,篇幅有效,本文将不再处理,在本例中由于有映射表,所有可以通过遍历映射表删除重复元素。
5.3 集合及运算
小白专场:堆中的路径 - C语言实现
6.1 什么是图
6.2 图的遍历
6.3 应用实例:拯救007
6.4 应用实例:六度空间
小白专场:如何建立图- C语言实现
树之习题选讲-Tree Traversals Again
树之习题选讲-Complete Binary Search Tree
树之习题选讲- Huffman Codes
7.1 最短路径问题
小白专场:哈利·波特的考试- C语言实现
第八讲 图(下)[陈越]
8.1 最小生成树问题
8.2 拓扑排序
图之习题选讲-旅游规划
第九讲 排序(上)[陈越]
9.1 简单排序(冒泡、插入)
9.2 希尔排序
9.3 堆排序
9.4 归并排序
第十讲 排序(下)[陈越]
10.1 快速排序
10.2 表排序
10.3 基数排序
10.4 排序算法的比较
11.1 散列表\哈希表
11.2 散列函数的构造方法
11.3 冲突处理方法
11.4 散列表的性能分析
11.5 应用实例:词频统计
- 我钟爱的数据结构大复习
- 我的钟爱---PLC
- 什么是我所钟爱的?
- 我被大老板们钟爱的五大要素 蒋继平
- show一下我所钟爱的Eclipse
- 我钟爱的喜乐蒂牧羊
- 我所钟爱的 HTML5 资源
- 我所钟爱的 HTML5 资源
- 端午拼图记:我钟爱的香港电影
- 我钟爱的教育技术专业
- 盘点JSP语言令开发人员钟爱的五大优势
- 《QQ自由幻想》我所钟爱的可爱宠物
- 《QQ自由幻想》我所钟爱的可爱宠物
- 《QQ自由幻想》我所钟爱的可爱宠物
- 我钟爱的HTML5和CSS3在线工具
- 我钟爱的Visual Studio前端开发工具/扩展
- 【翻译】我钟爱的HTML5和CSS3在线工具
- 钟爱技术,来点科学 ----我的IT成长路
- 在tiny4412源码下编写全系统编译执行脚本
- Yii2.0 探究三 :用户登录机制
- 个人收藏的一些很有性价比的Github链接
- 自定义View实现导航栏与主面板交互效果
- NoSQL
- 我钟爱的数据结构大复习
- 不缓存页面过滤器
- 16道嵌入式C语言面试题(经典)
- RTP协议
- Python2.7学习
- 欧拉计划 43
- 函数:字符串逆序
- zabbix实战--Php-fpm监控详解
- MyBatis入门基础(一)