数据结构笔记-部分算法

1.二叉树先序遍历递归算法：

void PreOrder(BiTree T){

  if(T!=null){

    visit(T);

    PreOrder(T->lchild);

    PreOrder(T->rchild);

  }

}

二叉树先序遍历非递归算法：

void PreOrder2(BiTree T){

  InitStack(S);

  BiTree p=T;

  while(p||IsEmpty(S)){

    if(p){

      visit(p);

      Push(S,p);

      p=p->lchild;

    }

    else{

      Pop(S,p);

      p=p->rchild;

    }

  }

}

2.二叉树中序遍历递归算法：

void InOrder(BiTree T){

  if(T!=NULL){

    InOrder(T->lchild);

    visit(T);

    InOrder(T->rchild);

  }

}

二叉树中序遍历非递归算法：

void InOrder2(BiTree T){

  InitStack(S);

  BiTree p=T;

  while(p||!IsEmpty(S)){

    if(p){

      Push(S,p);

      p=p->lchild;

}

else{

 Pop(S,p);

 visit(p);

 p=p->rchild;

}

  }

}

3.二叉树后序遍历递归算法：

void PostOrder(BiTree T){

  if(T!=NULL){

    PostOrder(T->lchild);

    PostOrder(T->rchild);

    visit(T);

  }

}

二叉树后序遍历非递归算法：

void PostOrder2(BiTree T){

  InitStack(S);

  BiTree p=T;

  BiTree r=NULL;

  while(p||!IsEmpty(S)){

    if(p){

      Push(S,p);

      p=p->lchild;

}

else{

 GetTop(S,p);

 if(p->rchild&&p->rchild!=r){

   p=p->rchild;

   Push(S,p);

   p=p->lchild;

 }

 else{

   Pop(S,p);

   visit(p);

   r=p;

   p=NULL;

 }

}

  }

}

4.二叉树层序遍历非递归算法：

void LevelOrder(BiTree T){

  InitQueue(Q);

  BiTree p;

  EnQueue(Q,T);

  while(!IsEmpty(Q)){

    DeQueue(Q,p);

    visit(p);

    if(p->lchild!=NULL)

      EnQueue(Q,p->lchild);

    if(p->rchild!=NULL)

      EnQueue(Q,p->rchild);

  }

}

5.通过中序遍历对二叉树线索化的递归算法：

void InThread(ThreadTree &p,ThreadTree &pre){

  if(p!=NULL){

    InThread(p->lchild,pre);

    if(p->lchild==NULL){

    p->lchild=pre;

    p->ltag=1;

    }

    if(pre!=NULL&&pre->rchild==NULL){

      pre->rchild=p;

      pre->rtag=1;

}

pre=p;

InThread(p->rchild,pre);

  }

}

6.图的深度优先搜索递归算法：

void DFSTraverse(Graph 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){

  visit(v);

  visited[v]=TRUE;

  for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w))

    if(!visited[w]){

      DFS(G,w);

}

}

7. 图的广度优先搜索非递归算法：（借助队列）

void BFSTraverse(Graph G,Status(* Visit)(int v)){

  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>=0;w=NextAdjVex(G,u,w))

 if(!visited[w]){

   visited[w]=TRUE;

   Visit(w);

   EnQueue(Q,w);

 }        

 }

}

}

8.Primr算法的简单实现：

void Prim(G,T){

  T=∅;

  U={w};

  while((V-U)!=∅){

    设(u,v)是使u∈U与v∈(V-U),且权值最小的边;

T=T∪{(u,v)};

U=U∪{v};

  }

}

9. 顺序查找算法：

int search_seq(SSTable ST,KeyType key){

  ST.elem[0].key=key;

  for(i=ST.length;ST.elem[i]!=key;--i);

  return i;

}

10.折半查找算法：

int search_bin(SSTable ST,KeyType key){

  int low=1,high=ST.length;

  while(low<=high){

    mid=(low+high)/2;

    if(ST.elem[mid].key==key)

      return mid;

    else if(ST.elem[mid].key>key)

      high=mid-1;

    else

      low=mid+1;

  }

  return 0;

}

11.二叉排序树的查找算法：

BiTree searchBST(BiTree T,KeyType key){

  if(T==NULL)

    return NULL;

  else{

    if(T->key==key)

      return T;

    else if(key<T->key)

      return searchBST(T->lchild,key);

    else

      return searchBST(T->rchild,key);

  }

}

12.二叉排序树的插入算法：

Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p){

  if(!T){

    p=f;  return FALSE;

  }

  else if(key==T->data.key){

    p=T;

    return TRUE;

  }

  else if(key<T->data.key)

    return SearchBST(T->lchild,key,T,p);

  else return SearchBST(T->rchild,key,T,p);

}

Status InsertBST(BiTree &T,ElemType e){

  if(!SearchBST(T,e.key,NULL,p)){

    s=(BiTree)malloc(sizeof(BiTNode));

    s->data=e;  s->lchild=s->rchild=NULL;

    if(!p)  T=s;

    else if LT(e.key,p->data.key)

      p->lchild=s;

    else  p->rchild=s;

    return TRUE;

  }

  else return FALSE;

}

13.二叉排序树的构造算法：

Status creatBST(BiTree &T,KeyType str[],int n){

  T=NULL;

  int i=0;

  while(i<n){

    InsertBST(T,str[i]);

    i++;

  }

}

14.二叉排序树删除结点的算法。（书p230）

15.直接插入排序算法：（书p265）

void InsertSort(SqList &L){

  for(i=2;i<=L.length;++i)

    if(L.r[i].key<L.r[i-1].key){

      L.r[0]=L.r[i];

      L.r[i]=L.r[i-1];

}

for(j=i-2;L.r[0].key<L.r[j].ley;--j){

 L.r[j+1]=L.r[j];

L.r[j+1]=L.r[0];

}

}

16.希尔排序的算法：

void ShellSort(SqList &L,int dlta[],int t){

  for(k=0;k<t;++k)

    ShellInsert(L,dlta[k]);

}

void ShellInsert(SqList &L,int dk){

  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[0].key<L.r[j].key);j-=dk)

        L.r[j+dk]=L.r[j];

      L.r[j+dk]=L.r[0];

}

}

17.一趟快速排序的算法：

void Partition(SqList &L,int low,int high){

  L.r[0]=L.r[low];

  pivotkey=L.r[low].key;

  while(low<high){

    while(low<high&&L.r[high].key>=pivotkey)

      --high;

    L.r[low]=L.r[high];

    while(low<high&&L.r[low].key<=pivotkey)

      ++low;

    L.r[high]=L.r[low];

  }

  L.r[low]=L.r[0];

  return low;

}

18.简单选择排序算法：

void SelectSort(SqList &L){

  for(i=1;i<L.length;++i){

    j=SelectMinKey(L,i);

    if(i!=j)

      L.r[i]←→L.r[j];

  }

}

19.2-路归并排序：

void Merge(RcdType SR[],RcdType &TR[],int i,int m,int n){

  for(j=m+1,k=i;i<=m&&j<=n;++k){

    if(SR[i].key<=SR[j].key)

      TR[k]=SR[i++];

    else

      TR[k]=SR[j++];

  }

  if(i<=m)

    TR[k...n]=SR[i...m];

  if(j<=n)

    TR[k...n]=SR[j...n];

}