//链表基本操作tatus ListOppose(LinkList &L)
{
linklist p,q;
p=L;
p=p->next;
L->next=NULL;
while(p){
q=p;
p=p->next;
q->next=L->next;
L->next=q;
}
return OK;
}
//两个有序链表合并成一个
void MergeList(LinkList &la,LinkList &lb)
{
LinkList pa,pb,pc;
pc=la;
pa=la->next;pb=la->next;
while(pa&&pb)
{
if(pa->num<pb->num) {pc->next=pa;pc=pa;pa=pa->next;}
else
{pc->next=pb;pc=pb;pb=pb->next;}
}
if(pa)
pc->next=pa;
if(pb)
pc->next=pb;
}
//删去la中与lb相同的元素
Status DelSame(LinkList &la,LinkList &lb )
{
LinkList p,q,r;
p=la;q=p->next;
while(q!=NULL)
{
r=lb->next;
while(r!=NULL&&r->num!=q->num)
r=r->next;
if(r==NULL) p=q;
else p->next=q->next;
q=q->next;
}
}
/*栈和队列常见算法*/
//进制转换
void Conersion(int n)
{
Initstack(S);
while(n)
{
push(S,n%N);
n/=N;
}
/*十六进制
while(n){
if(n%16<=9) push(S,n%16+48);//存入字符
else push(S,n%16+55)
此时存入的是字符
}
*/
while(!emptystack)
{
pop(S,e);
printf("%d",e);
}
}
//行编辑程序,存入文件
void LineEdit(){
FILE *fp=fopen("file.txt","w");
InitStack(S);
ch=getchar();
while(ch!=EOF){
while(ch!=EOF&&ch!='\n')
{//全文未结束且未到行末
switch(ch)
{
case '#':pop(S,c);break;
case '@':clearstack(S);break;
default:push(S,ch) ;break;
}
ch=getchar();
}
StackTraverse(S,copy);//遇到'\n'或者EOF从栈底到栈顶的栈内字符传送至文件
fputc('\n',fp);//向文件传送一个换行符
clearstack(S);
if(ch!=EOF) ch=getchar();
}
destroystack(S);
fclose(fp);
}
//迷宫问题
typedef struct{
int x;
int y;
}PosType;//迷宫坐标位置类型
typedef struct{
int ord; //通道块在路径上的序号
PosType seat;//通道块在迷宫中的坐标
int di;//走向下一个通道快的方向
}SElemType;
Mazetype m;//迷宫数组
void Print();//输出迷宫的解
void Init(int k)//迷宫数组的初始化,墙值为0,通道值为k
Status Pass(PosType b);//当迷宫m的b点序号为1(可以通过),返回OK,否则,返回error
void FootPrint(Postype a)//a点变为足迹
PosType Nextpos(PosType&c,int di)//根据当前位置及移动方向,求下一位置
void Markprint(PosType b)//使b点序号变为-1(不能通过)
Status MazePath(PosType start,PosType end)//算法
{
InitStack(S);
curpos=start;
curstep=1;
SElemType e;
do{
if(Pass(curpos)){//当前位置可以通过
FootPrint(curpos);//留下足迹
e.ord=curstep;e.seat=curpos;e.di=0;
push(S,e);//加入路径
++curstep;
if(curpos==end) return true;
curpos=Nextpos(curpos,e.di);
}
else //当前位置不能通过
{
if(!Stackempty(S))
{
pop(S,e);//退栈到前一位置
curstep--;//足迹减一
while(e.di==3&&!Stackempty(S))//前一位置处于最后一个方向
{
markPrint(e.seat);//留下不能通过的标记(-1)
pop(S,e);//继续回退
curstep--;
}
if(e.di<3)
{
e.di++;
push(S,e);//push e into stack again
curstep++;
curpos=e.seat;//确定当前位置
curpos=NeatPos(curpos,e.di);
}
}
}while(!Stackempty(S));
return FALSE;
}
}
//表达式求值
char Precede(SElemType t1,SElemtype t2)//判断t1,t2量符号的优先关系
Status In(Selemtype c)//判断c是否7种运算符之一
SElemType Operate(SElemType a,SElemType theta,SElemtype b)
//做四则运算:a theta b,返回运算结果
SElemtype EvaluateExpression()//算法
{
Initstack(OPTR);push(OPTR,'#');
Initstack(OPND);
c=getchar();
while(c!='#'||Gettop(OPTR)!='#')
{
if(!In(c)) push(OPND,c);//不是运算符则进栈
else
switch(Precede(Gettop(OPTR),c)){
case '<':push(OPTR,c);c=getcahr();//栈顶元素优先权低
break;
case '=':pop(OPTR,x);c=getchar();//脱括号,接受下一个字符
break;
case '>':pop(OPTR,thea);// 退栈并将运算结果入栈
pop(OPND,a);pop(OPND,b);
push(OPND,Operate(a,theta,b));
break;
}//switch
c=getchar();
}//while
return Gettop(OPND);
}
//八皇后问题
typedef struct{
int i;
int j;
}Pos;
Pos pos[3]={{-1,-1},{-1,1},{-1,0}}//检测左上,右上,上,三个方向
void queenini(void)//初始化
void display(void)//打印出来
int check(int i,int j)//检测board[i][j]是否能放皇后,返回1,可放
{
int ni,nj,k,t;
t=1;
for(k=0;k<3;k++)
{
ni=i;nj=j;
while(t&&board[ni][nj]!='#')//未到达边界且未检测到皇后
{
ni+=pos[k].i;nj+=pos[k].j;
if(board[ni][nj]=='*') t=0//t=0表示遇到皇后,退出while,
}
}
return t;
}
void queenfind(int i,int j)
{//递归两个出口:1.i>N 2.回溯,重置board[i][k]=' '
int k;
if(i>N) {count++;display();}
else//j not used,just locate first position
{
for(k=1;k<=N;k++)
if(check(i,k))
{
board[i][k]='*';
queenfind(i+1,j);
board[i][k]=' ';
}
}
}
/*树中常见算法:遍历,判定*/
//二叉树的先序建立
typedef struct BiNode{
ElemType data;
struct BiNode *lchild,*rchild;
}BiNode,*Bitree;
void CreatTree(Bitree &p)//先序建立二叉树
{
if((ch=getchar())=='#') p=NULL;
else{
p=(Bitree)malloc(sizeof(BiNode));
p->data=ch;
Create(p->lchild);
Create(p->rchild);
}
}
//递归遍历
Status Preorder(Bitree p)
{
if(!p)
{
visit(p);
preorder(p->lchild);
Preorder(p->rchild);
}
}//其他类推
//非递归遍历.利用栈
//先序
Status Preorder(Bitree p)
{
InitStack(S);
while(!emptyStack(S)||p)
{
if(p) {visit(p);push(S,p); p=p->lchild;}//访问根指针,进栈,遍历左子树
else {pop(S,p),p=p->rchild;}
}
return OK;
}
//中序
Status Inorder(Bitree p)
{
InitStack(S);
while(!emptyStack(S)||p)
{
if(p){push(S,p);p=p->lchild;}
else { pop(S,p);visit(p); p=p->rchild; }
}
return OK;
}
//后序
Status Postorder(Bitree p)
{
InitStack(S);
Bitree t,l;
t=p;l=NULL;
while(!emptyStack(S)||t)
{
if(t) {push(S,t);t=t->lchild;}//存在左孩子,入栈
else {t=gettopStack(S);t=t->rchild;}//否则,查找栈顶元素,定位到栈顶的右孩子
if(!t||t==l) {pop(S,l);visit(l);t=NULL;}//栈顶的右孩子为空或者上一次被访问,弹出栈顶,并访问
}
return OK;
}
//层次遍历.利用队列
Status LevelOrder(Bitree p)
{
InitQueue(Q);
if(p) enqueue(Q);
while(!emptyQueue(Q))
{
dequeue(Q,p);visit(p);
if(p->lchild) enqueue(p->lchild);
if(p->rchild) enqueue(p->rchild);
}
}
//求二叉树深度,宽度非递归算法
Status BitreeDepWid(Bitree p)
{
Initqueue(Q);
Bitree t,l;
l=t=p;
int n,wid,dep;
n=wid=dep=0;
if(p) enqueue(Q,p);
while(!emptyQueue(Q))
{
dequeue(Q,t);n++;
if(t->lchild) enqueue(Q,t->lchild);
if(t->rchild) enqueue(Q,t->rchild);
if(t==l)
{
dep++;//换一层,深度加1,
if(!emptyQueue(Q)) l=Q.rear->bt;//队不空,l指向队尾节点
if(n>wid) wid=n;//某层节点比mid大则替换
n=0;
}
printf(dep,wid);
}
}
//判断一棵二叉树是否完全二叉树
Status Iscomplete(Bitree p)
{
Initqueue(Q);
Bitree t;
if(!p) return FALSE;
else enqueue(Q,p);
while(!emptyQueue(Q))
{
dequeue(Q,t);
if(t) {enqueue(Q,t->lchild);enqueue(Q,t->rchild);}//节点不空,左右孩子均入队
else {
while(!emptyQueue(Q)) {dequeue(Q,t);if(t) return FALSE;}
}//出现了一个空节点,若再出现一个非空的节点,表明非完全二叉树
}
return OK;
}
//删除节点值为x的子树
Status Delx(Bitree p,Elemtype x)
{
InitQueue(Q);
Bitree t=p;
if(p->data==x) {Deltree(p);return OK;}
enqueue(Q,t);
while(!emptyQueue(Q))
{
dequeue(Q,t);
if(t->lchild) {
if(t->lchild->data==x) {DelTree(t->lchild);t->lchild=NULL;}
else enqueue(Q,t->lchild);
}
if(t->rchild){
if(t->rchild->data==x) {DelTree(t->rchild);t->rchild=NULL;}
else enqueue(Q,t->rchild);
}
}
//查找第一个以x值为节点的所有父节点
Status SearchParent(Bitree p,ElemType x)
{//利用二叉树的后序遍历思想
InitStack(s);
Bitree t,l;
t=p,l=NULL;
while(t||!empstack(S))
{
if(t) {
if(t->data==x) break;//入栈的时候检测看是否存在取值为x的点,其余跟后序遍历一样
else {push(Q,t);t=t->lchild;}
}
else { t=gettopStack(Q);t=t->rchild; }
if(!t||t==l) {pop(Q,l);t=NULL;}
}
if(!empStack)//非空,输出父节点
{
while(!empStack) {pop(Q,t);visit(t);}
return OK;
}
else
return FALSE;
}
//二叉排序树的插入
Status BST_Insert(Bitree &p,ElemType x)//插入节点一定在叶子节点上
{
Bitree l,t,k;
l=(Bitree)malloc(sizeof(Binode));
l->lchild=l->rchild=NULL;
t=p;
if(t){//根节点非空
while(t)
{ k=t;
if(k->data>x) t=k->lchild;
else if(k->data<x) t=k->rchild;
else {free(t);break;}
}
if(k->data>x) k->lchild=l;
else k->rchild=l;
}
else
p=l;
}
//二叉排序树的判断:中序遍历 不能用层次遍历(切记)
Status Is_BST(Bitree p)
{
InitStack(S);
Bitree t=p;
l=NULL;
while(t||!empStack(S))
{
if(t){push(S,t);t=t->lchild;}
else {
pop(Q,t);
if(l&&l->data>t->data) return FALSE;//与上次出栈 的数做比较
l=t;t=t->rchild;
}
}
}
//平衡二叉树的判定
Status IS_Balence(Bitree p)
{
if(!p) return OK;
if(abs(dep(p->lchild)-dep(p->rchild))>1) return FALSE;
else
return (IS_Balence(p->lchild)&&IS_Balence(p->rchild));
}
//Huffman编码 Huffman树
typedef struct{
unsigned int weight;
unsigned int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char * * HuffmanCode;
Status Select(Huffman HT,int n,int &s1,int &s2);//数组HT[1...n]中查找parent
为0且weight最小的两个节点,s1权值小于s2
//求huffman编码的算法:
status HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)
{
if(n<=1) return FALSE;
m=2*n-1;//一棵拥有n个叶节点的Huffman树拥有2*n-1个节点
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0号单元未使用
for(p=HT,i=1;i<=n;++i) *p={*w,0,0,0};//初始化前n个节点
for(;i<=m;i++) *p={0,0,0,0};//初始化剩余节点
for(i=n+1;i<=m;i++)//建Huffman树
{
Selecte(HT,i-1,s1,s2);
HT[s1].parent=HT[s2].parent=i;
HT[i].lchild=s1,HT[i].rchild=s2;
Ht[i].weight=HT[s1].weight+HT[s2].weight;
}
//从叶子节点到根逆向求每个字符的Huffman编码
HC=(HuffmanCode)malloc((n+1)*sizeof(char *));//分配n个字符编码的头指针向量
cd=(char*)malloc(n*sizeof(char));//分配求编码的工作区间
cd[n-1]='\0';
for(i=1;i<=n;i++)//逐个字符求Huffman编码
{
start=n-1;//编码结束符位置
for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子向根逆向求编码
{
if(c==HT[f].lchild) cd[--start]='0';//c是父节点f的左孩子
else cd[--start]='1';
}
HC[i]=(char*)malloc((n-start)*sizeof(char));
strcpy(HC[i],&cd[start]);
}
}
//遍历Huffman树求编码
Status Get_HuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{
HC=(HuffmanCode)malloc((n+1)*sizeof(char*));//分配指向编码的头指针空间
cd=(char*)malloc(n*sizeof(char));
int p=m;cdlen=0;
for(i=1;i<=m;i++) HT[i].weight=0;//遍历Huffman树时作节点状态标记
while(p)
{
if(HT[p].weight==0){//向左
HT[p].weight=1;
if(HT[p].lchild!=0) {p=HT[p].lchild;cd[cdlen++]='0';}
else if (HT[p].rchild==0) {//登记叶子节点的字符的编码
HC[p]=(char*)malloc((cdlen+1)*sizeof(char));
cd[cdlen]='\0';strcpy(HC[p],cd);//复制编码串
}
}
else if(HT[p].weight==1) {//向右
HT[p].weight=2;
if(HT[p].rchild!=0) {p=HT[p].rchild;cd[cdlen++]='1';}
}
else {//HT[p].weight==2,退回
HT[p].weight=0;p=HT[p].parent;--cdlen;//退到父节点,编码长度减1
}
}
}
/*图的基本算法*/
//DFS:递归 非递归
Status DFS(Graph G,VerType v)
{
visit(v);//访问v节点
visit[v]=TRUE;//做访问标记
for(w=FirstNeighbor(G,v);w>=0;w=NextNeighor(G,v,w))
if(!visit[w]) DFS(G,w);
}
Status DFS(Graph G)//非递归,利用栈
{
InitStack(Q);
for(v=0,v<G.vexnum;v++)
if(!visit[v])
{
visit[v]=true;
ArcNode *t;
push(Q,v);
while(!emptyStack(S))
{
pop(Q,t);
visit(t);
for(w=FirstNeighor(G,k);w>=0;w=NextNeighor(G,k,w))
if(!visit[w])
{push(Q,w);
visit[v]=TRUE;
}//if
}//while
}//if
}
//BFS:非递归
Status BFS(Graph G)//BFS非递归算法,利用队列
{
InitQueue(Q);
for(v=0;v<G.vernum;v++)
if(!visit[v]){
enqueue(Q,v);
visit[v]=TRUE;//访问标记
while(!empQueue(Q)){
dequeue(Q,v);
visit(v);
for(w=FirstNeighor(G,v);w>=0;w=NextNeighor(G,v,w))
if(!visit[w]) {visit[w]=TRUE;visit(w);enqueue(Q,w);}//访问v的关联点后入队
}//while
}//if
}
//拓扑排序:邻接表存储的有向图
Status TopLogicalSort(Graph G)
{
InitStack(S);
FindInDegree(G,indegree);//对各顶点求入度indegree[0....vernum-1]
for(i=0;i<G.vernum;i++)
if(!indegree[i]) push(Q,i);//顶点为0的入栈
int count=0//计数,作最后的判断之用
while(!emptyStack(S))
{
pop(S,i);visit(i);++count;//输出i号顶点并计数
for(p=G.vertice[i].firstarc;p!=NULL;p=p->nextarc)
{
k=p->adjvex;//对i的每个邻接点的入度减1
if(!(--indegree[k])) push(Q,k);//若度为0则入栈
}
}
if(count==G.vexnum) return Ok;
else
return FALSE;
}
//最短路径:Dijstra(1-n).floyd(n-n)
//floyd,求任意两顶点的最短路径
Status ShortestPath_floyd(Graph p)
{
int path[][][]//3维矩阵记录路径
int Distance[][]//二维矩阵记录两点间距离
for(v=0;v<G.vexnum;v++)//对各点初始已知距离和路径
for(w=0;w<G.vexnum;w++)
{
d[v][w]=G.arc[v][w];//init the array
for(u=0;u<G.vexnum;u++) p[v][w][u]=0;
if(d[v][w]){//v到w之间有直接路径
p[v][w][v]=p[v][w][w]=1;//v到w经过v和w
}
}
for(u=0;u<G.vexnum;u++)
for(v=0;v<G.vexnum;v++)
for(w=0;w<G.vexnum;w++)
if(d[v][u]+d[u][w]<d[v][w])//从v到w的一条路径更短
{
d[v][w]=d[v][u]+d[u][w];
for(i=0;i<G.vexnum;i++) p[v][w][i]=p[v][[u][i]||p[u][w][i]//v到w经过v到u和u到w的所有路径
}
}
//dijstra
Status ShortestPath_Dijstra(Graph G,int v0,pathmatrix p,shortpathtable d)
{
int v,w,i,j,min;
Status final[];//为真表示该顶点到v0最短距离已求出,初值为假
for(v=0;v<G.vexnum;v++)
{
final[v]=FALSE;
d[v]=G.arcs[v0][v].adj;//d[]存放v0到v的最短距离,初值为直接距离
for(w=0;w<G.vexnum;+=w)
p[v][w]=FALSE;//初值为FALSE,表示没有路径
if(d[v]<INFINITY)//v0到v有直接路径
p[v][v0]=p[v][v]=TRUE;//一维数组p[v][]表示v0到v最短路径通过的顶点
}//initial,v0 belongs to Set[s]
d[v0]=0;//v0到v0距离为0
final[v0]=TRUE;//v0并入S集
for(i=1;i<G.vexnum;++i)//其余G.vexnum-1个顶点
{//开始主循环,每次求得v0到某个顶点v的最短路径,并将v并入S集
min=INFINITY;
for(w=0;w<G.vexnum;++w)//对所有顶点检查
if(!final[w]&&d[w]<min)//在S集之外的顶点中找离v0最近的顶点,赋值给v,距离赋值给min
{v=w;min=d[w];}
final[v]=TRUE;//v并入S集
for(w=0;w<G.vexnum;++w)//根据新并入的顶点更新不在S集中的顶点到v0的距离和路径数组
if(!final[w]&&min<INFINITY&&G.arcs[v][w].adj<INFINITY&&(min+G.arcs[v][w].adj<d[w]))
{//w不属于S集且v0->v->w的距离<目前v0->w的距离
d[w]=min+G.arcs[v][w].adj;//更新d[w]
for(j=0;j<G.vexnum;++j)//修改p[w],v0到w经过的顶点包括v0到v经过的顶点再加上顶点w
p[w][j]=p[v][j];
p[w][w]=TRUE;
}//if
}//for
}
//最小生成树:prim kruskal
//prim算法
Status MiniSpanTree_Prim(MGraph G,VertexType u)
{
typedef struct{
VertexType adjvex;
int lowcost;
}closedge[MAX_VERTEXNUM];
int minivex(miniside sz,MGraph G);//求出sz数组中lowcost最小positive节点,返回其在sz中序号
k=Locate(G,u);//找出节点u在节点数组的位置
for(j=0;j<G.vexnum;++j)
if(j!=k&&G.arcs[k][j].adj)//辅助数组初始化
{
closedge[j].adjvex=u;
closedge[j].lowcost=G.arcs[k][j].adj;
}
closedge[k].lowcost=0;//已访问的节点置于u集中
for(i=1;i<G.vexnum;++i)//选择其余G.vexnum-1个顶点
{
k=minivex(closedge,G);//求出T的下一个顶点:第k顶点
printf(closedge[k].adjvex->G.vex[k]);//输出生成树的边
closedge[k].lowcost=0;//第k顶点并入u集
for(j=0;j<G.vexnum;++j)//加入G.vex[k]后有边权值比原来小
if(G.arcs[k][j].adj>0&&G.arcs[k][j].adj<closedge[j].lowcost)
{
closedge[j].adjvex=G.vex[k];
closedge[j].lowcost=G.arcs[k][j].adj;
}
}
}
//kruskal算法
Status MiniSpanTree_Kruskal(MGraph G)
{
int set[MAX_VERTEX_NUM],i,j;
int k=0,a=0,b=0,min=G.arcs[a][b].adj;
for(i=0;i<G.vexnum;++i)
set[i]=i;//初态,各顶点分别属于各集合
while(k<G.vexnum-1)//最小生成树边数小于顶点树减1
{//寻找最小权值的边
for(i=0;i<G.vexnum;++i)
for(j=i+1;j<G.vexnum;++j)
if(G.arc[i][j]<min)
{
min=G.arcs[i][j];
a=i;b=j;
}
min=G.arcs[a][b].adj=INFINITY;//删除上三角中该边,下次不再查找
if(set[a]!=set[b])//边的两顶点不属于同一集合
{
printf(G.vexs[a]-G.vexs[b]);//输出该边
k++;//边数加一
for(i=0;i<G.vexnum;i++)
if(set[i]==set[b]) set[i]=set[a];
}
}
}
/*内部排序算法*/
typedef struct{
int key;
int otherinfo;
}redtype;
typedef struct{
redtype r[MAX+1];
int length;
}SqList;
/*1.插入排序*/
//直接插入排序
void InsertSort(SqList &l)
{
int i,j;
for(i=2;i<l.length;i++)
if(l.r[i]<l.r[i-1])
{
l.r[0]=l.r[i];//复制为哨兵
for(j=i-1;j>0&&l.r[j].key>l.r[0].key;j--)
l.r[j+1]=l.r[j];//记录后移
l.r[j+1]=l.r[0];//插入
}
}
//折半插入排序
void BInsertSort(SqList &l)
{
int i,j,mid,low,high;
for(i=2;i<l.length;i++)
{
l.r[0]=l.r[i];
low=1;high=i-1;//注意是插入排序,不是全部序列折半查找
while(low<=high)
{
mid=low+(high-low)/2;
if(l.r[mid].key>l.r[0].key) high=mid-1;
else low=m+1;
}
for(j=i-1;j>=high+1;j--)
l.r[j+1]=l.r[j];//记录后移
l.r[high+1]=l.r[0];
}
}
//希尔排序
void ShellSort(sqList &l)
{
int dk,i,j;
for(dk=l.length/2;dk>=1;dk/=2)
for(i=dk+1;i<=l.length;++i)
if(l.r[i].key<l.r[i-dk].key)
{
l.r[0]=l.r[i];
for(j=i-dk;j>0&&l.r[j].key<l.r[0].key;j-=dk;)
l.r[j+dk]=l.r[j];//记录后移查找icharu位置
l.r[j+dk]=l.r[0];//插入
}
}
//交换排序:冒泡 快速
//快速
void QuickSort(SqList &l,int low,int high)
{
int pos;
if(low<high)
{
pos=Partion(l,low,high);
QuickSort(l,low,pos-1);
QuickSort(l,pos+1,high);
}
}
int Partion(SqList &l,int low,int high)
{
int piv=l.r[low].key;
l.r[0]=l.r[low];//以第一个元素为基准
while(low<high)
{
while(low<high&&l.r[high].key>piv) --high;
l.r[low]=l.r[high];
while(low<high&&l.r[low].key<piv) --low;
l.r[high]=l.r[low];
}
l.r[low]=l.r[[0];
return low;
}
//选择排序,堆排序.采用顺序结构存储待排元素
void HeapSort(SqList &l)
{
for(i=l.lenngth/2;i>0;i--)
HeapAdjust(l,i,l.length);//把l.r[1...l.length]建成大顶堆
for(i=l.length;i>1;i--)
{
t=l.r[1];
l.r[1]=l.r[i];
l.r[i]=t;
HeapAdjust(l,1,i-1);//将l.[1...i-1]从新调整为大顶堆
}
}
void HeapAdjust(SqList &l,int s,int m)//调整H.r[s]的关键字,使H.r[s...m]成大顶堆
{
int i;
t=l.r[s];
for(i=2*s;i<m;i*=2)//沿key较大的子节点向下筛选
{
if(i<m&&l.r[i].key<l.r[i+1].key) ++i;
if(t.key>=l.r[i].key) break;//筛选结束
else {l.r[s]=l.r[i];//t应插在s上
s=i;
}//修改s值,以便继续向下筛选
}
l.r[s]=t;//插入
}
//归并排序
void Merge(int a[],int b[],int low,int mid,int high)
{//将a[low..mid]和a[mid+1...high]合并,b是辅助数组
int i,j,k;
for(i=low;i<=high;i++) b[i++]=a[i++];a中所有元素复制到b中
i=low;j=mid+1;
k=low;
while(i<=mid&&j<=high)//类似于链表合并
{
if(b[i].key<b[j].key) a[k++]=b[i++];
else a[k++]=b[j++];
}
while(i<=mid) a[k++]=b[i++];
while(j<=high) a[k++]=b[j++];
}
void MergeSort(int a[],int b,int low,int high)
{
int mid;
if(low<high)
{
mid=(low+high)/2;
MergeSort(a,b,low,mid);
MergeSort(a,b,mid+1,high);
Merge(a,b,low,mid,high);
}
}
//两个升序序列求中位数
int search(int a[],int b[],int n)
{
int a1,a2,m1,b1,b2,m2;
a1=b1=0;a2=b2=n-1;
while(a1!=a2&&b1!=b2)
{
m1=(a1+a2)/2;
m2=(b1+b2)/2;
if(a[m1]==b[m2]) return a[m1];
else if(a[m1]<b[m2])
{
if((a1+a2)%2==0) {a1=m2;b2=m2;}
else {a1=m1+1;b2=m2;}
}
else {
if((a1+a2)%2==0) {a2=m1;b1=m2;}
else {a2=m1;b1=m2+1;}
}
return a[a1]<b[b1]?a[a1]:b[b1];
}
}
//字符串匹配的kmp算法
void get_next(const char *str)
{
int i,j;
i=0;j=-1;
next[0]=-1;
while(*(str+i)!='\0')
{
if(j==-1||*(str+i)==*(str+j))
{
i++;j++;
if(str[i]!=str[j]) next[i]=j;
else next[i]=next[j];
}
else j=next[j];
}
int kmp_search(char *s1,char *s2)
{
int i,j;
i=0;j=0;
while(i!=trlen(s1)&&j!=strlen(s2))
{
if(j==-1||s1[i]==s2[j]) {i++;j++;}
else j=next[j];
}
if(j==strlen(s2)) return i-j+1;
else return 0;
}
//二分法求(A*B)%C
typedef unsigned _int64 llong;
llong Modle(llong a,llong b,llong c)
{
llong d=0;
while(b)
{
if(b&1) d=(d+a)%c;
a=(a+a)%c;
b>>=1;
}
return d;
}
//二分法求A^B%C
int mod_exp(int a,int b,int c)
{
int d=1;
while(b)
{
if(b&1) d=(d*a)%c;
a=(a*a)%c;
b>>=1;
}
return d;
}
数据结构算法总结
最新推荐文章于 2022-06-02 17:36:07 发布