#define  MAXSIZE 100     //最大长度
typedef  struct {
  ElemType  *elem;     //指向数据元素的基地址
  int  length;          //顺序表的当前长度
  int listsize;        //顺序表初始分配的空间大小               
 }SqList；

Status InitList_Sq(SqList &L){  //构造一个空的顺序表L
    L.elem=new ElemType[MAXSIZE];   //为顺序表分配空间
    if(!L.elem) exit(OVERFLOW);       //存储分配失败
    L.length=0;  //空表长度为0
    L.listsize=MAXSIZE;  
    return OK;
}

Status InitList_Sq(SqList *L){    //构造一个空的顺序表L
    L-> elem=new ElemType[MAXSIZE];   //为顺序表分配空间
    if(! L-> elem) exit(OVERFLOW);       //存储分配失败
    L-> length=0;              //空表长度为0
    L-> listsize=MAXSIZE;
    return OK;
}

Status DestroyList(SqList &L){
  if (L.elem) {
      delete L.elem;    //释放存储空间
      L.elem=NULL;
      L.length=0;
      L.listsize=0;
   }
   return OK;
}

Status ClearList(SqList &L) 
{
   L.length=0;                //将顺序表的长度置为0
   return OK;
}

Status ClearList(SqList &L) 
{
   L.length=0;                //将顺序表的长度置为0
   return OK;
}

int IsEmpty(SqList L)
{
  if (L.length==0) return 1;      
   else return 0;
}

int IsEmpty(SqList L)
{
  if (L.length==0) return 1;      
   else return 0;
}

int LocateElem(SqList L,ElemType e)
{
  for (i=0;i< L.length;i++)
      if (L.elem[i]==e) return i+1;                
  return 0;
}

Status ListInsert_Sq(SqList &L,int i ,ElemType e){
   if(i<1 || i>L.length+1) return ERROR;         //i值不合法
   if(L.length==L.listsize) return ERROR;    //当前存储空间已满     
   for(j=L.length-1;j>=i-1;j--) 
       L.elem[j+1]=L.elem[j];    //插入位置及之后的元素后移
    L.elem[i-1]=e;                     //将新元素e放入第i个位置
    L.length++;     //表长加1
    return OK;
}

Status ListDelete_Sq(SqList &L,int i,ElemType &e){
   if((i<1)||(i>L.length)) return ERROR; //i值不合法
   e=L.elem[i-1];                              //将欲删除的元素保留在e中
  for (j=i;j<=L.length-1;j++)                   
　  　L.elem[j-1]=L.elem[j];       //被删除元素之后的元素前移  
   --L.length;                     //表长减1
  return OK;
}

typedef struct LNode{
     ElemType   data;       //数据域
     struct LNode  *next;   //指针域
}LNode,*LinkList;   
                // LinkList为Lnode类型的指针

Status InitList_L(LinkList &L){ 
   L=new LNode;     
   if (!L) exit(OVERFLOW);               
   L->next=NULL;　　　　　
   return OK; 
} 

Status DestroyList_L(LinkList &L){
    LinkList p;
       while(L)
        {
            p=L;  
            L=L->next;
            delete p;  
        }
     return OK;
 }

LinkList p = L;
       while(p){
            q = p->next;
            delete p; 
            p=q;  
        }
       L=NULL;
       return OK;
}

Status ClearList(LinkList &L){// 将L重置为空表 
   LinkList p;
   while(L->next) {               
        p=L->next; 
        L->next =p->next; 
        delete p; 
    }
    return OK;
}

LinkList p = L->next, q;
       while(p){
            q=p->next;
            delete p; 
            p=q;}
       L->next=NULL;
       return OK;
}

int  ListLength_L(LinkList L){
//返回L中数据元素个数
    LinkList p;
    p=L->next;         //p指向第一个结点
     j=0;             
     while(p){           //遍历单链表,统计结点数
           j++;
           p=p->next;    } 
    return j;                             
 }

int ListEmpty(LinkList L){ 
//若L为空表，则返回1，否则返回0 
   if(L->next)   //非空 
     return 0;
   else
     return 1;
 }

Status GetElem_L(LinkList L,int i,ElemType &e){ 
    p=L->next;j=1; //初始化
     while(p&&j<i){//向后扫描，直到p指向第i个元素或p为空
       p=p->next; ++j;                           
     } 
     if(!p || j>i)return ERROR; //第i个元素不存在 
     e=p->data; //取第i个元素 
     return OK; 
}//GetElem_L 

LNode *LocateElem_L (LinkList L，Elemtype e) { 
  p=L->next; 
  while(p &&p->data!=e)  
        p=p->next;                
  return p; //返回L中值为e的数据元素的位置，查找失败返回NULL 
} 

Status ListInsert_L(LinkList &L,int i,ElemType e){ 
     p=L;j=0; 
      while(p&&j<i−1){p=p->next;++j;}//寻找第i−1个结点 
      if(!p||j>i−1)return ERROR;//i大于表长 + 1或者小于1  
      s=new LNode;//生成新结点s 
      s->data=e;                 //将结点s的数据域置为e 
      s->next=p->next;             //将结点s插入L中 
      p->next=s; 
      return OK; 
}//ListInsert_L 

Status ListInsert_L(LinkList &L,int i,ElemType e){ 
    //添加这一段-----------------------------------------
      if(!L&&i!=1)  return ERROR;
      if(i==1) {
           s=new LNode; s->data=e; s->next=L; L=s;  return  OK;}
    //--------------------------------------------------
      p=L;j=1; 
      while(p&&j<i−1){p=p->next;++j;}//寻找第i−1个结点 
      if(!p||j>i−1)return ERROR;//i大于表长 + 1或者小于1  
      s=new LNode;//生成新结点s 
      s->data=e;                 //将结点s的数据域置为e 
      s->next=p->next;             //将结点s插入L中 
      p->next=s; 
      return OK; 
}//ListInsert_L 

Status ListDelete_L(LinkList &L,int i,ElemType &e){
    p=L;j=0; 
    while(p->next &&j<i-1){//寻找第i个结点，并令p指向其前驱 
        p=p->next; ++j; } 
    if(!(p->next)||j>i-1) return ERROR; //删除位置不合理 
    q=p->next; //临时保存被删结点的地址以备释放 
    p->next=q->next; //改变删除结点前驱结点的指针域 
    e=q->data; //保存删除结点的数据域 
    delete q; //释放删除结点的空间 
 return OK; 
}//ListDelete_L 

Status ListDelete_L(LinkList &L,int i,ElemType &e){
    if(!L)  return ERROR;
    if(i==1) {p=L; L=L->next; delete p; return OK;}
    p=L;j=1; 
    while(p->next &&j<i-1){p=p->next; ++j; } 
    if(!(p->next)||j>i-1) return ERROR; //删除位置不合理 
    q=p->next; //临时保存被删结点的地址以备释放 
    p->next=q->next; //改变删除结点前驱结点的指针域 
    e=q->data; //保存删除结点的数据域 
    delete q; //释放删除结点的空间 
 return OK; 
}//ListDelete_L 

void CreateList_F(LinkList &L,int n){ 
     L=new LNode; 
      L->next=NULL; //先建立一个带头结点的单链表 
      for(i=n;i>0;--i){ 
        p=new LNode; //生成新结点 
        cin>>p->data; //输入元素值 
        p->next=L->next;L->next=p; //插入到表头 
     } 
}//CreateList_F 

void CreateList_L(LinkList &L,int n){ 
      //正位序输入n个元素的值，建立带表头结点的单链表L 
      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;     //插入到表尾 
        r=p; //r指向新的尾结点 
      } 
}//CreateList_L 

void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){
   pa=La->next;  pb=Lb->next;
   pc=Lc=La;             //用La的头结点作为Lc的头结点 
   while(pa && pb){
      if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next;}
      else{pc->next=pb; pc=pb; pb=pb->next;}
   pc->next=pa?pa:pb;    //插入剩余段  
   delete Lb;             //释放Lb的头结点}  

typedef struct DuLNode{
    ElemType   data;              
    struct DuLNode  *prior;  
    struct DuLNode  *next;  
}DuLNode, *DuLinkList

Status ListInsert_DuL(DuLinkList &L,int i,ElemType e){
   if(!(p=GetElemP_DuL(L,i))) return ERROR;
    s=new DuLNode; 
   s->data=e;
   s->prior=p->prior;  
   p->prior->next=s;
   s->next=p;  
   p->prior=s;
   return OK;
}

Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e){
   if(!(p=GetElemP_DuL(L,i)))     return ERROR;
   e=p->data;
   p->prior->next=p->next;
   p->next->prior=p->prior;
   delete p; 
   return OK;
}

#define  MAXSIZE  100
typedef struct
{
SElemType   *base;
SElemType   *top;
int stacksize;
}SqStack;

Status InitStack( SqStack &S ){
S.base =new SElemType[MAXSIZE]；
if( !S.base ) return OVERFLOW;
S.top = S.base;
S.stackSize = MAXSIZE;
return OK;
}

bool StackEmpty( SqStack S )
{
if(S.top == S.base) return true;
   else return false;
}

int StackLength( SqStack S )
{
return S.top – S.base;
}

Status ClearStack( SqStack  &S )
{
if( S.base ) S.top = S.base;
return OK;
}

Status DestroyStack( SqStack &S ){
if( S.base ){
delete S.base ;
S.stacksize = 0;
S.base = S.top = NULL;
}
  return OK;
}

Status Push( SqStack &S, SElemType e)  
{
if( S.top - S.base== S.stacksize ) // 栈满
        return ERROR; 
*S.top++=e;
return OK;
}

Status Pop( SqStack &S, SElemType &e)  
{
if( S.top == S.base ) // 栈空
        return ERROR; 
e＝ *--S.top;
return OK;
}

Status GetTop( SqStack S, SElemType &e)  
{
if( S.top == S.base ) return ERROR; // 栈空
e = *( S.top – 1 );
return OK;
}

typedef  struct StackNode {
      SElemType  data; //数据域
      struct StackNode *next; //指针域
 } StackNode,  *LinkStack;

void InitStack(LinkStack &S )
{
S=NULL;
}

Status StackEmpty(LinkStack S) {
    if (S == NULL) {
        return TRUE;
    } else {
        return FALSE;
    }
}

Status Push(LinkStack &S, SElemType e) {
    p = new StackNode; // 生成新结点p
    if (!p) {
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = S;
    S = p;
    return OK;
}

Status Pop (LinkStack &S,SElemType &e)
{
if (S==NULL) return ERROR;
e = S-> data;  
p = S;   
S =  S-> next;
delete p;   
return OK;  
}  

#define M  100   //最大队列长度
Typedef struct {
   QElemType *base;  //初始化的动态分配存储空间
   int  front;            //头指针   
   int  rear;             //尾指针
}SqQueue;  

Status InitQueue (SqQueue &Q){
    Q.base =new QElemType[MAXQSIZE] ;
   if(!Q.base) exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

int  QueueLength (SqQueue Q){
    return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;   
 }

Status EnQueue(SqQueue &Q,QElemType e){
    if((Q.rear+1)%MAXQSIZE==Q.front)  return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
     return OK; 
}

Status DeQueue (LinkQueue &Q,QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAXQSIZE;
   return OK;
}

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=(QueuePtr) malloc(sizeof(QNode)); 
    if(!Q.front) exit(OVERFLOW);
    Q.front->next=NULL;
     return OK;
}

Status InitQueue (LinkQueue &Q){
   Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode)); 
    if(!Q.front) exit(OVERFLOW);
    Q.front->next=NULL;
     return OK;
}

Status QueueEmpty (LinkQueue Q){
   return (Q.front==Q.rear);   
}

Status GetHead (LinkQueue Q, QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.front->next->data;
   return OK;
}

Status EnQueue(LinkQueue &Q,QElemType e){
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(OVERFLOW);
    p->data=e; p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}

Status EnQueue(LinkQueue &Q, QElemType e) {
    p = (QueuePtr)malloc(sizeof(QNode));
    if (!p) {
        exit(OVERFLOW);
    }
    p->data = e; 
    p->next = NULL;
    if (Q.front == NULL) {
        Q.front = p;
        Q.rear = p;
        return OK;
    }
    Q.rear->next = p;
    Q.rear = p;
    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;
   if(Q.rear==p) Q.rear=Q.front;
   free(p);
   return OK;
}

int Search_Seq( SSTable  ST , KeyType  key ){
   //若成功返回其位置信息，否则返回0
  ST.R[0].key =key;   
 for( i=ST.length; ST.R[ i ].key!=key;  - - i  );
 //不用for(i=n; i>0; - -i) 或 for(i=1; i<=n; i++)  
   return i; 

}

int Search_Bin(SSTable ST,KeyType key){
//若找到，则函数值为该元素在表中的位置，否则为0
    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;//表中不存在待查元素
}

int Search_Bin (SSTable ST, keyType key, int low, int high) 
{ 
  if(low>high) return 0;   //查找不到时返回0 
  mid=(low+high)/2; 
  if(key等于ST.elem[mid].key)  return mid; 
  else if(key小于ST.elem[mid].key)  
    ……..//递归
  else…….  //递归
} 

void InsertSort(SqList ＆L)
 {int i,j;
   for(i=2;i<=L.length;++i)
     if( L.r[i].key<L.r[i-1].key)//将L.r[i]插入有序子表
       { L.r[0]=L.r[i]; // 复制为哨兵
          L.r[i]=L.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]; //插入到正确位置
       }
 }

Status BInsertSort ( SqList &L )
 { for ( i = 2;  i <= L.length ; ++i )
    {  L.r[0] = L.r[i]; low = 1 ; high = i-1 ;
       while ( low <= high )       
          {  m = ( low + high ) / 2 ; 
             if  ( LT( L.r[0].key , L.r[m]. key ) )  high = m -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];
     }
  }  // BInsertSort

void   ShellSort(SqList &L，int delta[ ]，int t){
        //按增量序列delta[0…t-1]对顺序表L作Shell排序
   for(k=0；k<t；++k)
    　ShellInsert(L，delta[k])；
　 　//增量为delta[k]的一趟插入排序
}  // ShellSort

void bubble_sort(SqList &L)
{ int m,i,j,flag=1;   RedType x;
  m=n-1;
  while((m>0)&&(flag==1))
  {  flag=0;
     for(j=1;j<=m;j++)
        if(L.r[j].key>L.r[j+1].key)
         {  flag=1;
            x=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=x; //交换
          }//endif
     m--;
   }//endwhile
}

void QSort ( SqList &L，int low,  int  high ) 
{  if  ( low < high ) 
    {  pivotloc = Partition(L, low, high ) ;
        Qsort (L, low, pivotloc-1) ; 
        Qsort (L, pivotloc+1, high ) 
     }
}

int 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;
}

void SelectSort(SqList &K)
 { 
    for (i=1; i<L.length; ++i)
    { //在L.r[i..L.length] 中选择key最小的记录
        k=i;     
        for( j=i+1;j<=L.length ; j++)
            if ( L.r[j].key <L.r[k].key) k=j; 
        if(k!=i)L.r[i]←→L.r[k];            
    }  
}

typedef struct BiNode{
   TElemType   data;
   struct  BiNode   *lchild,*rchild; //左右孩子指针
}BiNode,*BiTree; 

typedef struct TriTNode{  TelemType data;   struct TriTNode *lchild,*parent,*rchild; }TriTNode,*TriTree;
//三叉链表

Status PreOrderTraverse(BiTree T){
  if(T==NULL) return OK; //空二叉树
  else{    
     cout<<T->data; //访问根结点
     PreOrderTraverse(T->lchild); //递归遍历左子树
     PreOrderTraverse(T->rchild); //递归遍历右子树
    }
}

Status InOrderTraverse(BiTree T){
  if(T==NULL) return OK; //空二叉树
  else{    
     InOrderTraverse(T->lchild); //递归遍历左子树
  cout<<T->data; //访问根结点
     InOrderTraverse(T->rchild); //递归遍历右子树
    }
}

Status PostOrderTraverse(BiTree T){
  if(T==NULL) return OK; //空二叉树
  else{    
     PostOrderTraverse(T->lchild); //递归遍历左子树
     PostOrderTraverse(T->rchild); //递归遍历右子树
     cout<<T->data; //访问根结点
    }
}

int NodeCount(BiTree T)
{
if(T==NULL)
return 0; //如果是空树，则结点总数为0
else
return 1 + NodeCount(T- >lchild) + 
NodeCount(T->rchild);
}

int LeafCount(BiTree T)
{
if(T==NULL)
return 0; //如果是空树，则叶子结点个数为0
else if(T->lchild==NULL&&T->rchild==NULL)
return 1; //判断该结点是否是叶子结点（左孩子
右孩子都为空），若是则返回1
else
return LeafCount(T->lchild) + 
LeafCount(T->rchild);
}

int Height(BiTree T)
{
if(T==NULL)
return 0; //如果是空树，则高度为0
else 
           {
                        int hl = Height(T>lchild), 
                        int hr = Height(T->rchild);
return (hl ≥ hr) ? (1 + hl): (1 + hr);
            }
}

void LayeredTraverse(BiTree T){ 
    cout<<T->data;               //访问第v个顶点
    InitQueue(Q); EnQueue(Q, T);            //辅助队列Q初始化， T进队
    while(!QueueEmpty(Q)){   //队列非空 
       DeQueue(Q, p);        //队头元素出队并置为p 
       if(p->lchild!=NULL){               //p指向的结点有左孩子
             cout<<p->lchild->data; 
             EnQueue(Q, p->lchild); //左孩子进队 
        }//if 
       if(p->rchild!=NULL){               //p指向的结点有右孩子
             cout<<p->rchild->data; 
             EnQueue(Q, p->rchild); //右孩子进队 
        }//if 
    }//while 
}//LayeredTraverse

typedef struct PTNode{
    DataType data;
    int parent;
} PTNode;

typedef struct PTree{
    PTNode     nodes[MAXSIZE];
    int r, n; //根的位置和结点数
} PTree;

typedef struct CTNode{
    int child;
   struct CTNode *next;
}CTNode;//孩子节点
typedef struct CTBox{
    DataType data;
   CTNode *firstchild;
}CTBox; //表头节点

typedef struct CTree{
    CTBox nodes[MAXSIZE];
    int n,r;
} CTree; //树

typedef struct CSNode{
  ElemType          data;
  struct CSNode     *firstchild,*nextsibling;
}CSNode,*CSTree;

BSTree SearchBST(BSTree T, KeyType key) {
   if((!T) || key==T->data.key) return T;        
   else if (key<T->data.key)  return SearchBST(T->lchild,key);//在左子树中继续查找
   else return SearchBST(T->rchild,key);       //在右子树中继续查找
} // SearchBST

typedef struct BiNode{
   TElemType   data;
   struct  BiNode   *lchild,*rchild; //左右孩子指针
}BiNode,*BiTree; 

bool isBalanced(BiTree T) 

bool isBalanced(BiTree T) 
{ return height(T) >= 0; } 

int dfs(TreeNode* root) { 
      if (T == null) 
               { return 0; } // 记录左子树的高度
      int left_height = dfs(T->lchild); // 记录右子树的高度
      int right_height = dfs(T->rchild); 
      if (abs(left_height - right_height) > 1 || left_height == -1 || right_height == -1) { return -1; } 
     return 1 + max(left_height, right_height); } 
}

void CreatHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int n){
//从叶子到根逆向求每个字符的赫夫曼编码，存储在编码表HC中
HC=new char *[n+1];         //分配n个字符编码的头指针矢量
cd=new char [n];//分配临时存放编码的动态数组空间
cd[n-1]=’\0’; //编码结束符
for(i=1; i<=n; ++i){//逐个字符求赫夫曼编码
    start=n-1; c=i; f=HT[i].parent;                 
    while(f!=0){//从叶子结点开始向上回溯，直到根结点
         --start;                          //回溯一次start向前指一个位置
         if (HT[f].lchild= =c)  cd[start]=’0’;//结点c是f的左孩子，则生成代码0
         else cd[start]=’1’;               //结点c是f的右孩子，则生成代码1
         c=f; f=HT[f].parent;             //继续向上回溯
    }                                  //求出第i个字符的编码      
    HC[i]= new char [n-start];         // 为第i 个字符编码分配空间
    strcpy(HC[i], &cd[start])；    //将求得的编码从临时空间cd复制到HC的当前行中
  }
  delete cd;                            //释放临时空间
} // CreatHuffanCode

Status CreateUDN(AMGraph &G){ 
    //采用邻接矩阵表示法，创建无向网络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;   
    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 
   }//for 
   return OK; 
}//CreateUDN 
 int LocateVex(MGraph G,VertexType u)
 { /* 初始条件:图G存在,u和G中顶点有相同特征 */
   /* 操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
   int i;
   for(i=0;i<G.vexnum;++i)
     if(u==G.vexs[i])
       return i;
   return -1;
 }

#define MVNum 100            //最大顶点数 
typedef struct ArcNode{      //边结点 
    int adjvex;                        //该边所指向的顶点的位置 
    struct ArcNode * nextarc;   //指向下一条边的指针 
    OtherInfo info;              //和边相关的信息 
}ArcNode; 
-----------------------------------------------------
typedef struct VNode{ 
    VerTexType data;        //顶点信息 
    ArcNode * firstarc;     //指向第一条依附该顶点的边的指针 
}VNode;               
-----------------------------------------------------
typedef struct{ 
    VNode vertices[MVNum];  //邻接表 
    int vexnum, arcnum;          //图的当前顶点数和边数 
}ALGraph; 

Status CreateUDG(ALGraph &G){ 
　　//采用邻接表表示法，创建无向图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 
    for(k = 0; k<G.arcnum;++k){        //输入各边，构造邻接表 
       cin>>v1>>v2;                 //输入一条边依附的两个顶点 
       i = LocateVex(G, v1);  j = LocateVex(G, v2);    
       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的边表头部 
    }//for 
    return OK; 
}//CreateUDG 

typedef  struct  arcnode     //边结点
{   int   tailvex,  headvex;  //弧尾、弧头在表头数组中位置
     struct   arcnode   *hlink；//指向弧头相同的下一条弧
     struct   arcnode   *tlink;    //指向弧尾相同的下一条弧
}DGraphEdge;

typedef  struct  dnode  //顶点结点
{   int   data;  //与顶点有关信息
     struct   arcnode   *firstin；//指向以该顶点为弧头的第一个弧结点
     struct   arcnode   *firstout; //指向以该顶点为弧尾的第一个弧结点
}DGraph;
DGraph g[M];    //g[0]不用

typedef   struct  arcnode  //边结点
{   int  mark;   //标志域
     int  ivex, jvex;  //该边依附的两个顶点在表头数组中位置
     struct  arcnode  *ilink, *jlink; //分别指向依附于ivex和jvex的
                                                           下一条边
}NDGraphEdge;

typedef   struct  dnode  //顶点结点
{    int   data;   //存与顶点有关的信息
      struct   arcnode  *firstedge;  //指向第一条依附于该顶点的边
}NDGraph;
NDGraph G[M];   //G[0]不用

void DFS(AMGraph G, int v){        //图G为邻接矩阵类型 
  cout<<v;  visited[v] = true;  //访问第v个顶点
  for(w = 0; w< G.vexnum; w++)  //依次检查邻接矩阵v所在的行  
        if((G.arcs[v][w]!=0)&& (!visited[w]))  DFS(G, w); 
      //w是v的邻接点，如果w未访问，则递归调用DFS 
} 

typedef struct{ 
      VerTexType vexs[MVNum]; //顶点表 
      ArcType arcs[MVNum][MVNum]; //邻接矩阵 
      int vexnum,arcnum; //图的当前点数和边数 
}AMGraph; 

void DFS(ALGraph G, int v){        //图G为邻接表类型 
   cout<<v;  visited[v] = true;    //访问第v个顶点
   p= G.vertices[v].firstarc;     //p指向v的边链表的第一个边结点 
   while(p!=NULL){              //边结点非空 
     w=p->adjvex;               //表示w是v的邻接点 
     if(!visited[w])  DFS(G, w);//如果w未访问，则递归调用DFS 
     p=p->nextarc;                //p指向下一个边结点 
   } 
} 

typedef struct ArcNode{
    int adjvex;  
    struct ArcNode * nextarc; 
    OtherInfo info;           
}ArcNode; 
typedef struct VNode{ 
    VerTexType data; 
    ArcNode * firstarc; 
}VNode; 

typedef struct{ 
    VNode vertices[MVNum]; 
    int vexnum, arcnum; }ALGraph; 

void BFS (Graph G, int v){ 
    //按广度优先非递归遍历连通图G 
    cout<<v; visited[v] = true;     //访问第v个顶点
    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)) 
       if(!visited[w]){               //w为u的尚未访问的邻接顶点 
             cout<<w; visited[w] = true;
             EnQueue(Q, w); //w进队 
          }//if 
    }//while 
}//BFS 

typedef struct node
{   int vex;
    struct node *next;
}GraphNode;
typedef struct tnode
{   int vexdata;
    int in;
    struct node *link;
}Graph;

void toposort(Graph g[],int n)
{  int top,m,k,j,s[M];
   GraphNode *p;
   top=0; m=0;
   for(j=1;j<=n;j++)
     if(g[j].in==0)  s[top++]=j;
   while(top>0)
   {  j=s[--top];
      printf("%d  ",g[j].vexdata);
      m++;
      p=g[j].link;
      while(p!=NULL)
      {  k=p->vex;
   g[k].in--;
   if(g[k].in==0)
      s[top++]=k;
      p=p->next;
      }
   }
   printf("\nm=%d\n",m);
   if(m<n)  printf("The network has a cycle\n");
}

Status TopoLogicalOrder( Graph G, Stack &T){
//T 拓扑排序栈
FindInDegree(G, indegree); //求各的顶点的入度
Stack S; //入度为0 的顶点栈
InitStack(T); count=0; ve[0..G,vexnum-1]=0;
while(!stackEmpty(S)){
Pop(S,j); Push(T,j);++count;
for (p=G.vertices[j].firstarc; p; p=p->nextarc){
k=p->adjvex;
if(--indegree[k]==0)Push(S,k);
if(ve[j]+*(p->info)>ve[k]) ve[k]=ve[j]+*(p->info);
}
}
if(count<G.vexnum) return ERROR;
else return OK;
}

Status CriticalPath(Graph G){
Stack T;
if(!TopoLogicalOrder(G,T) return ERROR; //拓扑排序时已计算最早发生时间
vl[0..G.vexnum-1]=ve[G.vexnum-1]; //初始化最迟发生时间
while(!StackEmpty(T)){
for(Popo(T,j), p=G.vertices[j].firstarc; p; p=p->nextarc){
k=p->adjvex; dut=*(p->info); //dut<j,k>
if(vl[k]-dut<vl[j]) vl[j]=vl[k]-dut
}
}
for(j=0; j<G.vexnum; ++j){
for(p=G.vertices[j].firstarc; p; p=p->nextarc){
k=p->adjvex; dut=*(p->info);
ee=ve[j]; el=vl[k]-dut;
tag=(ee==el)?"*":"";
printf(j,k,dut,ee,el,tag); //输出关键活动
}
}
}

public static float knapsack(float c, float [] w, float [] v, float [] x){
int n=v.length;
Element [] d = new Element [n];
for (int i = 0; i < n; i++) d[i] = new Element(w[i],v[i],i);
MergeSort.mergeSort(d);
int i;
float opt=0;
for (i=0;i<n;i++) x[i]=0;
for (i=0;i<n;i++) {
if (d[i].w>c) break;
x[d[i].i]=1;
opt+=d[i].v;
c-=d[i].w;
}
if (i<n){
x[d[i].i]=c/d[i].w;
opt+=x[d[i].i]*d[i].v;
}
return opt;
}

public static int greedySelector(int [] s, int [] f, boolean a[])
   {  sort all the job in ascending order of finishing time, 
      and relabel them.
      int n=s.length-1;
      a[1]=true;
      int j=1;
      int count=1;
      for (int i=2;i<=n;i++) {
        if (s[i]>=f[j]) {
          a[i]=true;
          j=i;
          count++;
          }\\if
        else a[i]=false;
      }\\for
      return count;
   }

void ShortestPath_DIJ(AMGraph G, int v0){ 
    //用Dijkstra算法求有向网G的v0顶点到其余顶点的最短路径 
    n=G.vexnum;                    //n为G中顶点的个数 
    S[v0]=true;                    //将v0加入S 
    D[v0]=0;                      //源点到源点的距离为0
    for(v = 1; 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 
     }//for 
/*―开始主循环，每次求得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 
               }//if 
    }//for       
}//ShortestPath_DIJ 

采用图的邻接矩阵的存储结构
怎样构造一个图，在此不赘述，直接给出floyd-wallshall算法。
void MDNet::Floyd(CDC *pDC)
{
typedef vector<int> path;//使用顺序表模板
path p[max_vertex_num][max_vertex_num];
//p存放每对顶点之间的最短路径

int D[max_vertex_num][max_vertex_num];
// D存放每对顶点之间的最短路径值
int i,j,k;
for(i=1;i<=vex_num;i++)
{//初始化
for(j=1;j<=vex_num;j++)
{
p[i][j].push_back(i);
p[i][j].push_back(j);
//顶点i和顶点j之间的路径初始时就是ij。
D[i][j]=arcs[i][j];//路径值为边（i，j）的权值
}
} 
for(k=1;k<=vex_num;k++)
 {//对于每一个顶点都要试探
for(i=1;i<=vex_num;i++)
{
for(j=1;j<=vex_num;j++)
{//在顶点i和顶点j之间的路径上试探k
if(i==j)continue;//对角线上的元素（即顶点自身之//间）不予考虑
if(D[i][k]+D[k][j]<D[i][j])
{//发现更短的路径
D[i][j]=D[i][k]+D[k][j];
//新的i、j间的路径由两部分组成
//p[i][k]+p[k][j]
p[i][j]=p[i][k]for(int m=1;m<p[k][j].size();m++)
    p[i][j].push_back(p[k][j][m]);
}
}
}
 }
for(i=1;i<=vex_num;i++)
 {//打印每两个顶点之间的路径
 for(j=1;j<=vex_num;j++)
 {
 for(k=0;k<p[i][j].size();k++)
 cout<<p[i][j][k]<<"  ";
 cout<<D[i][j];
 cout<<endl;
 }
 }
}

public static void matrixChain(int [] p, int [][] m, int [][] s) {
      int n=p.length-1;
      for (int i = 1; i <= n; i++) m[i][i] = 0;
      for (int r = 2; r <= n; r++)                   \\ r 为矩阵链的长度
           for (int i = 1; i <= n - r+1; i++) {     \\ i 为首矩阵的序号
                 int j=i+r-1;                                \\ j 为尾矩阵的序号
                 m[i][j] = m[i+1][j]+ p[i-1]*p[i]*p[j];   \\ 首先尝试在矩阵 i 处分开
                 s[i][j] = i;
                 for (int k = i+1; k < j; k++) {           \\ 然后尝试在矩阵 k 处分开
                       int t = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
                       if (t < m[i][j]) {
                            m[i][j] = t;
                            s[i][j] = k;
                       }
                 }
           }
      }
}

Input: n, w1,…,wN, v1,…,vN
for w = 0 to W
   M[0, w] = 0
for i = 1 to n
   for w = 1 to W
      if (wi > w)
         M[i, w] = M[i-1, w]
      else
         M[i, w] = max {M[i-1, w], vi + M[i-1, w-wi ]}
return M[n, W]

Algorithm lcsLength(x,y,b)
1: m<-x.length;
2: n<-y.length;
3: m[i][0]=0; m[0][i]=0;
4: for (int i = 1; i <= m; i++)
5:    for (int j = 1; j <= n; j++) 
6:       if (x[i]==y[j]) 
7:           m[i][j]=m[i-1][j-1]+1;
8:           b[i][j]=1;
9:        else if (m[i-1][j]>=m[i][j-1]) 
10:          m[i][j]=m[i-1][j];
11:          b[i][j]=2;
12:      else 
13:           m[i][j]=c[i][j-1];
14:           b[i][j]=3;

构造最长公共子序列
Algorithm lcs(int i,int j,char [] x,int [][] b)
   {
      if (i ==0 || j==0) return;
      if (b[i][j]== 1){
        lcs(i-1,j-1,x,b);
        System.out.print(x[i]);
        }
      else if (b[i][j]== 2) lcs(i-1,j,x,b);
        else lcs(i,j-1,x,b);
   }

iwctl   //在 Linux 中，"ctl" 通常代表 "control" 或 "controller"。例如，在 SysV 初始化系统中，/etc/init.d 目录下的脚本通常以 "ctl" 作为后缀，表示它们是用于控制系统服务的控制器。此外，在某些驱动程序中，CTL 可能代表 "control"，表示该驱动程序控制某个设备的操作。
station wlan0 scan
    
station wlan0 get-networks
    
station wlan0 connect [wifi名字] //这里有个小技巧，如果遇到中文乱码，可以打出前面的非中文字符，再按下Tab匹配
//接着输入密码
exit
    
ping baidu.com   //检查网络是否正常

timedatectl set-ntp true //开启ntp时间同步
    
timedatectl status

//p 查看布局
//n 新建分区
n
7  //这里给出为linux的交换分区给出空间的磁盘的序号
+4G //这里建立linux的交换分区，大小为4GB
n
//直接回车表示把剩余默认空间都给linux的根分区

mkfs.btrfs /dev/nvme...n...1  //将根目录分区格式化为btrfs文件系统
    
mkswap /dev/nvme...n...2 //对交换分区进行操作，mkswap命令用于在一个文件或者设备上建立交换分区。在建立完之后要使用sawpon命令开始使用这个交换区。最后一个选择性参数指定了交换区的大小，但是这个参数是为了向后兼容设置的，没有使用的必要，一般都将整个文件或者设备作为交换区。
swapon /dev/nvme...n...2