深入探讨编程技术与应用-优快云博客

本文链接：https://blog.youkuaiyun.com/luowei505050/article/details/6569473

1.串

str.h

//str.h
#ifndef _STR_H
#define _STR_H
typedef struct
{
char *ch;
int len;
}STR;
STR *NewStr(char *str);
void DestroyStr(STR *s);
void ClearStr(STR* s);
int StrCompare(STR *s,STR *t);
int StrCancat(STR *s,STR *t);
STR *SubStr(STR *s,int pos,int len);
#endif

str.c

//str.c
#include
#include
#include "str.h"
STR *NewStr(char *str) //新建一个串
{
STR *s=NULL;
int i;
s=(STR *)malloc(sizeof(STR));
if(s==NULL)
return NULL;
for(i=0;str[i];++i);
s->ch=(char *)malloc((i+1)*sizeof(char));
if(s->ch==NULL)
{
free(s);
return NULL;
}
s->len=i;
while(i>=0)
{
s->ch[i]=str[i];
--i;
}
return s;
}
void DestroyStr(STR *s) //销毁串
{
free(s->ch);
s->ch=NULL;
s->len=0;
}
void ClearStr(STR* s)
{
free(s->ch);
s->ch=NULL;
s->len=0;
}
int StrCompare(STR *s,STR *t)//比较串
{
int i;
for(i=0;ilen && ilen;i++)
if(s->ch[i]!=t->ch[i])
return s->ch[i]-t->ch[i];
return s->len-t->len;
}
int StrCancat(STR *s,STR *t)//连接两个串
{
int i;
char *temp=NULL;
temp=(char *)malloc((s->len+t->len+1)*sizeof(char));
if(temp==NULL) return 0;
for(i=0;ilen;i++)
temp[i]=s->ch[i];
for(;ilen+t->len;i++)
temp[i]=t->ch[i-s->len];
temp[i]=0; //在最后加上'/0'
ClearStr(s);
s->ch=temp;
s->len=i;
return 1;
}
STR *SubStr(STR *s,int pos,int len) //获取子串
{
STR *t=NULL;
if(pos<1||pos>s->len||len<0||len>s->len-pos+1)
return NULL;
t=NewStr("");
ClearStr(t);
t->ch=(char *)malloc((len+1)*sizeof(char));
if(t->ch==NULL) return NULL;
t->len=len;
for(--len;len>=0;--len)
t->ch[len]=s->ch[pos-1+len];
t->ch[t->len]=0;
return t;
}

main.c

//main.c
#include
#include
#include "str.h"
void main()
{
int res;
STR *t=NULL,*s=NewStr("hello");
printf("s=%s,len=%d/n",s->ch,s->len);
t=NewStr("hello");
res=StrCompare(s,t);
if(res==0)
printf("s=t/n");
else if(res>0)
printf("s>t/n");
else
printf("s);
ClearStr(t);
t=NewStr("world");
StrCancat(s,t);
printf("s=%s,len=%d/n",s->ch,s->len);
DestroyStr(t);
t=SubStr(s,2,5);
printf("t=%s,len=%d/n",t->ch,t->len);
DestroyStr(s);
}

2.树

tree.h

//tree.h
#ifndef _TREE_H
#define _TREE_H
typedef struct _node //定义树的结点
{
void *data;
struct _node *parent;
struct _node *child;
struct _node *next;
}TREE;
int InsertTree(TREE **t,void *data,int size);
int DeleteAllTree(TREE *t);
int DeleteTree(TREE *t);
TREE *GetTreeByKey(TREE *r,void *key,int(*compare)(void*,void *data));
int PrintTree(TREE *t,void(*print)(void *));
#endif

tree.c

//tree.c
#include
#include
#include
#include "tree.h"
int InsertTree(TREE **t,void *data,int size)
//第1个参数为目录指针变量的地址，第2个参数数据无类型，第3个参数数据的大小
{
TREE *p=(TREE *)malloc(sizeof(TREE));
if(p==NULL) return 0;
memset(p,0,sizeof(TREE));
p->data=malloc(size);
if(p->data==NULL)
{
free(p);
return 0;
}
memcpy(p->data,data,size);
//以上是创建一个新的结点
//--------------------------------
//以下是把数据存到新结点中去
if(*t==NULL) //如果目录结点为空
*t=p;
else if((*t)->child==NULL)//如果树中只有根结点
{
p->parent=*t;
(*t)->child=p;
}
else
{
TREE *tmp=(*t)->child;
while(tmp->next) //循环到这一层的最后一个结点
tmp=tmp->next;
tmp->next=p;
p->parent=*t;
}
return 1;
}
int DeleteAllTree(TREE *t) //删除整棵树
{
TREE *p=NULL;
while(t)//当树不为空时，往下做，直到树为空
{
if(t->child!=NULL)//如果子结点不为空
{
p=t->child->child;
while(p->next)//这个循环使p指向t的孙子结点下的最后一个
p=p->next;
//此时p已指向t的孙子结点下的最后一个
p->next=t->child->next;//将此时p的下一个指向t的子结点的下一个(即t的最右子结点)
t->child->next=NULL;//将指向t子结点的兄弟结点清空
}
p=t->child;//将t的子结点赋给p指针,以记录t的子结点
free(t->data);
free(t);
t=p; //将p重新赋给t指针
}
return 1;
}
int DeleteTree(TREE *t)//删除一个树结点
{
if(t==NULL) return 0;
if(t->parent==NULL) //如果t为根结点
;
else if(t==t->parent->child)//如果t是某一层的第一个结点
t->parent->child=t->next;//将t的下一个挂到t的位置
else
{
TREE *p=t->parent->child;//将t结点所在的这一层的第1个兄弟结点赋给p
while(p->next==t)//p往下找，直到找到p的下一个是t结点，即找到t的上一个
p=p->next;
p->next=t->next;//把p的上一个的next指针指向t的下一个，这样就从树中删除了t结点
}
DeleteAllTree(t);
return 1;
}
TREE *GetTreeByKey(TREE *r,void *key,int(*compare)(void*,void *data))//查找结点
{
if(r==NULL)
return NULL;
if(compare(r->data,key))
return r;
if(GetTreeByKey(r->child,key,compare))
return r->child;
if(GetTreeByKey(r->next,key,compare))
return r->next;
return NULL;
}
int PrintTree(TREE *t,void(*print)(void *))//打印树
{
int i=0;
TREE *p=t->child;
while(p)
{
print(p->data);
i++;
p=p->next;//让p指向它的兄弟
}
return i;
}