《数据结构》严蔚敏与陈越伪代码总结

//陈 
typedef struct LNode *List;
struct LNode{
    int Data[MaxSize];//如果放多个元素，这个可改为指针，在初始化中指向数组 
    int Last;
};
//严
typedef struct {
    ElemType *elem;//存储空间基地址   zt:上面用的数组，数组首地址跟指针一样的，但这里没声明大小，初始化时再声明 
    int length;
} SqList; 

//陈 
List MakeEmpty(){
    List PtrL;
    PtrL=(List)malloc(sizeof(struct LNode));
    PtrL->Last=-1;
    return PtrL;
}
//严 
Status InitList(SqList &L){
    L.elem=new ElemType[MAXSIZE]; 
    if(!L.elem)exit(OVERFLOW);  //多了校验分配失败 
    L.length=0;
    return OK;
} 

//陈 
int Find(int X,List PtrL){
    int i=0;
    while(i<=PtrL->Last&&PtrL->Data[i]!=X) i++;
    if(i>PtrL->Last) return -1;
    else return i;
}
//严 
int LocateElem(SqList L,ElemType e){
    for(i=0;i<L.length;i++){
        if(e==L.elem[i]) return i+1;  //查找成功返回序号 
    }
    return 0;
}
//取值
//严  获取第i个值，他的数组存储位置是i-1 
Status GetElem(SqlList &L,int i,ElemType &e){
    if(i<1||i>L.length) return ERROR;  //判断i值是否合理
    e=L.elem[i-1];
    return OK;
}

//陈 
void insert(ElementType X,int i,List PtrL){
    //i表示插入第几个数，他在数组中的位置是i-1 
    int j; 
    if(PtrL->Last==MaxSize-1){
        printf("表满");
        return;
    }
    if(i<1||i>PtrL->Last+2){ //i最小是第1个数字；last初始值是-1，所以加2，严老师初始值是0，所以加1 
        printf("位置不合法");
        return;
    }
    for(j=PtrL->Last;j>=i-1;j--)
        PtrL->Data[j+1]=PtrL->Data[j];
    PtrL->Data[i-1]=X;
    PtrL->Last++;
    return;
}
//严
Status ListInsert(SqList &L,int i,ElemType e) {
    if(i<1||i>L.length+1) return ERROR;  //插入位置不合理 
    if(L.length==MAXSIZE) return ERROR;  //表满了 
    for(j=L.length-1;j>=i-1;j--) L.elem[j+1]=L.elem[j];  //后面元素向后移一位 
    L.elem[i-1]=e;  //做插入 
    L.length++;        //长度+1 
    return OK;
}

//陈 
void Delete (int i,List PtrL){
    //i表示删除第几个数，他在数组中的位置是i-1 
    int j;
    if(i<1||i>PtrL->Last+1){  //删的位置不合理 
        printf("不存在");
        return; 
    }
    for(j=i;j<=PtrL->Last;j++)  //元素往前移一位 
        PtrL->Data[j-1]=PtrL->Data[j];
    PtrL->Last--;
}
//严
Status ListDelete(SqList &L,int i){
    if(i<1||i>L.length) return ERROR;  //删的位置不合理 
    for(j=i;j<=L.length-1;j++) L.elem[j-1]=L.elem[j]; 
    L.length--;
    return OK;
}

//陈
typedef struct LNode *List;
struct LNode{
    ElementType Data;
    List Next;
};
//严
typedef struct LNode{
    ElemType data;
    struct LNode *next;
} LNode,*LinkList; //LinkList为指向结构体LNode的指针类型 

//附：陈，求表长 
int length(List PtrL){
    int j=0;
    List p=PtrL;
    while(p){
        p=p->Next;
        j++;
    }
    return j;
}

//严
Status InitList(LinkList &L){
    L=new LNode;  //生成新节点作为头结点，用头指针，指向头结点 
    L->next=NULL;  //头结点的指针域置空 
    return OK;
}

//陈 
List findKth(int K,List PtrL){
    List p=PtrL;
    int i=1;
    while(i<K&&p!=NULL){
        p=p->Next;
        i++;
    }
    if(i==K)return p;
    else return NULL;
}
//严
Status GetElem(LinkList L,int i,ElemType &e){
    p=L.next; //p指向首元结点
    j=1;
    while(p&&j<i){  //找第i个元素 
        p=p->next;
        ++j; 
    } 
    if(!p||j>i) return ERROR; //i>n或i<=0,i值不合法，比如i直接取-1，j=1比i大，i就不合法，若i>n，那取到边界外了，p早就为null了
    e=p->data;
    return OK; 
} 

//陈
List find(Element X,List PtrL){
    List p=PtrL;
    while(p!=NULL&&p->Data!=X)p=p->Next;
    return p;
}
//严
LNode *LocateElem(LinkList L,ElemType e){  //返回指向LNode类型的指针 
    p=L->next;  //还是指向首元结点 
    while (p&&p->data!=e) p=p->next; //直到p为空或找到 
    return p;
} 

//陈 
List Insert(ElementType X,int i,List PtrL){
    List p,s;
    if(i==1){ //新节点插在表头       如果有头指针，就不用单独考虑这种了 
        s=(List)malloc(sizeof(struct LNode));
        s->Data=X;
        s->Next=PtrL;
        return s; 
    }
    p=findKth(i-1,PtrL); //查找第i-1个结点 
    if(p==NULL){  //第i-1个结点不存在 
        return NULL;
    }else{
        s=(List)malloc(sizeof(struct LNode));
        s->Data=X;
        s->Next=p->Next;   
        p->Next=s;  //新节点插到p结点后面 
        return PtrL;
    }
}
//严 
Status ListInsert(LinkList &L,int i,ElemType e){
    p=L;j=0;
    while(p&&j<i-1) { //找到第i-1个元素，并用p指向 ，有头结点，不用单独考虑插到第1位 
        p=p->next;
        j++;
    }
    if(!p||j>i-1) return ERROR;  //与上面获取值一样，校验不合法
    s=new LNode;
    s->data=e;
    s-next=p-next;
    p->next=s;
    return OK; 
}

 //严
 //前插法
 void CreateList_H(LinkList &L,int n){
     L=new LNode;
     L->next=NULL;  //建立带头结点的空链表 
     for(i=0;i<n;i++){  //逆序输入n个值，不断插到头部 
         p=new LNode;
         cin>>p->data;  //给data设置值 
         p->next=L->next;
         L->next=p;  //头结点不断指向新的首元结点 
     }
 }
 //后插法 
 void CreateList_R(LinkList &L,int n){
     L=new LNode;
     L-next=NULL;
     r=L; //r当做尾指针，指向头结点
    for(i=0;i<n;++i){
        p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;  //新结点p插到尾部
        r=p;  //尾指针指向尾部 
    } 
 } 

//陈 
List Delete(int i,List PtrL){
    List p,s; //s用来释放空间 ，p是要删除结点的前驱 
    if(i==1){  //删除第1个结点 
        s=PtrL; 
        if(PtrL!=NULL)PtrL=PtrL->Next;
        else return NULL;
        free(s);
        return PtrL;
    }
    p=findKth(i-1,PtrL);  
    if(p==NULL)return NULL;  //要删除结点的前一个结点 不存在 
    else if(p->Next==NULL) return NULL; //前一个结点存在，但要删除的结点不存在 
    else{
        s=p->Next;  //删除第i个结点 
        p->Next=s->Next;
        free(s);
        return PtrL;
    }
}
//严
Status ListDelete(LinkList &L,int i){
    p=L;  //p是被删结点的前驱 
    j=0;
    while (!(p->next)&&j<i-1){
        p=p->next;
        j++;
    }
    if(p->next||j>i-1) return ERROR;  //p-next为空了，或者i值不合法 则退出
    q=p->next；
    p->next=q->next;
    delete q;
    return OK; 
}

  //严
  //双向链表的定义
  typedef struct DuLNode{
      ElemType data;
      struct DuLNode *prior;
      struct DuLNode *next;
  } DuLNode ,*DuLinkList;
  
  //双向链表的插入
  Status ListInsert_DuL(DuLinkList &L,int i,ElemType e){
      //带头结点的双链表L，在第i个位置之前插入e
      if(!(p=GetElem_DuL(L,i))) return ERROR;  //找到第i个位置的元素p
      s=new DuLNode;
      s-data=e;
      s-next=p;
      s-prior=p->prior;
      p->prior->next=s;
      p->prior=s;
      return OK;
  } 
  
  //双向链表的删除
  Status ListDelete_DuL(DuLinkList &L,int i){
      //删除 带头结点的双链表L的第i个元素
      if(!(p=GetElem_DuL(L,i))) return ERROR;  //找到第i个位置的元素p
       p->prior->next=p->next;
       p->next->prior=p->prior;
       delete p;
       return OK; 
  } 

尾指向头，就是循环链表。

//陈 
typedef struct SNode *Stack;
struct SNode{
    ElementType Data[MaxSize];
    int Top;
};
//严
typedef struct{
    SElemType *base;  //栈底指针 
    SElemType *top;  //栈顶指针 
    int stacksize;  //栈可用的最大容量 
} SqStack; 

//严
Status InitStack(SqStack &S){
    S.base=new SElemType[MAXSIZE];  //为顺序栈，分配一个最大容量为MAXSIZE的数组空间
    if(!S.base) exit(OVERFLOW);  //分配失败
     S.top=S.base;  //top初始为base，空栈 
     S.stacksize=MAXSIZE;  //stacksize置为数组最大容量 
     return OK;
}

//陈 
void Push(Stack PtrS,ElementType item{
    if(PtrS->Top==MaxSize-1){
        printf("满");
        return;
    }
    PtrS->Data[++(PtrS->Top)]=item;
    return; 
})
ElementType Pop(Stack PtrS){
    if(PtrS->Top==-1)return ERROR;
    return PtrS->Data[(PtrS->Top)--];
}
//严
Status Push(SqStack &S,SElemType e){
    if(S.top-S.base==S.stacksize) return ERROR; //栈满
    *S.top++=e;  //e压入栈顶，栈顶指针加1
    return OK; 
} 
Status Pop(SqStack &S,SElemType &e){
    if(S.top==S.base) return ERROR; //栈空
    e=*--S.top;  
    return OK; 
}
//严，取栈顶元素
SElemType GetTop(SqStack S){
    if(S.top!=S.base)     //栈非空 
        return *(S.top-1);  //不修改栈顶指针，返回栈顶元素值 
} 

//陈 
struct DStack{
    ElementType Data[MaxSize];
    int Top1;
    int Top2;
}; 
void Push(struct DStack *PtrS,ElementType item,int Tag){
    if(PtrS->Top2-PtrS->Top1==1)return;  //栈满 
    if(Tag==1) PtrS->Data[++(PtrS->Top1)]=item; //对第1个栈操作 
    else        PtrS->Data[--(PtrS->Top2)]=item; //对第2个栈操作 
}
ElementType Pop(struct DStack *PtrS,int Tag){
    if(Tag==1){
        if(PtrS->Top1==-1)return NULL; //第1个栈空 
        else return PtrS->Data[(PtrS->Top1)--];
    }else{
        if(PtrS->Top2==MaxSize))return NULL; //第2个栈空 
        else return PtrS->Data[(PtrS->Top2)++];
    }
}

//陈 
typedef struct SNode *Stack;
struct SNode{
    ElementType Data;
    struct SNode *Next;
};
//严
typedef struct StackNode{
    ElemType data;
    struct StackNode *next;
} StackNode,*LinkStack; 

//陈 
Stack CreateStack(){
    Stack S;
    S =(Stack)malloc(sizeof(struct SNode));
    S->Next=NULL;
    return S;
}
int isEmpty(Stack S){
    return (S->Next==NULL);
}
//严
Status InitStack(LinkStack &S){
    S=NULL; //栈没必要设头结点，初始化直接置为空就行 
    return OK;
} 

//陈 
void Push(ElementType item,Stack S){
    struct SNode *TempCell;
    TempCell=(struct SNode *)malloc(sizeof(struct SNode));
    TempCell->Data=item; 
    TempCell->Next=S->Next;
    S->Next=TempCell;//S的位置是栈顶，他总是next指向最顶部的元素   新元素插到头结点S和首元结点S->next之间，像链表的头插法 
}
ElementType Pop(Stack S){
    struct SNode *FirstCell;  //用来释放空间 
    ElementType TopElement;  //返回元素 
    if(isEmpty(S))return NULL;
    else{
        FirstCell=S->Next;   //S->Next指向栈顶元素 
        S->Next=FirstCell->Next;
        TopElement=FirstCell->Data;
        free(FirstCell);
        return TopElement;
    } 
}
//严 
Status Push(LinkStack &S,SElemType e){
    p=new StackNode;
    p->data=e;
    p->next=S; //因为没设头结点，所以新元素直接指向旧的栈顶元素 
    S=p;    //把新元素作为栈顶
    return OK;
} 
Status Pop(LinkStack &S,SElemType e){  //删除S的栈顶元素，用e返回其值
    if(S==NULL) return ERROR; 
    e=S->data;
    p=S;  //p临时保存栈顶元素空间，以备释放 
    S=S->next;  //修改栈顶指针 
    delete p;
    return OK;
} 
//严  取栈顶元素
SElemType GetTop(LinkStack S){
    if(S!=NULL) return S->data;
} 

//定义
//陈
struct QNode{
    ElementType Data[MaxSize];
    int front;
    int rear;
};
typedef struct QNode *Queue;
//严
typedef struct{
    QElemType *base; //存储空间的基地址 
    int front;  //头指针 
    int rear;  //尾指针
} SqQueue;

//初始化
//严
Status InitQueue(SqQueue &Q){
    Q.base=new QElemType[MAXQSIZE];  //指针指向新分配的数组基地址 
    if(!Q.base) return ERROR;  //校验分配失败 
    Q.front=Q.rear=0;  //头尾指针置为0，队列为空 
    return OK;
} 
//求队列长度
int QueueLength(SqQueue Q){
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
} 

//入队、出队
//陈 
void Add(ElementType item,Queue PtrQ){
    if((PtrQ->rear+1)%MaxSize==PtrQ->front)return NULL;  //校验队满 
    PtrQ->rear=(PtrQ->rear+1)%MaxSize;  //队尾+1 
    PtrQ->Data[PtrQ->rear]=item;
}
ElementType Delete(Queue PtrQ){
    if(PtrQ->front==PtrQ->rear)return NULL;  //校验队空 
    PtrQ->front=(PtrQ->front+1)%MaxSize;  //队头+1 
    return PtrQ->Data[PtrQ->front];
}
//严
Status EnQueue(SqQueue &Q,QElemType e) {
    if((Q.rear+1)%MAXSIZE==Q.front) return ERROR;  //校验队满 
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXSIZE;  //队尾指针+1 
    return OK;
}
Status DeQueue(SqQueue &Q,QElemType &e){
    if(Q.front==Q.rear) return ERROR;  //校验队空 
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXSIZE;  //队头指针+1 
    return OK; 
} 
//取队头元素
QElemType GetHead(SqQueue Q){
    if(Q.front!=Q.rear) return Q.base[Q.front];
}

//定义
//陈 
struct Node{
    ElementType Data;
    struct Node *Next;
};
struct QNode{
    struct Node *front;
    struct Node *rear;
};
typedef struct QNode *Queue;
//严
typedef struct QNode{
    QElemType data;
    struct QNode *next;
} QNode,*QueuePtr;
typedef struct {
    QueuePtr front;
    QueuePtr rear;
} LinkQueue; 

//初始化
//严
Status InitQueue(LinkQueue &Q){
    Q.front=Q.rear=new QNode;  //生成新结点作为头结点，队头和队尾指针指向此结点 
    Q.front->next=NULL;  //头结点的指针域置为空 
    return OK;
} 

//入队、出队
//陈 
ElementType Delete(Queue PtrQ){
    Queue FrontCell;  //临时保存出队元素，以备释放 
    ElementType FrontElem;  //保存出队元素的值 
    if(PtrQ->front==NULL)return NULL;  //校验队列为空 
    FrontCell=PtrQ->front;    
    if(PtrQ->front==PtrQ->rear)PtrQ->front=PtrQ->rear=NULL; //若队列只有一个元素，删除后，队列置为空 
    else FrontElem=FrontCell->Data;
    
    PtrQ->front=PtrQ->front->Next;  //队头+1 
    free(FrontCell);
    return FrontElem;
}
//严
Status EnQueue(LinkQueue &Q,QElemType e){
    p=new QNode;  //p是QueuePtr类型，c语言里可以省略强转，强制类型转换是为了兼容c++ 
    p->data=e; 
    p->next=NULL;
    Q->rear->next=p;  //初始化时，队头队尾指向同一个，所以若是第一次入队，这里使Q->front->next也指向了p，p是首元结点，从第二次入队开始，就只是新元素不断加到尾部了
    Q->rear=p;  //队尾指针后移一位，就是队尾+1 
    return OK; 
} 
Status DeQueue(LinkQueue &Q,QElemType &e){
    if(Q.front==Q.rear) return ERROR;  //校验队列为空 
    p=Q.front->next;  //临时保存出队元素，以备释放 
    e=p->data;
    Q.front->next=p->next;  //队头+1，若p是最后一个元素，p->next就是NULL，那 Q.front->next也是NULL了 
    if(Q.rear==p) Q.rear=Q.front;  //校验p是否是最后一个元素，若是，尾指针像初始化时一样，重新指向头结点，若不加校验，队头一直指向头结点，但删了首元结点后，又不管队尾指针，队尾就不知道指向谁了 
    delete p;
    return OK; 
} 
//严  取队头元素
SElemType GetHead(LinkQueue Q){
    if(Q.front!=Q.rear) return Q.front->next->data;  //若非空，返回头结点指向的首元结点的值 
} 

//串也有顺序存储和链式存储，考虑到效率和算法方便，多采用顺序存储
//严
//串的定长顺序存储 
#define MAXLEN 255  //串的最大长度 
typedef struct {
    char ch[MAXLEN+1];  //0空置不用，所以长度+1 
    int length;  //串的当前长度 
} SString; 
//串的堆式顺序存储
typedef struct {
    char *ch;    //按串长分配存储区，若空串则为NULL 
    int length;  //串的当前长度 
} HString; 

//广义表
//陈 
typedef struct GNode *GList;
struct GNode{
    int tag;  //标志域：0表示结点是单元素，1表示结点是广义表 
    union{
        ElementType Data;
        GList SubList;  //子表指针域SubList与单元素数据域Data复用，即共用存储空间 
    } URegion;
    GList Next;  //指向后继结点 
};
//严
typedef enum{ATOM,LIST} ElemTag;  //ATOM==0:原子 ; LIST==1:子表
typedef struct GLNode{
    ElemTag tag;  //公共部分，用于区分原子结点和表结点 
    union{        //原子结点和表结点的联合部分 
        AtomType atom;  //atom是原子结点的值域， AtomType由用户定义 
        struct {struct GLNode *hp,*tp;} ptr; //ptr是表结点的指针域，ptr.hp和ptr.tp分别指向表头和表尾 
    };
} *GList;  //广义表的头尾链表存储表示 

 

//树用儿子-兄弟表示法，就成了二叉树
//一般二叉树用顺序存储浪费空间，所以大都用链式存储
//特殊的二叉树有完美或满二叉树、完全树 。完全树可以用顺序存储

 //二叉树顺序存储定义 
//严
#define MAXSIZE 100  //二叉树的最大结点数
typedef TElemType SqBiTree[MAXSIZE]; //0号单元存根结点 
SqBiTree bt; 

 //二叉树链式存储定义 
 //陈 
 typedef struct TreeNode *BinTree;
 struct TreeNode{
     ElementType Data;
     BinTree Left;
     BinTree Right;
 };
 //严
 typedef struct BiTNode{
     TElemType data;  //结点数据域 
     struct BiTNode *lchild,*rchild;  //左右孩子指针 
 } BiTNode,*BiTree; 
 

//中序-左根右
 //递归 
 //陈 
 void InOrderTraversal(BinTree BT){
     if(BT){
         InOrderTraversal(BT->Left);
         printf("%d",BT->Data);
        InOrderTraversal(BT->Right);
     }
 } 
 //严
 void InOrderTraverse(BiTree T){
     if(T){
         InOrderTraverse(T->lchild); //中序遍历左子树 
         count<<T->data;            //访问根结点 
         InOrderTraverse(T->rchild); //中序遍历右子树 
     }
 }
 //非递归 
 //陈 
 void InOrderTraversal(BinTree BT){
     BinTree T=BT;  //用T做操作，不改变原树 
     Stack S=CreateStack();  //创建并初始化一个栈，栈是为了回溯 
     while(T||!isEmpty(S)){ //树不空说明这个树结点还有子树未遍历，栈不空说明还有等待回溯的结点 
         while(T){  //一直向左，并把沿途结点压入栈 
             PUSH(S,T);
             T=T->Left;
         }
         if(!isEmpty(S)){  
             T=POP(S);  //结点出栈 
             printf("%d",T->Data);//打印或访问结点 
             T=T->Right;//转向右子树 
         }
     }
 }
 //严 
 void InOrderTraverse(BiTree T){
     InitStack(S); //创建栈，用来做回溯 
     p=T; //用p做操作，不改变原树
     q=new BiTNode;   //临时存放根结点数据 
     while(p||!StackEmpty(S)){  //跟陈越老师的一样 
         if(p){  //p非空 
             Push(S,p);  //根指针入栈 
             p=p->lchild;  //根指针已入栈，遍历左子树 
         }else{  //p空 
             Pop(S,q); //出栈 
             count<<q->data;  //访问根结点 
             p=q->rchild;  //遍历右子树 
         } 
     }
 } 

 //先序-根左右
  //陈
 void PreOrderTraversal(BinTree BT){
     if(BT){
         printf("%d",BT->Data);
         PreOrderTraversal(BT->Left);
         PreOrderTraversal(BT->Right);
     }
 } 
  //非递归
 void PreOrderTraversal(BinTree BT){
     BinTree T=BT;
     Stack S=CreateStack();
     while(T||!isEmpty(S)){
         while(T){
             printf("%d",T->Data);  //只是访问根结点的代码位置变了 
             PUSH(S,T);
             T=T->Left;
         }
         if(!isEmpty(S)){
             T=POP(S);
             T=T->Right;
         }
     }
 }

//后序-左右根
 //陈 
 void PostOrderTraversal(BinTree BT){
     if(BT){
         PostOrderTraversal(BT->Left);
         PostOrderTraversal(BT->Right);
         printf("%d",BT->Data);
     }
 } 
 //非递归
 void PostOrderTraversal(BinTree BT){
     BinTree T=BT;
     Stack S=CreateStack();
     while(T||!isEmpty(S)){
         while(T){
             PUSH(S,T);
             T=T->Left;
         }
         if(!isEmpty(S)){
             T=POP(S);
             T=T->Right;
             printf("%d",T->Data);  //只是访问根结点的代码位置变了 
         }
     }
 }

 //层序用的不是栈，而是队列
 //陈 
 void LevelOrderTraversal(BinTree BT){
     Queue Q;  //队列做回溯 
     BinTree T; //临时用来操作树 
     if(!BT)return;  //校验是否为空树 
    Q=CreateQueue(MaxSize);  //创建并初始化队列 
    Add(BT,Q);  //最初是根节点入队 
    while(!IsEmpty(Q)){
        T=Delete(Q);  
        printf("%d",T->Data);  //访问根节点，下面将左右孩子入队。
        if(T->Left)Add(T->Left,Q);
        if(T->Right)Add(T->Right,Q);
//提示一下：父弹出时，左右儿子入队；左儿子弹出时，左边两个孙子入队，然后右儿子弹出，右边两个孙子入队；这样总能一层层地访问 
    }
 } 

 //二叉树的二叉线索存储
 //严
  typedef struct BiThrNode{
      TElemType data;
      struct BiThrNode *lchild,*rchild;  //左右孩子指针 
      int LTag,RTag; //左右标志 
  }BiThrNode,*BiThrTree ;

//二叉排序树，也叫二叉搜索树、二叉查找树，比二叉树多了个条件，左小右大
 //定义
 //严
 typedef struct { 
     KeyType key;          //关键字项 
    InfoType otherinfo;  //其他数据项 
}ElemType;               //每个结点的数据域的类型 
 typedef struct BSTNode{    //二叉排序树的二叉链表存储表示 
     ElemType data;          //每个结点的数据域包括关键字项和其他数据项 
     struct BSTNode *lchild,*rchild; //左右孩子指针 
 } BSTNode,*BSTree;
 

//创建
 //严
 void CreatBST(BSTree &T){
     T=NULL;  //将二叉排序树T初始化为空 
     cin>>e;  //读输入的数据e 
     while(e.data!=ENDFLAG){  //  ENDFLAG为自定义常量，作为输入结束标志 
         InsertBST(T,e);  //将此结点插入到二叉排序树T中 
         cin>>e;  //继续读输入的数据 
     }
 } 

 //查找-递归 
 //严
 BSTree SearchBST(BSTree T,KeyType key){
     //在二叉排序树T中，查找关键字等于key的数据元素
    if((!T)||key==T->data.key) return T;  //要么T查完了也没找到，此时T为空，返回空； 要么查找成功，返回该数据元素结点的指针
    else if (key<T->data.key) return  SearchBST(T->lchild,key);  //在左子树中继续查找
    else return SearchBST(T->rchild,key);  //在右子树中继续查找 
 } 
 //陈 
 Position Find(ElementType X,BinTree BST){
     if(!BST)return NULL;
     if(X>BST->Data) return Find(X,BST->Right); // 在右子树继续查找 
     else if(X<BST->Data) return Find(X,BST->Left); //在左子树继续查找 
     else return BST;  //查找成功 
 }
 
 //查找-非递归
 //陈 
  Position IteraFind(ElementType X,BinTree BST){
      while(BST){
          if(X>BST->Data)
              BST=BST->Right;
          else if(X<BST->Data)
              BST=BST->Left;
          else return BST;
    }
    return NULL;
  } 
  
  //附加 
  //陈  
  //查找最小值，最小值在最左边，这个展示下递归方式实现 
  Position FindMin(BinTree BST){
      if(!BST)return NULL;
      else if(!BST->Left) 
      return BST;  //找到最左叶结点返回 
      else 
      return FindMin(BST->Left); //沿左分支继续查找 
  } 
  //查找最大值，最大值在最右边，这个展示下循环方式实现 ，递归和循环都可以用 
  Position FindMax(BinTree BST){
      if(BST)
      while(BST->Right) BST=BST->Right;  //沿右分支继续查找，直到最右叶结点 
    return BST; 
  }

 //插入
  //陈 
  BinTree Insert(ElementType X,BinTree BST){
      if(!BST){  //树为空，则生成新的 
          BST=malloc(sizeof(struct TreeNode));
          BST->Data=X;
          BST->Left=BST->Right=NULL;
    }else{  //开始找要插入元素的位置 
        if(X>BST->Data) BST->Right=Insert(X,BST->Right); //递归插入右子树 
        else if(X<BST->Data) BST->Left=Insert(X,BST->Left);    //递归插入左子树 
        //否则就是X已存在，什么都不做 
    }
    return BST;
  } 
  //严
  void InsertBST(BSTree &T,ElemType e){
      if(!T){  //树为空，生成新的 
          S=new BSTNode;
          S->data=e;
          S->lchild=S->rchild=NULL;
          T=S;
      }else if(e.key<T->data.key) InsertBST(T->lchild,e); //插到左边 
       else if(e.key>T->data.key) InsertBST(T->rchild,e); //插到右边 
  } 

  //删除 三种情况，叶结点、1个孩子、2个孩子
  //陈 
  //陈越是用递归实现的 
  BinTree Delete(ElementType X,BinTree BST){
      Position Temp;
      if(!BST);  //要删除的元素未找到，不做处理或打印个提示 
      else if(X>BST->Data) BST->Right=Delete(X,BST->Right); //右子树递归删除 
      else if(X<BST->Data) BST->Left=Delete(X,BST->Left);  //左子树递归删除 
      else  //找到了要删除的结点 
          if(BST->Left&&BST->Right){  //被删除的结点有左右两个子结点 
              Temp=FindMin(BST->Right);  //在右子树中，找到最小的元素，填充删除结点 
              BST->Data=Temp->Data;
              BST->Right=Delete(BST->Data,BST->Right); //填充后，再删除右子树中那个最小元素 
        }else{  //被删除的结点有一个子结点、或没有子结点 
            Temp=BST;  //临时存放待删结点，以备释放 
            if(!BST->Left) BST=BST->Right;  //左孩子为空，右孩子填充上来 
            else if(!BST->Right) BST=BST->Left; //右孩子为空，左孩子填充上来 
            free(Temp);  //无子结点，那直接释放就行 
        }
      return BST;
  } 
  //严
  //严蔚敏是用循环实现的 
  void  DeleteBST(BSTree &T,KeyType key){
      p=T;f=NULL;  //p用来临时操作树T，f表示被删结点的父节点 
      while(p){  
          if(key==p->data.key) break;  //从根开始查被删结点key，找到就停止循环 
          f=p;                        //每次都存一下父节点 
          if(key<p->data.key) p=p->lchild;  //小于就去左子树继续找，大于就去右子树继续找 
          else p=p->rchild;
      }
    if(!p) return;  //最后没找到被删结点，退出 ，若找到了，分下面三种情况 
    if(p->lchild&&p->rchild){    // 1、被删除的结点有左右两个子结点 
        q=p;  //q临时存放被删结点p 
        s=p->lchild;  //s要成为p左子树的最大值 
        while(s->rchild){  //s一直往右走到头，找到最大值 
            q=s;  //q临时存放最大值的父节点 
            s=s->rchild;
        }
        p->data=s->data;  //把最大值s提拔上来，替代被删结点p的值，做善后工作 
        if(q!=p) q->rchild=s->lchild;   //q!=p，说明上面循环走了，q改成s了，那q的右儿子s被提拔了，但s没有右儿子，只有左儿子，s的左儿子就顶上s的位置，哪怕它是null 
        else q->lchild=s->lchild;//若q==p，说明上面循环没走，q还是p，即p的左儿子s被直接提拔上来，s没有右儿子，原来指向s的指针现在指向s的左儿子，对p来讲，左孙成了左儿 
        delete s;//释放 
        return ;  //处理完成，直接退出，这里是修改了p的值，但没有改链表关系，下面是改了链表关系，直接重置p节点指针 
    }else if(!p->rchild){  //2、被删除的结点右孩子为空，左孩子直接上位 
        q=p;  //q临时存放被删结点p 
        p=p->lchild;  //重置p节点指针 
    }else if(!p->lchild){  //3、被删除的结点左孩子为空，右孩子直接上位 
        q=p;  //q临时存放被删结点p 
        p=p->rchild;//重置p节点指针 
    }
    if(!f) T=p; //能走到这里，说明p节点已被重置。若f==NULL，说明第一个while没走，要删的是根节点，重置后得p作为新树根 
    else if(q==f->lchild) f->lchild=p; //被删结点是其父节点f的左孩子，左孩子重连为重置后得p 
    else f->rchild=p;                     //被删结点是其父节点f的右孩子，右孩子重连为重置后得p 
    delete q;//释放 
  } 

//堆，即优先队列，是特殊队列。取元素按优先级，而非进队顺序；使用完全二叉树结构，分为最大堆、最小堆

 //定义
 //陈 
 typedef struct HeapStruct *MaxHeap;
 struct HeapStruct{
     ElemetType *Elements;  //数组空间 
     int Size;  //堆的当前元素个数 
     int Capacity;  //堆的最大容量 
 };
 //创建
 MaxHeap Create(int MaxSize){
     MaxHeap H=malloc(sizeof(struct HeapStruct));  
     H->Elements=malloc((MaxSize+1)*sizeof(ElementType));  //申请容量为MaxSize的数组空间 
     H->Size=0;
     H->Capacity=MaxSize;
     H->Elements[0]=MaxData;  //定义哨兵为大于堆中所有可能元素的值，便于以后更快操作
                             //把MaxData换成小于堆中所有元素的MinData，同样适用于创建最小堆 
     return H;
 } 

 //最大堆为例
 //插入
 void Insert(MaxHeap H,ElementType item){
     int i;
     if(IsFull(H))return;  //最大堆已满，退出 
     i=++H->Size;  //i指向插入后堆中最后一个元素的位置 
     for(;H->Elements[i/2]<item;i/=2)  //H->Element[ 0 ] 是哨兵元素，它不小于堆中的最大元素，控制顺环结束。i最小为1 
      H->Elements[i]=H->Elements[i/2];//向下过滤结点，并在此过程中交换数据 
     H->Elements[i]=item; //将item插入 
 }     
 
 //删除
 ElementType DeleteMax(MaxHeap H){
     ElementType MaxData,Temp; //分别存堆顶元素，堆尾元素 
     int Parent,Child;  //这两个值用来一层层向下过滤，保证每层左右较大子结点成为父节点 
    if(IsEmpty(H))return;  //最大堆已空，退出 
    MaxData=H->Elements[1]; //取出堆顶 
    Temp=H->Elements[H->Size--]; //取出堆尾 
    for(Parent=1;Parent*2<=H->Size;Parent=Child){ //从第一层开始向下层走 
        Child=Parent*2;   //child代表来到下一层，再次循环时，进入的是上次较大子树的下一层，2就到4,3就到6,到6就不用管4、5那些值，因为4、5拼爹没拼过6、7 
        if(Child!=H->Size&&(H->Elements[Child]<H->Elements[Child+1])) Child++; //child代表左右子结点的较大者 
        if(Temp>=H->Elements[Child]) break;//走到最后一个节点了，结束循环，跳出循环，在最后一步让堆尾元素提拔为父节点 
        else H->Elements[Parent]=H->Elements[Child];//还有子树，让当前子树的左右孩子较大值者提拔为父节点，继续下次循环，进入被提拔者的下一层，比较它左右子树较大者 
    }
    H->Elements[Parent]=Temp;//独子直接当爹，或者小儿子放左边 
    return MaxData; 
 }
 //通俗一点讲，就是让大儿子当爹，大孙子当大儿子，依次类推直到最后一个子树，
 //如果最后一个树有俩儿子，左儿子大，去当爹，右儿子要放左边
 //如果最后一个树有一儿子，那他直接当爹 
 //找个实际的例子模拟一遍就明白了 

//最优二叉树，也叫哈夫曼树。带权路径长度(WPL)最小的二叉树
//定义
//陈  链式存储 
typedef struct TreeNode *HuffmanTree;
struct TreeNode{
    int weight;
    HuffmanTree Left,Right;
}; 
//严  顺序存储 
typedef struct {
    int weight;  //结点的权值 
    int parent,lchild,rchild;//结点的双亲、左右孩子下标 
} HTNode,*HuffmanTree; //动态分配数组存储 

//构造
//陈 
HuffmanTree Huffman(MinHeap H){//假设最小堆里的值就是权值，把最小堆改成哈夫曼树
    HuffmanTree T;
    int i;
    for(i=1;i<H->Size;i++){ //若3个值，做2次合并 
        T=malloc(sizeof(struct TreeNode));  
        T->Left=DeleteMin(H);  //从最小堆中删除一个节点，作为新T的左子结点 
        T->Right=DeleteMin(H); //从最小堆中删除一个节点，作为新T的右子结点 
        T->weight=T->Left->weight+T->Right->weight; //计算新权值 
        Insert(H,T); //将新T插入最小堆 
    }
    T=DeleteMin(H);
    return T;
}
//严 
void CreateHuffmanTree(HuffmanTree &HT,int n){ 
    if(n<=1) return ;  // 
    m=2*n-1;
    HT=    new HTNode[m+1]; //申请2n个单元的数组空间，其中0号单元未用
    for(i=1;i<=m;i++){  //从1到2n-1所有单元中的父节点、左孩子、右孩子，初始化为0 
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
    } 
    for(i=1;i<=n;++i){  //输入前n个单元叶子节点的权值 
        cin>>HT[i].weight;
    }//初始化完成 
    for(i=n+1;i<m;++i){ //m=2n-1,此循环是从1到n-1 ,将两个节点权值和，作为新节点权值存到数组n+1之后的单元中 
        Select(HT,i-1,s1,s2);//在已初始化的数组HT中，选择两个父节点为0且权值最小的结点，并返回他们在HT中的序号s1和s2 
        HT[s1].parent=i;  //新节点存到n+1之后单元中 
        HT[s2].parent=i;
        HT[i].lchild=s1;  //记录新节点的左右儿子 
        HT[i].rchild=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;  //记录新节点的权重值 
    }
} 

 

//定义
//严 
//邻接矩阵存储，图没有顺序存储结构，但可以用二维数组表示元素之间关系

#define MVNum 100  //最大顶点数 
typedef char VerTexType;  //假设顶点数据类型为字符型 
typedef int ArcType;    //假设边的权值类型为整型 
typedef struct{
    VerTexType vexs[MVNum];  //顶点表，用一维数组存储 
    ArcType arcs[MVNum][MVNum];  //邻接矩阵，表示顶点间的关系，用二维数组表示 
    int vexnum,arcnum;   //图的当前顶点数和边数 
} AMGraph;

//严
#define MaxInt 32767  //表示极大值，即无穷 

 Status CreateUDN(AMGraph &G){  //用邻接矩阵表示法，创建无向图
     cin>>G.vexnum>>G.arcnum;   //输入总顶点数、总边数 
     for(i=0;i<G.vexnum;++i) 
         cin>>G.vexs[i];  //按总顶点数，依次输入顶点信息 
         
     for(i=0;i<G.vexnum;++i)
         for(j=0;j<G.vexnum;++j)
             G.arcs[i][j]=MaxInt;  //初始化邻接矩阵，边的权值均置为极大值MaxInt 
             
     for(k=0;k<G.arcnum;++k){  //按总边数，构造邻接矩阵 
         cin>>v1>>v2>>w;  //输入一条边依附的顶点及权值 
         i=LocateVex(G,v1);   
         j=LocateVex(G,v2);  //确定v1,v2在G中的位置，即顶点的数组下标 
         G.arcs[i][j]=w;  //边<v1,v2>的权值置为w 
         G.arcs[j][i]=G.arcs[i][j]; //置<v1,v2>的对称边<v2,v1>的权值为w 
     }
     return OK;
 } 
//陈
//无向图的邻接矩阵是对称的，可以只留上三角或下三角，用一维数组存储，数组下标是和=（i*(i+1)/2+j），数组值是权重——适合稠密图 

//定义 
//严
#define MVNum 100  //最大顶点数 
typedef struct ArcNode{  //边结点 
    int adjvex;                //该边所指向的顶点位置 
    struct ArcNode *nextarc;  //指向下一条边的指针 
    OtherInfo info;              //和边相关的信息 
} ArcNode;
typedef struct VNode{  //顶点信息 
    VerTexType data;
    ArcNode * firstarc;  //指向第一条依附该顶点的边的指针 
} VNode,AdjList[MVNum];  // AdjList表示邻接表类型 
typedef struct {    //邻接表 
    AdjList vertices;
    int vexnum,arcnum;  //图的当前顶点数和边数 
} ALGraph;  //总之就是，邻接表里存放顶点数组，数组里每个顶点元素包含多条边的链式指针。

//创建
//严 
Status CreateUDG(ALGraph &G){ // 用邻接表表示法，创建无向图 
    cin>>G.vexnum>>G.arcnum;  //还是输入总顶点数、总边数 
    for(i=0;i<G.vexnum;++i){  
        cin>>G.vertices[i].data;  //还是按总顶点数，依次输入顶点信息  
        G.vertices[i].firstarc=NULL;  //每个顶点的首条边初始化为null 
    }
    for(k=0;k<G.arcnum;++k){// 还是按总边数，构造邻接表 
        cin>>v1>>v2;    //还是输入一条边依附的两个顶点 
        i=LocateVex(G,v1);  
        j=LocateVex(G,v2);  //还是确定v1,v2在G中的位置，即顶点在G.vertices中的序号 
        
        p1=new ArcNode;  //生成一个新的边结点*p1 
        p1->adjvex=j;    //邻结点序号为j 
        p1->nextarc=G.vertices[i].firstarc;  
        G.vertices[i].firstarc=p1;  //将新节点*p1插入顶点vi的边表头部 
        
        p2=new ArcNode;  //生成另一个对称的新的边结点*p2 
        p2->adjvex=i;     //邻接点序号为i 
        p2->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p2;  //将新节点*p2插入顶点vj的边表头部 
    }
    return OK;
}
//陈：邻接表，用指针数组存储，只存非零 ——适合稀疏图 

图的链式存储有邻接表、十字链表、邻接多重表，后两种991大纲不考，不列代码。

//陈 
void DFS(Vertex X){
    Visited(V)=true; // Vertex是顶点集合，E是边集合，V，W是一对顶点，(V,W)是一条边 
    for(V的每个邻接点W) 
        if(!Visited(W)) //若邻接点为空 
            DFS(W); 
}
//严
//遍历连通图 
 bool visited[MVNum];  //访问标志数组，其初始值为false 
 void DFS(Graph G,int v){  //从第v个顶点出发，递归地深度优先遍历图G 
     cout<<v;    //访问第v个顶点 
     visited[v]=true;  //访问到就把它的标志数组值置为true 
     for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))  //依次检查v的所有邻接点w， FirstAdjVex(G,v)表示v的第一个邻接点；NextAdjVex(G,v,w)表示v相对w的下一个邻接点，w>=0表示存在邻接点
         if(!visited[w])  //若邻接点未访问 
             DFS(G,w);  //对邻接点递归调用DFS 
 }

//严 
//遍历非连通图
 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_AM(AMGraph G,int v){  //图G为邻接矩阵类型，从第v个顶点出发，深度优先搜索遍历图G 
     cout<<v;          //访问第v个顶点 
     visited[v]=true;  //并把它的标志数组值置为true 
     for(w=0;w<G.vexnum;w++)  //依次检查邻接矩阵中，顶点v所在的行
         if(G.arcs[v][w]!=0&&!visited[w])  //G.arcs[v][w]!=0表示w是v的邻接点，如果w未访问，则递归调用DFS
             DFS(G,w);
 } 

//严 
 //用邻接表表示 
 void DFS_AL(ALGraph G,int v){  //图G为邻接矩阵类型，从第v个顶点出发，深度优先搜索遍历图G
     cout<<v;          //访问第v个顶点
     visited[v]=true;  //并把它的标志数组值置为true
     p=G.vertices[v].firstarc;  //p指向v的边链表的第一个边结点 
     while(p!=NULL){               //边结点非空 
         w=p->adjvex;           //w是v的邻接点 
         if(!visited[w]) 
             DFS_AL(G,w);         //若w未访问，则递归调用DFS_AL 
         p=p->nextarc;           //p指向下一个边结点 
     }
 } 

//陈 
void BFS(Vertex X){
    Visited(V)=true;
    Enqueue(V,Q); //把初始点放入队列
    while(!IsEmpty(Q)) {
        V=Dequeue(Q);
        for(V的每个邻接点W)
            if(!Visited(W)){
                Visited(W)=true; 
                Enqueue(W,Q); //把每个邻接点都放入队列，下次找邻接点的邻接点，一层层向外 
            } 
    }
} 
//严
void BFS(Graph G,int v){  //按广度优先，非递归遍历连通图G 
    cout<<v;                //访问第v个顶点
    visited[v]=true;        //并把它的标志数组值置为true
    InitQueue(Q);            //辅助队列Q初始化，置空 
    EnQueue(Q,v);            //v进队 
    while(!QueueEmpty(Q)){  //队列非空 
        DeQueue(Q,u);        //队头元素出队并置为u 
        for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w)) //依次检查u的所有邻接点w， FirstAdjVex(G,u)表示u的第一个邻接点；NextAdjVex(G,u,w)表示u相对w的下一个邻接点，w>=0表示存在邻接点
            if(!visited[w]){  //w为u的尚未访问的邻接顶点 
                cout<<w;     //访问w 
                visited[w]=true; //把它的标志数组值置为true
                EnQueue[Q,w];  //w进队 
            }
    }
} 

//最小生成树 MST Minimum Spanning Tree ,就是权重之和最小的，连通各顶点边，组成的集合。
//思路是每一步都是当前最优的解，但不能保证总体是最优的。这叫贪心算法

//Prim  从起点开始，不断找连通起点的，权重最小的边，和它对应的顶点，加入集合，直到所有的顶点都加进来
//陈 
 void Prim(){
     MST={s};
     while(1){
         V=未收录顶点中dist最小值;
        if(这样的V不存在)break; //说明全搞完了 
        将V收录进MST:dist[V]=0; 
        for(V的每个邻接点W){
            if(dist[W]!=0){
                if(E(V,W)<dist[W]){
                    dist[W]=E(V,W);
                    parent[W]=V;
                }
            } 
        }
     }
     if(MST中收录的顶点不足V个) Error; 
 }
 
 //严
 struct {  //定义辅助数组，用来记录从顶点集U到V-U的权值最小的边 
     VerTexType adjvex;  //最小边在U中的那个顶点 
    ArcType lowcost;   //最小边上的权值 
 } closedge[MVNum]; 
 
 //无向网G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T，输出T的各条边 
 void MiniSpanTree_Prim(AMGraph G,VerTexType u){
     k=LocateVex(G,u);         //k为顶点u的下标 
    for(j=0;j<G.vexnum;++j) //对V-U的每一个顶点vj，初始化closedge[j] 
        if(j!=k)
            closedge[j]={u,G.arcs[k][j]}  //{adjvex,lowcost} 
    closedge[k].lowcost=0;                //初始，U={u} 
    for(i=1;i<G.vexnum;++i){            //选择其余n-1个顶点，生成n-1条边(n=G.vexnum) 
        k=Min(closedge);                //求出T的下一个结点：第k个顶点，closedge[k]中存有当前最小边 
        u0=closedge[k].adjvex;            //u0为最小边的一个顶点，u0∈U 
        v0=G.vexs[k];                    //v0为最小边的另一个顶点，v0∈V-U 
        cout<<u0<<v0;                    //输出当前的最小边(u0,v0) 
        closedge[k].lowcost=0;            //第k个顶点并入U集 
        for(j=0;j<G.vexnum;++j)            
            if(G.arcs[k][j]<closedge[j].lowcost) //新顶点并入U后重新选择最小边 
                closedge[j]={G.vexs[k],G.arcs[k][j]};
    }      
 } 

 // Kruskal  将边按权值大小添加到图中，别形成环，直到所有顶点都连通
 //陈 
 void Kruskal(Graph G){
     MST={};
     while(MST中不到V-1条边&&E中还有边){
         从E中取一条权重最小的边E(V,W); //最小堆
         将E(V,W)从E中删除;
         if(E(V,W)不在MST中构成回路){
             将E(V,W)加入MST; 
         } else{
             彻底无视E(V,W); 
         }
    }
    if (MST中不到V-1条边) Error;
 } 
 
 //严
 struct {  //定义辅助数组，存储边的信息，包括边的两个顶点信息和权值 
     VerTexType Head;    //边的始点 
     VerTexType Tail;    //边的终点 
     ArcType lowcost;    //边上的权值 
 } Edge[arcnum]; 
 int Vexset[MVNum];        //表示该顶点所在的连通分量 
 
 void MiniSpanTree_Kruskal(AMGraph G){
//无向网G以邻接矩阵形式存储，构造G的最小生成树T，输出T的各条边
    Sort(Edge);                            //将数组Edge中的元素按权值从小到大排序 
    for(i=0;i<G.vexnum;++i)    Vexset[i]=i;//辅助数组，表示各顶点自成一个连通分量 
    for(i=0;i<G.arcnum;++i){            //依次查看数组Edge中的边 
        v1=LocateVex(G,Edge[i].Head);    //v1为边的始点Head的下标 
        v2=LocateVex(G,Edge[i].Tail);    //v2为边的终点Tail的下标 
        vs1=Vexset[v1];                    //获取边Edge[i]的始点所在的连通分量vs1 
        vs2=Vexset[v2];                    //获取边Edge[i]的终点所在的连通分量vs2 
        if(vs1!=vs2){                    //边的两个顶点分属不同的连通分量 
            cout<<Edge[i].Head<<Edge[i].Tail; //输出此边
            for(j=0;j<G.vexnum;++j)        //合并vs1和vs2两个分量，即两个集合统一编号 
                if(Vexset[j]==vs2) Vexset[j]=vs1; //集合编号为vs2的都改成vs1 
        }
    } 
 } 

//最短路径问题
//单源-无权-BFS
//单源-有权-BFS-Dijkstra算法 
//数组下标代表各点，值为源点到当前点最短权重值，数组中找最小，然后添加点到T，找出度该改值就改；再找没找过的最小，……  
//上面博客的理解，跟下面老师的逻辑是一样的 

//陈 
void Dijkstra(Vertex s){
    while(1){
        V=未收录顶点中dist最小者;
        if(这样的V不存在) break; //说明所有点都搞完了
        collected[V]=true;//处理点 
        for(V的每个邻接点W) 
            if(collected[W]==false) //这个点没被处理过
                if(dist[V]+E<v,w><dist[W]){ //源点到这里的权值跟目前数组的值比是不是小 
                    dist[W]=dist[V]+ E<v,w>; //是就改值 
                    path[W]=V;
                } 
    }
} 

//严
void ShortestPath_DIJ(AMGraph G,int v0){
//用 Dijkstra 算法求有向网G的v0顶点到其余顶点的最短路径
    n=G.vexnum;                        //n为G中顶点的个数 
    for(v=0;v<n;++v){                //n个顶点依次初始化 
        S[v]=false;                    //S初始为空集 
        D[v]=G.arcs[v0][v];            //将v0到各个终点的最短路径长度初始化为弧上的权值 
        if(D[v]<MaxInt) Path[v]=v0;    //如果v0和v之间有弧，则将v的前驱置为v0 
        else Path[v]=-1;            //如果v0和v之间无弧，则将v的前驱置为-1 
    } 
    S[v0]=true;                        //将v0加入S 
    D[v0]=0;                        //源点到源点的距离为0 
    //初始化结束，开始主循环，每次求得v0到某个顶点v的最短路径，将v加到S集 
    for(i=1;i<n;++i){                //对其余n-1个顶点，依次进行计算 
        min=MaxInt;
        for(w=0;w<n;++w)
            if(!S[w]&&D[w]<min){
                v=w;
                min=D[w];            //选择一条当前的最短路径，终点为v 
            }
        S[v]=true;                    //将v加入S 
        for(w=0;w<n;++w){            //更新从v0出发到集合V-S上所有顶点的最短路径长度 
            if(!S[w]&&(D[v]+G.arcs[v][w]<D[w])){
                D[w]=D[v]+G.arcs[v][w];//更新D[w] 
                Path[w]=v;            //更新w的前驱为v 
            }
        }
    }
} 

//多源-Floyd算法  S矩阵存两点权重距离，P矩阵存他们过哪个点连在一起的，S矩阵和P矩阵都是延对角线对称，因此只看一半就行 
//”a[i][j]的距离” > “a[i][0]+a[0][j]”(a[i][0]+a[0][j]表示”i与j之间经过第1个顶点的距离”)
//意思是  这两点现在的距离，如果过 第一个点0的距离比现有距离更短，那就把更短距离更新进S矩阵，然后把他们经过的这个点0，写进P矩阵 
//陈 
void Floyd(){
    for(i=0;i<N;i++)
        for(j=0;j<N;j++){
            D[i][j]=P[i][j];
            path[i][j]=-1;
        }
    for(k=0;k<N;k++)
        for(i=0;i<N;i++)
            for(j=0;i<N;i++)
                if(D[i][k]+D[k][j]<D[i][j]){
                    D[i][j]=D[i][k]+D[k][j];
                    path[i][j]=k;
                }
}
//严
void ShortestPath_Floyd(AMGraph G){
//用Floyd算法求有向网G中各对顶点i和j之间的最短路径
    for(i=0;i<G.vexnum;++i)            //各对结点之间初始已知路径及距离 
        for(j=0;j<G.vexnum;++j){
            D[i][j]=G.arcs[i][j];
            if(D[i][j<MaxInt]) Path[i][j]=i;//如果i和j之间有弧，则将j的前驱置为i 
            else Path[i][j]=-1;                //如果i和j之间无弧，则将j的前驱置为-1 
        } 
    for(k=0;k<G.vexnum;++k)
        for(i=0;i<G.vexnum;++i)
            for(j=0;j<G.vexnum;++j)
                if(D[i][k]+D[k][j]<D[i][j]){//从i经k到j的一条路径更短 
                    D[i][j]=D[i][k]+D[k][j];//更新 D[i][j]
                    Path[i][j]=Path[k][j];    //更改j的前驱为k 
                }
} 

//有向无环图  Directed Acyclic Graph简称DAG，有方向的，没有首尾相连的图
//AOV网，顶点活动网(Activity On Vertex network)，顶点表示活动、边表示活动间先后关系的有向图 
//AOV是DAG， 首尾相连就没有起点了，也没有顺序，且会死循环 
//AOV中所有活动组成线性序列，叫做拓扑序列Topological order，
//由AOV构造 拓扑序列的过程叫做拓扑排序Topological sort
//两种算法可实现拓扑排序 

//陈 
//Kahn算法  有向图中选个没有前驱的顶点，删除他和他的所有边，放入栈，重复此步骤直到所有顶点入栈，栈中就是个线性序列 
void TopSort(){
    for(cnt=0;cnt<V;cnt++){
        V=未输出的，入度为0的顶点;
        if(这样的V不存在){
            图中有回路;
            break;
        }
        输出V,或者记录V的输出序号;
        for(V的每个邻接点W) Indegree[W]--; 
    }
}
//基于DFS的拓扑排序算法 它每次都沿着一条路径一直往下搜索，知道某个顶点没有了出度时，就停止递归，往回走
//此算法可以用来检测有向图是否DAG 
void TopSort(){
    for(图中每个顶点V)
        if(Indegree[V]==0) Enqueue(V,Q); //随时将入度变为0的顶点放入一个容器
    while(!isEmpty(Q)){
        V=Dequeue(Q);
        输出V，或者记录V的输出序号; cnt++
        for(V的每个邻接点W){
        if(--Indegree[W]==0) Enqueue(W,Q);//入度为0的放入容器 
    }
    if(cnt!=V) Error(图中有回路); 
} 

//严
Status TopologicalSort(ALGraph G,int topo[]){
//有向图G采用邻接表存储结构
//若G无回路，则生成G的一个拓扑序列topo[]并返回OK，否则ERROR
    FindInDegree(G,indegree);        //求出各顶点的入度存入数组indegree中 
    InitStack(S);                    //栈S初始化为空 
    for(i=0;i<G.vexnum;++i)
        if(!indegree[i]) Push(S,i); //入度为0者进栈 
    m=0;                            //对输出顶点计数，初始为0 
    while(!StackEmpty(S)){            //栈S非空 
        Pop(S,i);                    //将栈顶顶点vi出栈 
        topo[m]=i;                    //将vi保存在拓扑序列数组topo中 
        ++m;                        //对输出顶点计数 
        p=G.vertices[i].firstarc;    //p指向vi的第一个邻接点 
        while(p!=NULL){
            k=p->adjvex;            //vk为vi的邻接点 
            --indegree[k];            //vi的每个邻接点的入度减1 
            if(indegree[k]==0) Push(S,k); //若入度减为0，则入栈 
            p=p->nextarc;            //p指向顶点vi下一个邻接结点 
        }
    }
    if(m<G.vexnum) return ERROR;    //该有向图有回路 
    else return OK;
}

//关键路径   AOE-网（Activity On Edge） 
//与AOV-网对应，它是以边表示活动的网。带权的有向无环图。
//顶点表示事件，弧表示活动，权表示活动持续的时间。通常用来估算工程的完成时间

//严
Status CriticalPath(ALGraph G)
{//G为邻接表存储的有向网，输出G的各项关键活动 
   if(!TopologicalOrder(G,topo)) return ERROR;  
   //调用拓扑排序算法，使拓扑序列保存在topo中，若调用失败，则存在有向环，返回ERROR  
   n=G.vexnum;                       //n为顶点个数  
   for(i=0;i<n;i++)                  //给每个事件的最早发生时间置初值0  
     ve[i]=0;  
/*- - - - - - - - - -  - 按拓扑次序求每个事件的最早发生时间 － - - -  - - - - - -*/
   for(i=0;i<n;i++) 
   {     
      k=topo[i];                    //取得拓扑序列中的顶点序号k     
      p=G.vertices[k].firstarc;     //p指向k的第一个邻接顶点   
      while(p!=NULL) 
      {                             //依次更新k的所有邻接顶点的最早发生时间    
         j=p->adjvex;               //j为邻接顶点的序号                    
         if(ve[j]<ve[k]+p->weight)  //更新顶点j的最早发生时间ve[j]  
            ve[j]=ve[k]+p->weight;      
          p=p->nextarc;             //p指向k的下一个邻接顶点   
       }                            //while  
   }                                //for  
   for(i=0;i<n;i++)                 //给每个事件的最迟发生时间置初值ve[n-1]  
      vl[i]=ve[n-1];  
/*- - - - - - - - - - - - -按逆拓扑次序求每个事件的最迟发生时间- -- - - - - -  - - - - - -*/ 
   for(i=n-1;i>=0;i--) 
   {                
      k=topo[i];                   //取得拓扑序列中的顶点序号k              
      p=G.vertices[k].firstarc;    //p指向k的第一个邻接顶点   
      while(p!=NULL)               //根据k的邻接点，更新k的最迟发生时间 
      {                   
         j=p->adjvex;              //j为邻接顶点的序号                    
         if(vl[k]>vl[j]-p->weight) //更新顶点k的最迟发生时间vl[k]  
            vl[k]=vl[j]-p->weight;        
          p=p->nextarc;            //p指向k的下一个邻接顶点   
      }                            //while  
   }                               //for  
/*- - - - - - - - - - - - - -- -判断每一活动是否为关键活动- -- - - - - -  - - - - - -*/  
   for(i=0;i<n;i++)                //每次循环针对vi为活动开始点的所有活动 
   {                    
      p=G.vertices[i].firstarc;    //p指向i的第一个邻接顶点   
      while(p!=NULL) 
      {     
         j=p->adjvex;              //j为i的邻接顶点的序号     
         e=ve[i];                  //计算活动<vi, vj>的最早开始时间  
         l=vl[j]-p->weight;        //计算活动<vi, vj>的最迟开始时间  
         if(e==l)                  //若为关键活动，则输出<vi, vj>  
            cout<<G.vertices[i].data <<G.vertices[j].data;    
         p=p->nextarc;             //p指向i的下一个邻接顶点   
      }                            //while  
   }                               //for   
}

 

//严 
//数据元素类型定义
typedef struct{
    KeyType key;  //关键字域 
    InfoType otherinfo;  //其他域 
}ElemType; 
//顺序表定义
typedef struct {
    ElemType *R;  //存储空间基地址 
    int length;      //当前长度 
} SSTable; 


//顺序查找
//严 
int Search_Seq(SSTable ST,KeyType key){  //在顺序表ST中查找其关键字等于key的数据元素。若找到，返回该元素在表中的位置 
    for(i=ST.length;i>1;--i)
        if(ST.R[i].key==key) return i;  //从后往前找 
    return 0; 
} 
//设置监视哨的顺序查找
int Search_Seq(SSTable ST,KeyType key){  //找不到还是返回0，少了一次比较，length大于1000时，查找平均时间少了一半 
    ST.R[0].key=key;                    //哨兵 
    for(i=ST.length;ST.R[i].key!=key;--i);//从后往前找 
    return i;
} 

//陈   
int BinarySearch(StaticTable *Tbl,ElementType K){
    int left,right,mid,notFound=-1;
    left=1;             //初始左边界 
    right=Tbl->length;    //初始右边界 
    while(left<right){
        mid=(left+right)/2;  //计算中间元素坐标 
        if(K>Tbl->Element[mid])left=mid+1;  //调整左边界 
        else if(K<Tbl->Element[mid])right=mid-1;//调整右边界 
        else return mid;                    //查找成功，返回数组元素下标 
    }
    return notFound;        //查找不成功，返回-1 
}
//严 
int Search_Bin(SSTable ST,KeyType key){
    low=1;
    high=ST.length;                    //置查找区间初值 
    while(low<=high){
        mid=(low+high)/2;
        if(key==ST.R[mid].key) return mid;  //找到待查元素 
        else if(key<ST.R[mid].key) high=mid-1;  //继续在前一子表查找 
        else low=mid+1;                            //继续在后一子表查找 
    }
    return 0;            //表中不存在待查元素 
} 

//严
#define m 3            //B树的阶，暂设为3阶 
typedef struct BTNode{
    int keynum;        //结点中关键字的个数，即结点的大小 
    struct BTNode *parent;//指向双亲结点 
    KeyType K[m+1];  //关键字向量，0号单元未用 
    struct BTNode *ptr[m+1];//子树指针向量 
    Record *recptr[m+1];    //记录指针向量，0号单元未用 
} BTNode,*BTree;    //B树结点和B树的类型 

typedef struct {
    BTNode *pt;        //指向找到的结点 
    int i;            //1..m，在结点中的关键字序号 
    int tag;        //1：查找成功；0：查找失败 
} Result;             //B树的查找结果类型 

//严
Result SearchBTree(BTree T,KeyType key){
//在m阶B树上查找关键字key，返回Result类型结果
//若查找成功，则特征值tag=1，指针pt所指结点中，第i个关键字等于key
//否则特征值tag=0，等于key的关键字应插入指针pt所指结点中第i个和第i+1个关键字之间
    p=T;
    q=NULL;
    found=FALSE;
    i=0;    //初始化，p指向待查结点，q指向p的双亲
    while(p&&!found){
        i=Search(p,key);  //在p-key[1..keynum]中查找i，使得 p->key[i] <= k < p->key[i+1] 
        if(i>0&&p->key[i]==k) found=TRUE;  //找到待查关键字 
        else {
            q=p;
            p=p->ptr[i];
        } 
    } 
    if(found) return (p,i,1);    //查找成功 
    else return (q,i,0);        //查找不成功，返回K的插入位置信息 
} 

//严
Status InsertBTree(BTree &T,KeyType K,BTree q,int i){
//在m阶B树T上结点*q的key[i]与key[i+1]之间插入关键字K
//若引起结点过大，则沿双亲链进行必要的分裂调整，使T仍是m阶B树
    x=K;
    ap=NULL;
    finished=FALSE;  //x表示新插入的关键字，ap为一个空指针 
    while(q&&!=finished){
        Insert(q,i,x,ap);    //将x和ap分别插入到q->key[i+1]和q->ptr[i+1] 
        if(q->keynum<m) finished=TRUE;  //插入完成 
        else{        //分裂结点*p 
            s=[m/2];
            split(q,s,ap);
            x=q->key[s];    //将q->key[s+1..m],q->ptr[s..m]和q->recptr[s+1..m]移入新结点*ap 
            q=q->parent;
            if(q) i=Search(q,x);  //在双亲结点*q中查找x的插入位置 
        }
    }
    if(!finished)             //T是空树（参数q初值为NULL）或者根结点已分裂为结点*q和*ap 
        NewRoot(T,q,x,ap);  //生成含信息(T,x,ap)的新的根结点*T，原T和ap为子树指针 
    return OK;
} 

//陈
//定义 
typedef struct HashTbl *HashTable;
struct HashTbl{
    int TableSize;
    Cell *TheCells;
}H ;
//初始化 
HashTable InitializeTable( int TableSize )
{
    HashTable H;
    int i;
    if ( TableSize < MinTableSize ){
        Error( "散列表太小" );
        return NULL;
    }
    /* 分配散列表 */
    H = (HashTable)malloc( sizeof( struct HashTbl ) );
    if ( H == NULL )
        FatalError( "空间溢出!!!" );
    H->TableSize = NextPrime( TableSize );
    /* 分配散列表 Cells */
    H->TheCells=(Cell *)malloc(sizeof( Cell )*H->TableSize);
    if( H->TheCells == NULL )
        FatalError( "空间溢出!!!" );
    for( i = 0; i < H->TableSize; i++ )
        H->TheCells[ i ].Info = Empty;
    return H;
}

Position Find( ElementType Key, HashTable H ) /*平方探测*/
{ 
    Position CurrentPos, NewPos;
    int CNum; /* 记录冲突次数 */
    CNum = 0;
    NewPos = CurrentPos = Hash( Key, H->TableSize );
    while( H->TheCells[ NewPos ].Info != Empty &&H->TheCells[ NewPos ].Element != Key ) {
    /* 字符串类型的关键词需要 strcmp 函数!! */
        if(++CNum % 2){ /* 判断冲突的奇偶次 */
            NewPos = CurrentPos + (CNum+1)/2*(CNum+1)/2;
            while( NewPos >= H->TableSize )
                NewPos -= H->TableSize;
        } else {
            NewPos = CurrentPos - CNum/2 * CNum/2;
            while( NewPos < 0 )
                NewPos += H->TableSize;
        }
    }
    return NewPos;
}

//陈
void Insert( ElementType Key, HashTable H )
{ /* 插入操作 */
    Position Pos;
    Pos = Find( Key, H );
    if( H->TheCells[ Pos ].Info != Legitimate ) {
    /* 确认在此插入 */
        H->TheCells[ Pos ].Info = Legitimate;
        H->TheCells[ Pos ].Element = Key;
    /*字符串类型的关键词需要 strcpy 函数!! */
    }
}

//严
//- - - - -开放地址法散列表的存储表示- - - - -
#define m 20                                            //散列表的表长
typedef struct{
    KeyType key;                                        //关键字项
    InfoType otherinfo;                                 //其他数据项
}HashTable[m];

//查找 
#define NULLKEY 0                               //单元为空的标记
int SearchHash(HashTable HT,KeyType key)
{//在散列表HT中查找关键字为key的元素，若查找成功，返回散列表的单元标号，否则返回-1  
   H0=H(key);                                  //根据散列函数H（key）计算散列地址 
   if(HT[H0].key==NULLKEY) return -1;          //若单元H0为空，则所查元素不存在 
   else if(HT[H0].key==key) return H0;         //若单元H0中元素的关键字为key，则查找成功 
   else 
   { 
      for(i=1;i<m;++i) 
     {     
         Hi=(H0+i)%m;                          //按照线性探测法计算下一个散列地址Hi 
         if(HT[Hi].key==NULLKEY) return -1;    //若单元Hi为空，则所查元素不存在 
         else if(HT[Hi].key==key) return Hi;   //若单元Hi中元素的关键字为key，则查找成功 
      }                                        //for 
      return -1; 
    }                                          //else 
} 

//陈 
//将相应位置上冲突的所有关键词存储在同一个单链表中
//定义 
typedef struct ListNode *Position,*List;
struct ListNode{
    ElementType Element;
    Position Next;
};
typedef struct HashTbl *HashTable;
struct HashTbl{
    int TableSize;
    List TheLists;
};
//查找 
Position Find(ElementType X,HashTable H){
    Position P;
    int Pos;
    Pos=Hash(X,H->TableSize);
    P=H->TheLists[Pos].Next;
    if(P!=NULL&&strcmp(P->Element,X)) P=P->Next;
    return P;
}

 

int ar[5]={3,8,9,5,2};//对它从小到大排序

//插入排序， 每个数与前面排好序的比较，满足条件，就把大家往后移，当前数插入前面自己的位置 
//3,8,9,5,2  
//arr[1]是8，temp= arr[1]  ，arr[0]没有>arr[1]， 
//arr[2]是9，temp= arr[2]  ，
//arr[3]是5，temp= arr[3]  ，
//arr[4]是2，temp= arr[3]  ，
//第1轮 3 8 9 5 2   
//第2轮 3 8 9 5 2
//第3轮 3 5 8 9 2
//第4轮 2 3 5 8 9
void insert_sort(int arr[], int len){
    int i,j,temp;
    for (i=1;i<len;i++){ //此处不-1，因为是从1开始 
            temp = arr[i]; //当前数待插入，先拿出来 
            for (j=i;j>0 && arr[j-1]>temp;j--) //循环每个数，把它和前面比，满足条件就把前面的往后挪一位，再比前面的，
                    arr[j] = arr[j-1];
            arr[j] = temp;  //直到没法挪，当前位置前一位不满足大小，就把待插入的放到当前位  
    }
}
//严
void InsertSort(SqList &L)
{//对顺序表L做直接插入排序 
   for(i=2;i<=L.length;++i) 
      if(L.r[i].key<L.r[i-1].key)                 //“<”，需将r[i]插入有序子表 
      {  
         L.r[0]=L.r[i];                          //将待插入的记录暂存到监视哨中 
         L.r[i]=L.r[i-1];                        //r[i-1]后移 
         for(j=i-2; L.r[0].key<L.r[j].key; --j)  //从后向前寻找插入位置 
            L.r[j+1]=L.r[j];                     //记录逐个后移，直到找到插入位置 
         L.r[j+1]=L.r[0];                        //将r[0]即原r[i]，插入到正确位置 
      }                                          //if 
}

//严
void BInsertSort(SqList &L)
{//对顺序表L做折半插入排序 
   for(i=2;i<=L.length;++i) 
   { 
      L.r[0]=L.r[i];                              //将待插入的记录暂存到监视哨中 
      low=1;high=i-1;                             //置查找区间初值 
      while(low<=high)                            //在r[low..high]中折半查找插入的位置
      {        
         m=(low+high)/2;                           //折半 
         if(L.r[0].key<L.r[m].key) high=m-1;       //插入点在前一子表 
         else low=m+1;                             //插入点在后一子表 
      }                                            //while 
      for(j=i-1;j>=high+1; --j) L.r[j+1]=L.r[j];   //记录后移 
      L.r[high+1]=L.r[0];                          //将r[0]即原r[i]，插入到正确位置 
   }                                               //for 
} 

//希尔排序，插入排序的升级版 
//3,8,9,5,2   len=5
//第1轮 3 5 2 8 9    gap=2  i=2 temp=9 j=0  |  i=3 temp=5 j=1 | i=4 temp=2 j=2 j=0 
//第2轮 2 3 5 8 9    gap=1  i=1 temp=5 j=0  |  i=2 temp=2 j=1 j=0  j=-1          
void shell_sort(int arr[], int len) {
    int gap, i, j;
    int temp;
    for (gap = len >> 1; gap > 0; gap = gap >> 1)
        for (i = gap; i < len; i++) {  
            temp = arr[i];
            for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap) 
                arr[j + gap] = arr[j]; 
            arr[j + gap] = temp;
        }
}
//严
void ShellInsert(SqList &L, int dk)
{//对顺序表L做一趟增量是dk的希尔插入排序 
   for(i=dk+1;i<=L.length;++i) 
      if(L.r[i].key<L.r[i-dk].key)     //需将L.r[i]插入有序增量子表 
      {     
         L.r[0]=L.r[i];                //暂存在L.r[0] 
         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];             //将r[0]即原r[i]，插入到正确位置 
      }                                //if 
}            
void ShellSort(SqList &L,int dt[],int t) 
{//按增量序列dt[0..t-1]对顺序表L作t趟希尔排序 
   for(k=0;k<t;++k) 
      ShellInsert(L,dt[k]);            //一趟增量为dt[t]的希尔插入排序 
} 

//冒泡排序，相邻两数比较，把大的往后冒，每轮循环找最大放后面 
//第1轮 3 8 5 2 9
//第2轮 3 5 2 8 9
//第3轮 3 2 5 8 9
//第4轮 2 3 5 8 9
void bubble_sort(int arr[],int len){
    int i,j,temp;
    for(i=0;i<len-1;i++){ // 同上 
        for(j=0;j<len-1-i;j++){ //下面有+1,所以这里减-1，防止最后一个数和外面比较越界了； 每次放一个最大的，放过的不用再比，因此-i。 
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }    
    }
}
//严
void BubbleSort(SqList &L)
{//对顺序表L做冒泡排序 
   m=L.length-1;flag=1;                           //flag用来标记某一趟排序是否发生交换 
   while((m>0)&&(flag==1)) 
   { 
      flag=0;                                     //flag置为0，如果本趟排序没有发生交换，则不会执行下一趟排序 
      for(j=1;j<=m;j++) 
         if(L.r[j].key>L.r[j+1].key) 
         { 
            flag=1;                                //flag置为1，表示本趟排序发生了交换 
            t=L.r[j]; L.r[j]=L.r[j+1]; L.r[j+1]=t;//交换前后两个记录 
          }                                       //if 
        --m; 
    }                                            //while 
}                                                //BubbleSort 

//快速排序-迭代法
Range new_Range(int s, int e) {
    Range r;
    r.start = s;
    r.end = e;
    return r;
}
void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}
//3,8,9,5,2   len=5
//第一轮：start=0 end=4 mid=9 left=0 right=4 进do left=1 left=2 {3,8,2,5,9} left=3 right=3 left=4
//第二轮：start=0 end=3 mid=8 left=0 right=3 进do left=1 {3,5,2,8,9} left=2 right=2 left=3
//第三轮：start=0 end=2 mid=5 left=0 right=2 进do left=1 {3,2,5,8,9} left=2 right=1 
//第四轮：start=0 end=1 mid=3 left=0 right=1 进do right=0 {2,3,5,8,9} left=1 right=0
void quick_sort(int arr[], const int len) {
    if (len <= 0)
        return; // 避免len等於負值時引發段錯誤（Segment Fault）
    // r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素
    Range r[len];
    int p = 0;
    r[p++] = new_Range(0, len - 1);
    while (p) {
        Range range = r[--p];
        if (range.start >= range.end)
            continue;
        int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點
        int left = range.start, right = range.end;
        do
        {
            while (arr[left] < mid) ++left;   // 檢測基準點左側是否符合要求
            while (arr[right] > mid) --right; //檢測基準點右側是否符合要求
 
            if (left <= right)
            {
                swap(&arr[left],&arr[right]);
                left++;right--;               // 移動指針以繼續
            }
        } while (left <= right);
 
        if (range.start < right) r[p++] = new_Range(range.start, right);
        if (range.end > left) r[p++] = new_Range(left, range.end);
    }
} 

//快速排序-递归法
//3,8,9,5,2   len=5
//第一轮：start=0 end=4 mid=2 left=0 right=3 进while right=2 right=1 right=0 {2,8,9,5,3}
//进递归，start=1 end=4 mid=3 left=1 right=3 进while right=2 right=1 {2,3,9,5,8}
//进if递归，start=1 end=0 return
//进递归  start=2 end=4 mid=8 left=2 right=3 进while {2,3,5,9,8} left=3 {2,3,5,8,9}
//进if递归，start=2 end=2 return
//进递归  start=4 end=4 return
void quick_sort_recursive(int arr[], int start, int end) {
    if (start >= end)
        return;
    int mid = arr[end];
    int left = start, right = end - 1;
    while (left < right) {
        while (arr[left] < mid && left < right)
            left++;
        while (arr[right] >= mid && left < right)
            right--;
        swap(&arr[left], &arr[right]);
    }
    if (arr[left] >= arr[end])
        swap(&arr[left], &arr[end]);
    else
        left++;
    if (left)
        quick_sort_recursive(arr, start, left - 1);
    quick_sort_recursive(arr, left + 1, end);
}
void quick_sort_digui(int arr[], int len) {
    quick_sort_recursive(arr, 0, len - 1);
}

//严
int Partition(SqList &L, int low, int high)
{//对顺序表L中的子表r[low..high]进行一趟排序，返回枢轴位置 
   L.r[0]=L.r[low];                     //用子表的第一个记录做枢轴记录 
   pivotkey=L.r[low].key;               //枢轴记录关键字保存在pivotkey中 
   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];               //将比枢轴记录大的记录移到高端 
   }                                    //while 
   L.r[low]=L.r[0];                     //枢轴记录到位 
   return low;                          //返回枢轴位置 
}
          
void QSort(SqList &L,int low,int high) 
{//调用前置初值：low=1; high=L.length; 
 //对顺序表L中的子序列L.r[low..high]做快速排序 
   if(low<high){                        //长度大于1 
      pivotloc=Partition(L, low, high); //将L.r[low..high]一分为二，pivotloc是枢轴位置 
      QSort(L, low, pivotloc-1);        //对左子表递归排序 
      QSort(L, pivotloc+1, high);       //对右子表递归排序 
   } 
}  

void QuickSort(SqList &L) 
{//对顺序表L做快速排序 
   QSort(L,1,L.length); 
} 

//选择排序，用每个数字和其他依次比较，循环找第一小放第一个、在剩下的里面找第二小放第二个，…… 
//第1轮 2 8 9 5 3
//第2轮 2 3 9 8 5
//第3轮 2 3 5 9 8
//第4轮 2 3 5 8 9
void select_sort(int arr[],int len){
    int i,j,temp; 
    for(i=0;i<len-1;i++){ //外层循环管轮数，5个数，肯定比4轮，因为最后一个数不用和自己比较，所以减一 
        for(j=i+1;j<len;j++) //每个数跟他后面的依次比较，所以加一 
            if(arr[i]>arr[j]){ //如果比后面大，就把小的放前面 
                temp = arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
    }
}
//严
void SelectSort(SqList &L)
{//对顺序表L做简单选择排序 
   for(i=1;i<L.length;++i){                     //在L.r[i..L.length] 中选择关键字最小的记录 
      k=i;                  
      for(j=i+1;j<=L.length;++j) 
         if(L.r[j].key<L.r[k].key) k=j;        //k指向此趟排序中关键字最小的记录 
      if(k!=i) 
         {t=L.r[i]; L.r[i]=L.r[k]; L.r[k]=t;}  //交换r[i]与r[k]         
    }                                          //for   
} 

//严 
//调整堆
void HeapAdjust(SqList &L,int s,int m)
{//假设r[s+1..m]已经是堆，将r[s..m]调整为以r[s]为根的大根堆 
   rc=L.r[s]; 
   for(j=2*s;j<=m;j*=2)                     //沿key较大的孩子结点向下筛选 
   {       
      if(j<m&&L.r[j].key<L.r[j+1].key) ++j; //j为key较大的记录的下标 
      if(rc.key>=L.r[j].key) break;         //rc应插入在位置s上 
      L.r[s]=L.r[j];s=j; 
   }                                        //for 
   L.r[s]=rc;                              //插入 
}

//建初堆
void CreatHeap(SqList &L)
{//把无序序列L.r[1..n]建成大根堆
   n=L.length;
   for(i=n/2;i>0; --i)                  //反复调用HeapAdjust
     HeapAdjust(L,i,n);
}
//堆排序
void HeapSort(SqList &L)
{//对顺序表L进行堆排序
   CreatHeap(L);                 //把无序序列L.r[1..L.length]建成大根堆
   for(i=L.length;i>1;--i)
   {
     x=L.r[1];                  //将堆顶记录和当前未经排序子序列L.r[1..i]中最后一个记录互换
     L.r[1]=L.r[i];
         L.r[i]=x;
     HeapAdjust(L,1,i-1);       //将L.r[1..i-1]重新调整为大根堆
   }                            //for
} 

选择排序还有树形选择排序，就是比赛用的那种。

//严
//相邻两个有序子序列的归并
void Merge(RedType R[],RedType T[],int low,int mid,int high)
{//将有序表R[low..mid]和R[mid+1..high]归并为有序表T[low..high]
   i=low;j=mid+1;k=low;
   while(i<=mid&&j<=high)                 //将R中记录由小到大地并入T中
   {
     if(R[i].key<=R[j].key) T[k++]=R[i++];
     else T[k++]=R[j++];
   }                                      //while
   while(i<=mid) T[k++]=R[i++];           //将剩余的R[i..mid]复制到T中
   while(j<=high) T[k++]=R[j++];          //将剩余的R[j.high]复制到T中
}
//归并排序
void MSort(RedType R[],RedType &T[],int low,int high)
{//R[low..high]归并排序后放入T[low..high]中  
   if(low==high) T[low]=R[low];  
   else 
   {  
      mid=(low+high)/2;       //将当前序列一分为二，求出分裂点mid  
      MSort(R,S,low,mid);     //对子序列R[low..mid]递归归并排序，结果放入S[low..mid]  
      MSort(R,S,mid+1,high);  //对子序列R[mid+1..high]递归归并排序，结果放入S[mid+1..high] 
      Merge(S,T,low,mid,high);//将S[low..mid]和S[mid+1..high]归并到T[low..high] 
   }         //else  
}  
void MergeSort(SqList &L) 
{//对顺序表L做归并排序  
   MSort(L.r,L.r,1,L.length);  
} 

//归并排序-之迭代法 
//大致想法是，相邻两数比，变成小大、小大、小大，然后变宽，再比，变成小小大大、…… ；再变宽，小小小小大大大大、……，
//以此类推，每一轮只要两两比较 小小小小，大大大大的值，把新结果放到新数组里，剩下的抄到后面即可
//这个有种2分法逆着用的感觉，因为变宽（seg）总以2的指数级增长，所以这个算法快不快，取决于边界值能不能快点比完，比如小小小小都小于大，那么后面3个大直接抄就行
int min(int x, int y) {
    return x < y ? x : y;
}
//3,8,9,5,2   len=5
//第一轮  seg=1 start=0 low=0 mid=1 high=2 k=0 start1=0 end1=1 start2=1 end2=2 b[0]=3,k=1,start1=1 b[1]=8 k=2 start2=2  
//                start=2 low=2 mid=3 high=4 k=2 start1=2 end1=3 start2=3 end2=4 b[2]=5 k=3,start2=4 b[3]=9 k=4 start1=3
//                 start=4 low=4 mid=5 high=5 k=4 start1=4 end1=5 start2=5 end2=5 b[4]=2 k=5,start1=5
//                start=6 exit
//                a[]={3,8,5,9,2}
//第二轮  seg=2 start=0,low=0 mid=2 high=4 k=0 start1=0 end1=2 start2=2 end2=4 b[0]=3 k=1 start1=1 b[1]=5 k=2 start2=3 b[2]=8 k=3 start1=2 b[3]=9 k=4 start2=4
//                start=4,low=4,mid=5 high=5 k=4 start1=4 end1=5 start2=5 end2=5 b[4]=2 k=5,start1=5
//                a[]={3,5,8,9,2}
//第三轮  seg=4 start=0 low=0 mid=4 high=5 k=0 start1=0 end1=4 start2=4 end2=5 b[0]=2 k=1 start2=5 b[1]=3 k=2 start1=1 b[2]=5 k=3 start1=2 b[3]=8 k=4 start1=3 b[4]=9 k=5 start1=4 
//                start=8 exit
//                a[]={2,3,5,8,9}
//第三轮  seg=8 exit
void merge_sort(int arr[], int len) {
    int* a = arr; //指向要排序的数组 
    int* b = (int*) malloc(len * sizeof(int));//临时存放每轮排序结果 
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg + seg) {
            //按照分段大小，先确定段与段之间的界限 
            int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            //段内元素两两比较，小的放到临时数组 
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            //其中一段全比完了，剩下一段直接抄到后面 
            while (start1 < end1)
                b[k++] = a[start1++];
            //其中一段全比完了，剩下一段直接抄到后面 
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        //把这种分段下排好的临时数组，作为下次要排序的数组 
        int* temp = a;
        a = b;
        b = temp;
    }
    //释放b空间，我也不知道为啥要重新赋值再释放 
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    free(b);
}

//归并排序-之递归法  
//3,8,9,5,2   len=5
//start=0,end=4,len=4,mid=2,start1=0,end1=2 start2=3 end2=4 入栈 
//start=0,end=2 len=2 mid=1 start1=0,end1=1 start2=2 end2=2 入栈
//start=0,end=1 len=1 mid=0 start1=0 end1=0 start2=1 end2=1 入栈
//start=0 end=0 return end1=0出栈 start2=1入栈直接出栈，代码第一次往下执行
//代码第一次往下执行 k=0 reg[0]=3,start1=1,k=1 reg[1]=8 start2=2 arr[0]=3 arr[1]=8
//上步代码走完，return end1=1出栈 start2=2入栈直接出栈，代码第二次往下执行
//代码第二次往下执行 k=0 reg[0]=3 start1=1 k=1 reg[1]=8 start1=2 k=2 reg[2]=9 start2=3 k=3 arr[0]=3 arr[1]=8 arr[2]=9
//上步代码走完，return end1=2出栈 start2=3入栈,
//start=3,end=4 len 1 mid=3 start1=3 end1=3 start2=4 end2=4 入栈直接出栈，入栈直接出栈，代码第三次往下执行
//代码第三次往下执行 k=3 reg[3]=2 start2=5 k=4 reg[4]=5 k=5 start1=4 arr[3]=2 arr[4]=5
//arr[]={3,8,9,2,5} 
//上步代码走完,第一行 start=0,end=4完成了两个递归，继续往下，
//代码第四次往下走  k=0,reg[0]=2,start1=1,k=1, reg[1]=3,start1=2,k=2 reg[2]=5 start2=4 k=3 reg[3]=8 start2=4 k=4 reg[4]=9 
//arr[]={2,3,5,8,9}      

void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}
void merge_sort_digui(int arr[], const int len) {
    int reg[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
}

//严
//链式基数排序
//定义 
#define MAXNUM_KEY 8                    //关键字项数的最大值
#define RADIX 10                        //关键字基数，此时是十进制整数的基数
#define MAX_SPACE 10000
typedef struct
{
   KeyType keys[MAXNUM_KEY];            //关键字
   InfoType otheritems;                 //其他数据项
   int next；
}SLCell；                               //静态链表的结点类型
typedef struct
{
   SLCell r[MAX_SPACE];                //静态链表的可利用空间，r[0]为头结点
   int keynum;                         //记录的当前关键字个数
   int recnum;                         //静态链表的当前长度
}SLList;                               //静态链表类型
typedef int ArrType[RADIX]             //数组类型 

//排序
void Distribute(SLCell &r,int i,ArrType &f,ArrType &e)
{//静态链表L的r域中记录已按（keys[0], …, keys[i-1]）有序
 //本算法按第i个关键字keys[i]建立RADIX个子表，使同一子表中记录的 keys[i]相同
 //f[0..RADIX-1]和e[0..RADIX-1]分别指向各子表中第一个和最后一个记录
   for(j=0;j<RADIX;++j) f[j]=0;                   //各子表初始化为空表
   for(p=r[0].next;p;p=r[p].next)
   {
     j=ord(r[p].keys[i]);                         //ord将记录中第i个关键字映射到[0..RADIX-1]
     if(!f[j]) f[j]=p;
     else r[e[j]].next=p;
     e[j]=p;                                      //将p所指的结点插入第j个子表中
   }                                              //for
}

void Collect(SLCell &r,int i,ArrType f,ArrType e)
{//本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成一个链表
 //e[0..RADIX-1]为各子表的尾指针
   for(j=0;!f[j]; j=succ(j));                     //找第一个非空子表，succ为求后继函数
   r[0].next=f[j]; t=e[j];                        //r[0].next指向第一个非空子表中第一个结点
   while(j<RADIX)
   {
     for(j=succ(j);j<RADIX-1&&!f[j];j=succ(j));   //找下一个非空子表
     if(f[j]) {r[t].next=f[j]; t=e[j];}           //链接两个非空子表
   }                                              //while
   r[t].next=0;                                   //t指向最后一个非空子表中的最后一个结点
}

void RadixSort(SLList &L)
{//L是采用静态链表表示的顺序表
 //对L做基数排序，使得L成为按关键字自小到大的有序静态链表，L.r[0]为头结点
   for(i=0;i<L.recnum;++i) L.r[i].next=i+1;
   L.r[L.recnum].next=0;                         //将L改造为静态链表
   for(i=0;i<L.keynum;++i)  {                    //按最低位优先依次对各关键字进行分配和收集
     Distribute(L.r,i,f,e);                      //第i趟分配
     Collect(L.r,i,f,e);                         //第i趟收集
   }                                             //for
}