数据结构算法

二叉排序树的非递归删除算法

bool Remove(BSTree &root,DataType x)
{//二叉排序树的非递归删除算法
 //在root为根的二叉排序树中删除关键字值为 x 的结点，成功返回true，失败返回false
  BSTNode *s,*p,*f;
  p=Search(root,x,f);//寻找删除结点
  if(p==NULL) return false;//查找失败，不作删除
  if(p->lchild!=NULL&&p->rchild!=NULL)
  {
    s=p->lchild;//找 p 的中序前驱 s
    while(s->rchild!=NULL)
    {
     f=s;
     s=s->rchild;
    }
    p->data=s->data;
    p=s;
  }
  if(p->lchild!=NULL)
    s=p->lchild;//记录非空子女结点
  else
    s=p->rchild;
  if(p==root) root=s;//被删结点为根结点
   else if(s->data<f->data)
          f->lchild=s;
        else
          f->rchild=s;
  free(p);//释放被删结点
  return true;
}

void InsertSort(DataType l[],int left,int right)
{//直接插入排序
  DataType temp;
  int i,j;
  for(i=left+1;i<right;i++)
     if(l[i]<l[i-1])
     {
       temp=l[i];
       j=i-1;
       do{
          l[j+1]=l[j];
          j--;
         }while(j>=left&&temp<l[j]);
       l[j+1]=temp;
     }
}
 
void BinaryInsertSort(DataType l[],int left,int right)
{//折半插入排序
  DataType temp;
  int i,j,low,high,middle;
  for(i=left+1;i<=right;i++)
  {
    temp=l[i];
    low=left;
    hight=i-1;
    while(low<=high)
    {
      middle=(low+hight)/2;
      if(temp<l[middle])
        high=middle-1;
      else
        low=middle+1;
    }
  for(j=i-1;j>=low;j--)
     l[j+1]=l[j];
  l[low]=temp;
  }
}
 
void ShellSort(DataType l[],int left,int right)
{//希尔排序
  DataType temp;
  int i,j,gap=right-left+1;
  do{
    gap=gap/3+1;
    for(i=left+gap;i<=right;i++)
       if(l[i]<l[i-gap])
         {
          temp=l[i];
          j=i-gap;
          do{
             l[j+gap]=l[j];
             j=j-gap;
            }while(j>left&&temp<l[j]);
          l[j+gap]=temp;
         }
     }while(gap>1);
}
 
void BubbleSort(DataType l[],int left,int right)
{//气泡排序
  bool exchangel;
  DataType temp;
  int i,j;
  for(i=left;i<right;i++)
   {
     exchange=false;
     for(j=right;j>=i+1;j--)
      if(l[j-1]>l[j])
      {
        temp=l[j-1];
        l[j-1]=l[j];
        l[j]=temp;
        exchange=true;
      }
   if(exchange==false)return;
   }
}
 
void QuickSort(DataType l[],int left,int right)
{//快速排序
  if(left<right)
  {
    int pivotpos=Partition(left,right);
    QuickSort(l,left,pivotpos-1);
    QuickSort(l,pivotpos+1,right);
  }
}
int Partition(DataType l[],int low,int high)
{
  int l=low,j=high;
  DataType pivot=l[low];
  while(i<j)
   {
     while(i<j&&l[j]>=pivot) j--;
     if(i<j) l[i++]=l[j];
     while(i<j&&l[i]<=pivot) i++;
     if(i<j) l[j--]=l[i];
   }
  l[i]=pivot;
  return i;
}
 
void SelectSort(DataType l[],int left,int right)
{//选择排序
  DataType temp;
  int i,j,k;
  for(i=left;i<right;i++)
  {
    k=i;
    for(j=i+1;i<right;i++)
      if(l[j]<l[k]) k=j;
    if(k!=i)
    {
     temp=l[i];
     l[i]=l[k];
     l[k]=temp;
    }
  }
}
 
void Merge(DataType l1[],DataType l2[],int left,int mid,int right)
{
  for(int k=left;k<=right;k++)
      l2[k]=l1[k];
  int s1=left,s2=mid+1,t=left;
  while(s1<=mid&&s2<=right)
      if(l2[s1]<=l2[s2]) l1[t++]=l2[s1++];
      else
         l1[t++]=l2[s2++];
  while(s1<=mid) l1[t++]=l2[s1++];
  while(s2<=right)l1[t++]=l2[s2++];
}
 
int Width(BinTree bt)
{//用层次遍历求最大宽度
 if(bt==NULL) return 0;
 Queue Q;
 front=rear=last=1;
 temp=maxw=0;
 Q[rear]=bt;
 while(front<=last)
 {
   p=Q[front++];
   temp++;
   if(p->lchild!=NULL)
     Q[++rear]=p->lchild;
   if(p->rchild!=NULL)
     Q[++rear]=p->rchild;
   if(front>last)
   {
    last=rear;
    if(temp>maxw)
      maxw=temp;
    temp=0;
   }
 }
}
 
int JudgeComplete(BinTree bt)
{//判断完全二叉树
  int tag=0;
  BinTree p=bt;
  Queue Q;
  if(p==NULL)
    return 1;
  Enqueue(Q,P);
  while(!QueueEmpty(Q))
   {
    p=Dequeue(Q);
    if(p->lchild&&!tag)
      Enqueue(Q,p->lchild);
    else  if(p->lchild)
           return 0;
     else
         tag=1;
     if(p->rchild&&!tag)
       Enqueue(Q,p->rchild);
     else if(p->rchild)
           return 0;
          else
             tag=1;
    
   }
  return 1;
}
 
void BFST Traversec(Graph G)
{//广度优先遍历图
  for(v=0;v<G.vexnum;++v)
     visited[v]=false;
  InitQueue(Q);
  for(v=0;v<G.vexnum;++v)
  {
    if(!visited[v])
    {
      visited[v]=true;
         visit(v);
      Enqueue(Q,v);
      while(!QueueEmpty(Q))
      {
        Dequeue(Q,u);
        for(w=FirstAdjvex(G,u);w;w=NextAdjvex(G,u,w))
        {
          if(!visited[w])
          {
           visited[w]=true;
           visit(w);
           Enqueue(Q,w);
          }
        }
      }
    }
  }
}
 
void DFSTraverse(Gruph G)
{//图的深度优先遍历
  for(v=0;v<G.vexnum;v++)
     visited[v]=false;
  for(v=0;v<G.vexnum;++v)
  {
   if(!visited[v])
     DFS(G,v);
  }
}
void DFS(Graph G,int v)
{
 visited[v]=true;
 visit(v);
 for(w<FirstAdjvex(G,v);w;w=NextAdjvex(G,v,w))
 {
  if(!visited[w])
     DFS(G,w);
 }
}
或者
void DFS(Graph &G,int v,bool visited[])
{
 visit(getValue(g,v));
 visited[v]=true;
 int w=getFirstNeighbor(G,v);
 while(w!=-1)
 {
  if(visited[w]==false)
    DFS(G,w,visited);
  w=getNextNeighbor(G,v,w);
 }
}
 
status InOrderThreading(BinThrTree &Thrt,BinThrTree T)
{
 //中序遍历二叉树T，并将其中序线索化，Thrt指向头节点
 if(!(Thrt=(BinThrTree)malloc(sizeof(BinThrNode))))
    exit(OVERFLOW);
 Thrt->ltag=link;
 Thrt->rtag=Thread;
 Thrt->rchild=Thrt;
 if(!T)
    Thrt->lchild=Thrt;
 else
    {
     Thrt->lchild=T;
     pre=Thrt;
     InThreading(T);
     pre->rchild=Thrt;
     pre->rtag=Thread;
     Thrt->rchild=pre;
    }
   return OK;
}
void InThreading(BinThrTree p)
{
 if(p)
 {
   InThreading(p->lchild);
   if(!p->lchild)
   {
    p->ltag=Thread;
    p->lchild=pre;
   }
 if(!pre->rchild)
 {
  pre->rtag=Thread;
  p->rchild=p;
 }
 pre=p;
 InThreading(p->rchild);
 }
}
 
status InOrder-Thr(BinThrTree T,status(*visit)(ElemType e))
{//中序遍历线索二叉树
 p=T->lchild;
 while(p!=T)
 {
  while(p>ltag==link)
  {
    p=p->lchild;
  }
  if(!(visit(p->data)))
    return ERROR;
  while(p->rtag==Thread&&p->rchild!=T)
  {
    p=p->rchlid;
    visit(p->data);
  }
 p=p->rchild;
 }
}
 
int depth(BinTree T)
{//求二叉树的深度
  if(T==NULL)
   return 0;
  else
   {
    if((ldepth=depth(t.lchild))>(rdepth=depth(T.rchild)))
        return ldepth+1;
    else
        return rdepth+1;
   }
}
 
void LevelOrder(BinTree T)
{//二叉树层次遍历
  Queue Q;
  BinTree bt;
  if(T!=NULL)
  {
    visit(T);
    if(T->lchild!=NULL)
     Enqueue(Q,T->lchild);
    if(T->rchild!=NULL)
     Enqueue(Q,T->rchild);
  }
  bt=Dequeue(Q);
  LevelOrder(bt);
}
 
//利用两个栈S1,S2模拟队列
status Enqueue(stack S1,ElemType e)
{
  if(top1==n&&!Sempty(S2))
  {
    printf("栈满");
    return ERROR;
  }
  if(top1==n&&Sempty(S2))
  {
   while(!Sempty(S1))
   {
    pop(S1,e);
    push(S2,e);
   }
  }
 push(S1,e);
 return OK;
}
void Dequeue(stack S1,stack S2)
{
 if(!Sempty(S2))
 {
  pop(S2,e);
  printt("出队元素为：",e);
 }
 else
 {
   if(Sempty(S1))
   {
   printf(""队列空");
   exit(0);
   }
   else
      {
      while(!Sempty(S1))
       {
        pop(S1,e);
        push(S2,e);
       }
      pop(S2,e);
      printf("出队列元素为：",e);
      }
 }
}
 
int size(BinTreeNode *t)
{//求二叉树节点个数
  if(t==NULL) return 0;
  return 1+size(t->lchild)+size(t->rchild);
}
int leaves(BinTreeNode *t)
{//返回二叉树的叶子节点个数
 if(t==NULL) return 0;
 if(t->lchild==NULL&&t->rchild==NULL) return 1;
 return leaves(t->lchild)+leaves(t->rchild);
}
int height(BinTree *t)
{//返回二叉树的高度
 if(t==NULL) return 0;
 int hl=height(t->lchild);
 int hr=height(t->rchild);
 if(hl>hr) return hl+1;
  else return hr+1;
}
int level(BinTreeNode* t,BinTreeNode* p)
{//返回以*t为根的二叉树中指定节点*p所在层次
  if(t==NULL) return 0;
  if(t==p) return 1;
  int levell=level(t->lchild,p);
  if(level>0) return 1+levell;
  int levelr=level(t->rchlild,p);
  if(levelr>0) return 1+levelr;
return 0;
}
void reflect(BinTreeNode *t)
{//交换以为*t根的二叉树中每一个节点的两个子女
  if(t==NULL) return;
  reflect(t->lchild);
  reflect(t->rchild);
  BinTreeNode *P=t->lchild;
  t->lchild=t->rchild;
  t->rchild=p;
}
void defoliate(BinTreeNode *t)
{//从以*t为根的二叉树中删去所有叶子节点
  if(t==NULL) return;
  if(t->lchild==NULL&&t->rchild==NULL)
  {
    delete t;
    t=NULL;
  }
  else
  {
    defoliate(t->lchild);
    defoliate(t->rchild);
  }
}
int Degree1(BinTreeNode *t)
{//统计以*t为节点的二叉树中度为1的节点个数，有此可推出求度数为2的节点个数
  if(t==NULL) return 0;
  if(t->lchild!=NULL&&t->rchild==NULL||t->rchild!=NULL&&t->lchild==NULL)
    return 1+Degree1(t->lchild)+Degree1(t->rchild);
}
//统计以*t为根的二叉树的宽度：先用前序遍历求出每一层的宽度，再求最大宽度
int levelNumber(BinTreeNode *t,int a[],int level)
{
  if(t!=NULL)
  {
    a[level]+=1;
    levelNumber(t->lchild,a,level+1);
    levelNumber(t->rchild,a,level+1);
  }
}
int width(BinTreeNode *t)
{
  int a[n+1],level=0,i,wid;
  for(i=0;i<=n;i++)  a[i]=0;
  levelNumber(t,a,level);
  wid=a[0];
  for(i=1;i<=n;i++)
     if(a[i]>wid) wid=a[i];
  return wid;
}
DataType MaxValue(BinTree *t,DataType max)
{//计算以*t为根的二叉树节点中最大元素的值
  if(t!=NULL)
  {
   if(t->data>max) max=t->data;
   max=MaxValue(t->lchild,max);
   max=MaxValue(t->rchild,max);
  }
 return max;
}
void nodePrint(BinTreeNode *t,int i)
{//以前序输出一棵以为根的二叉树所有节点，数据值以及所在层次
  if(t!=NULL)
  {
    cout<<t->data<<","<<i<<endl;
    nodePrint(t->lchild,i+1);
    nodePrint(t->rchild,i+1);
  }
}
void ConstructTree(DataType T[],int n,int i,BinTreeNode *ptr)
{//一棵完全二叉树存在一个一维数组T[n]中，建立一棵链接二叉树与之对应
  if(i>=n) ptr=NULL;
  else
  {
    ptr=(BinTreeNode *)malloc(sizeof(BinTreeNode));
    ptr->data=T[i];
    ConstructTree(T,n,i*2+1,ptr->lchild);
    ConstructTree(T,n,i*2+2,ptr->rchild);
  }
}

oid InOrder(BinTree bt)
{ //二叉树链接实现，非递归中序遍历
  Stack S;
  p=bt;
  while(p!=NULL||!isEmpty(S));
  {
    while(p!=NULL)
    {
      push(S,p);
      p=p->lchild;
    }
    if(!isEmpty(S))
    {
     pop(S,p);
     Visit(p->data);
     p=p->rchild;
    }
  }
}
bool Insert(BSTree &root,DataType x)
{//二叉排序树非递归插入算法
  BSTNode *s,*p,*f;
  p=Search(root,x,f);//f指向查找节点父节点
  if(p!=NULL) return false;
  s=(BSTNode*)malloc(sizeof(BSTNode));
  if(s==NULL) return false;
  s->data=x;
  s->lchild=NULL;
  s->rchild=NULL;
  if(f==NULL)
    root=s;
  else if(x<f->data)
         f->lchild=s;
       else
          f->rchild=s;
 return true;
}
bool Remove(BSTree &root,DataType x)
{//二叉排序树的非递归删除算法
  BSTNode *s,*p,*f;
  p=Search(root,x,f);
  if(p==NULL) return false;
  if(p->lchild!=NULL&&p->rchild!=NULL)
  {
    s=p->lchild;
    while(s->rchild!=NULL)
    {
     f=s;
     s=s->rchild;
    }
    p->data=s->data;
    p=s;
  }
  if(p->lchild!=NULL)
    s=p->lchild;
  else
    s=p->rchild;
  if(p==root) root=s;
   else if(s->data<f->data)
          f->lchild=s;
        else
          f->rchild=s;
  free(p);
  return true;
}
 
Prim算法（求最小生成树）
const int MaxInt=INT_MAX;
const int n=6;
typedef int AdjMatrix[n][n];
typedef struct{
        int fromVex,toVex;
        int weight;
        };
typedef TreeEdgeNode MST[n-1];
void PrimMST(AdjMatrix G,MST T,int rt)
{//从顶点rt出发构造G的最小生成树T,rt为根
 TreeEdgeNode e;
 int i,k=0,min,minpos,v;
 for(i=0;i<n;i++)
 {
   if(i!=rt)
   {
     T[k].fromVex=rt;
     T[k].toVex=i;
     T[k++].weight=G[rt][i];
   }
 }
 for(k=0;k<n-1;k++)
 {
   min=MaxInt;
   for(i=k;i<n-1;i++)
   {
    if(T[i].weight<min)
    {
     min=T[i].weight;
     minpos=i;
    }
   }
  if(min==MaxInt)
  {
    cout<<"Graph is disconnected!"<<endl;
      exit(0);
  }
 e=T[minpos];
 T[minpos]=T[k];
 T[k]=e;
 v=T[k].toVex;
 for(i=k+1;i<n-1;i++)
 {
  if(G[v][T[i].toVex]<T[i].weight)
  {
   T[i].weight=G[v][T[i].toVex];
   T[i].fromVex=v;
  }
 }
 }
}
 
拓扑排序
void topsort(hdnodes graph[],int n)
{
  int i,j,k,topl;
  node_pointer ptr;
  top=-1;
  for(i=0;i<n;i++)
  {
    if(!graph[i].count)
    {
      graph[i].count=top;
      top=i;
    }
  }
 for(i=0;i<n;i++)
 {
   if(top==-1)
   {
     fprintf(stderr,"\\n graph has a cycle!\\n");
      exit(1);
   }
   else{
        j=top;
        top=-1;
        printf("v%d",j);
        for(ptr=graph.link;ptr;ptr=ptr->link)