数据结构的一些算法
内容
1.BM算法
2.栈的使用
3.利用哈弗曼树实现文件压缩
4.约瑟夫问题
5.链表的相关操作
6.栈、队列的相关操作
7.树的相关操作
1.BM算法
//好后缀规则和坏字符规则
//j+max(shift(好后缀),shift(坏字符））
/*文本串和模式串进行匹配；
模式串共有m个，从0—(m-1)
设计数组bmBc[k]表示坏字符k在模式串中出现的位置距离模式串末尾的最大长度；
遇到坏字符时，模式串可以移动距离为:shift（坏字符）=bmBc[T[i]]-(m-i-1)
i表示匹配的第一个字符在模式串中的位置，0,1,2,3，****
T[i]为模式串的第一个字符对应的文本串
(m-1-i)为i到模式串最后一个字符的距离
*/
#include
#define ASIZE 256 //把ASCII表中的256个字符表示全，不会漏掉字符
void preBmBc(char *x,int m,int bmBc[])
{
int i;
for(i=0;i //好后缀规则移动模式串 shift(好后缀）
//1.模式串中有子串匹配上好后缀，移动模式串，让子串和好后缀对其；
若超过一个子串匹配上好后缀，则选择最左边的子串对齐
2.模式串中没有子串匹配上好后置，则寻找模式串中的一个最长前缀，
并让该前缀等于好后缀的后缀，寻找到该前缀后，让该前缀和好后缀对齐
3.模式串中没有子串匹配上好后缀，并且找不到最长前缀让该前缀等于好后缀的后缀，
此时，直接移动模式串到好后缀的下一个字符
void suffixes(char *x,int m,int *suff)
//suffix[i]=s表示以i为边界，与模式串匹配的最大长度
//P[i-s,i]==P[m-s,m]的最大长度s
{
suff[m-1]=m;
for(i=m-2;i>=0;--i)
{
q=i;
while(q>=0&&x[q]==x[m-1-i+q])
--q;
suff[i]=i-q;
}
bmGs[]表示遇到好后缀时，模式串应该移动的距离，
其中i表示好后缀前面一个字符的位置
1.模式串中有子串匹配上好后缀
2.模式串中没有子串匹配上好后缀，但找到一个最大前缀
3.模式串中没有子串匹配上好后缀，但找不到一个最大前缀
void preBmGs(char *x,int m,int bmGs[])
{
int i,j;suff[XSIZE];
suffixes(x,m,suff);
for(i=0;i<m;++i)
bmGs[i]=m;
j=0;
for(i=m-1;i>=0;--i)
if(suff[i]==i+1)
for(;j<m-1-i;++j)
if(bmGs[j]==m)
bmGs[j]=m-1-j;
for(i=0;i<=m-2;++i)
bmGs[m-1-suff[i]]=m-1-i;
}
2.栈的使用
#include 3.利用哈弗曼树实现文件压缩
简介
给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
哈夫曼静态编码
它对需要编码的数据进行两遍扫描：第一遍统计原数据中各字符出现的频率，利用得到的频率值创建哈夫曼树，并必须把树的信息保存起来，即把字符0-255(28=256)的频率值以2-4BYTES的长度顺序存储起来，（用4Bytes的长度存储频率值，频率值的表示范围为0–232-1，这已足够表示大文件中字符出现的频率了）以便解压时创建同样的哈夫曼树进行解压；第二遍则根据第一遍扫描得到的哈夫曼树进行编码，并把编码后得到的码字存储起来。
哈夫曼动态编码
动态哈夫曼编码使用一棵动态变化的哈夫曼树，对第t+1个字符的编码是根据原始数据中前t个字符得到的哈夫曼树来进行的，编码和解码使用相同的初始哈夫曼树，每处理完一个字符，编码和解码使用相同的方法修改哈夫曼树，所以没有必要为解码而保存哈夫曼树的信息。编码和解码一个字符所需的时间与该字符的编码长度成正比，所以动态哈夫曼编码可实时进行。
哈夫曼译码
在通信中，若将字符用哈夫曼编码形式发送出去，对方接收到编码后，将编码还原成字符的过程，称为哈夫曼译码。
#include4.约瑟夫问题
问题
约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。
分析：
（1）由于对于每个人只有死和活两种状态，因此可以用布尔型数组标记每个人的状态，可用true表示死，false表示活。
（2）开始时每个人都是活的，所以数组初值全部赋为false。
（3）模拟杀人过程，直到所有人都被杀死为止。
解决
int main()
{
//准备空节点和尾指针
Linklist headPtr=NULL,lastPtr=NULL;
int i,j;
headPtr=malloc(sizeof(LNode));
if(headPtr!=NULL) //判断空间是否分配成功
{
headPtr->nextPtr=headPtr;
lastPtr=headPtr;//尾指针初始指向空节点；
}
else
{
printf("List isn't created.No memory avaliable.\n'");
exit(-1);
}
//调用尾插函数建立N个节点的环形链表；
for(i=1;i<N+1;i++)
insertCirclednd2(&lastPtr,i);
printCirclelist(headPtr);
//遍历链表，第M个节点删除，到只剩下一个节点；
Linklist currentPtr,previousPtr;
currentPtr=headPtr->nextPtr;
previousPtr=headPtr;
for(j=1;j<(N-1)*M+1;j++)
{
//遇到空节点跳过
if(currentPtr==headPtr)
{
previousPtr=currentPtr;
currentPtr=currentPtr->nextPtr;
}
if(j%M==0)
{
previousPtr->nextPtr=currentPtr->nextPtr;
printf("j=%d,delete %d\n",j,currentPtr->data);
free(currentPtr);
printCirclelist(headPtr);
currentPtr-previousPtr->nextPtr;
}
else
{
previousPtr=currentPtr;
currentPtr=currentPtr>nextPtr;
}
//打印剩下的环形链表
prinCirclelist(headPtr);
//销毁链表
destroyCirclelist(&headPtr);
return 0;
}
}
void printCirclelist(Linklist headPtr)
{
Linklist currentPtr;
currentPtr=headPtr->nextPtr;
if(currentPTr==NULL)
printf("List is empty.\n");
else
{
printf("The list is:\n");
while(currentPtr!=headPtr)
{
prntf("%d-->",currentPtr->data);
currentPtr=currentPtr->nextPtr;
}
printf("end\n");
}
}
void destroyCirclelist(Linklist *headPtrPtr)
{
Linklist tempPtr,currentPtr;
currentPtr=(*headPtrPtr)->nextPtr;
while(currentPtr!=*headPtrPtr)
{
tempPtr=currentPtr;
currentPtr=currentPtr->next;
free(tempPtr);
}
free(*headPtrPtr);
//将被释放链表头指针置空
*headPtr=NULL;
}
5.链表的相关操作
#include6.栈、队列的相关操作
C语言相关
push pop
init_stack(s)
empty_stack(s)
push_stack(s,x)
pop_stack(s)
gettop_stack(S)
clear_stack(s)
current_size_stack(s)//top指针指示当前栈顶位置
typedef struct
{
Elemtype *top;
Elemtype *base;
int stacksize;
}SqStack;
//栈空： S.top=S.base ;
//此时进栈则上溢
// 栈满 ： S.top=S.base+arrmax(栈的最大容量）
Status InitStack(SqStack &s)
{
s.base=(Elemtype*)malloc(100*sizeof(Eletype));
s.stacksize=100;
s.top=s.base;
return ok;
}
/*栈满 s.top-s.base>=s.stacksize
return OVERFLOW;
s.top=s.base+arrmax; */
Status Pop(SqStack &s,Elemtype &e)
{
if(s.top==s.base)
return errror;
else
e=*--(s.top);
return ok;
}
status GetTop(SqStack s,Elemtype &e)
{
if(s.top==s.base)
return error;
else
e=*(s.top-1);
return ok;
}
void conversion()
{
InitStack(S);
cin>>N;
while(N)
{
Push(S,N%8);
N=N/8;
}
while(!StackEmpty())
{
Pos(S,e);
cout<<e;
}
}
OPTR--运算符 OPND --寄存数
compute()
{
init_stack(OPTR);//运算符
init_stack(OPND);
push(OPTR,'#');
w=getchar();
while(w!'#'||gettop(OPTR)!='#')
{
if(w为整数)
{
push(OPND,w);
w=getchar();
}
else
{
}
}
}
void face(int n,int &f)
{
InitStack(S);
while(n!=0)
{
Push(S,n);
n-=1;
}
f=1;
whlie(!StackEmpty(S))
{
Pop(S,n);
f=n*f;
}
}
init_queue(q)
empty_queue(q)
en_queue(q,x) //入队
dl_queue(q) //出队
gethead_queue(q)
clear_queue(q)
current_size_queue(q)
typedef struct node
{
Elemtype data;
struct node *next;
}QNode;
QNode *front,*rear;
typedef struct
{
QNode *front;
QNode *rear;
}LinkQueue;
Status InitQueue (LinkQueue *Q)
{
Q->front=Q->rear=NULL;//链队不带头结点
return OK;
}
//入链队
Status EnQueue(LinkQueue *Q,Elemtype e)
{
s=(Qnode*)malloc(sizeof(Qnode));
s->data=e;
s->next=NULL:
Q->rear->next=s;
Q->rear=s;
return OK;//不是将rear隔过去了吗
}
q.base+q.rear=e;
q.rear=(q.rear+1)%MAX
q.front==q.rear
*e=*(q.base+q.front)
q.front=(q.front+1)%MAX;
strlength(s)
strassign(*s1,s2)
strconcat(*T,s1,s2)
strcompare(s1,s2)
substring(*sub,s,pos,len)
index(s1,s2,pos)
for(li=0;i<s1[0];i++)
if(s1[i]!=s2[i])
return FALSE;
return OK;
for(i=0;i<=len;i++)
{
sub[i]=s[pos+i-1];
sub[0]=len;
}
typedef struct node
{
char data;
struct ndoe *next;
}
i=pos;j=1;
while(i<=S[0]||S[o])
void get_nextval(SSring &T,int &nextval[])
{
i=1;
nextval[1]=0;
j=0;
if(j==0||T[i]==T[j])
{
++i;++j;
}
if(T[i]!=T[j])
{
nextval[i]=j;
}
else
{
nextval[i]=nextval[j];
}
Cpp相关
#include7.树的相关操作
pre_find(bitree bt,elemtp x,bitree q)
{
if(!bt&&(F==false))
{
if(bt->data==x)
{
q=bt;
F=true;
}
}
else
{
pre_find(bt->lc,x,q);
pre_find(bt->rc,x,q);
}
}
pre_level(bitree p,int level)
{
if(!p)
{
write(p->data,level);
pre_level(p->lc,level+1);
pre_level(p->rc,level+1);
}
}
pre_copy(bitree bt,bitree &q)
{
if(bt!=null)
{
new(q); //new()应该是赋予空间
q->data=bt->data;
pre_copy(bt->lc,q->lc);
pre_copy(bt->lc,q->lc);
}
else
{
q=NULL;
}
}
//哈夫曼编码树
typedef struct
{
unsigned int weight;
unsigned int parent,lch,rch;
} HTNode;
typedef HTNode huffmantree[m];
huffmantree ht;
int search(int a[],int x)
{
int low,mid,high;
low=1;
high=n;
while(low<=high)
{
mid=(low+high)/2;
if(x<a[mid])
high=mid-1;
else if(x>a[mid])
low=mid+1;
else
return mid;
}
return 0;
}
status insertbst(bitree &t,elemtype e)
{
if(!search(t,e.key,null,p))
{
s=(bitree)malloc(sizeof(bitnode));
s->data=e;
s->lchild=s->rchild=null;
if(!t) //二叉树为空
t=s;
else if LT(e.key,p->data.key) 如果e.key小于p->data.key
p->lchild=s;
else
p->lchild=s;
return true;
}//insertbst
}