大学c语言《数据结构》考试这一篇就够了

//线性表——顺序表
//模板
           /* #define InitSize 100
            typedef struct  //有两个类型用结构 
            {   
                int  elem[InitSize];   //数组
                int length;                //可变的长度
            }SqList; */

//定一个多项式的系数和指数的线性表
#define MAXSIZE 1000
typedef struct 
{
    float p;  //系数
    int e;//指数
}Polynomial;
typedef struct 
{
    Polynomial *elem;  //存储空间基地址
    int length; // 多项式当前个数
}SqList;

图书管理

图书管理
#define MAXSIZE 10000
typedef struct 
{
    char NO[20];  //ISBN
    char name[50];//指数
    float price;//价格
}BOOK;
typedef struct 
{
    BOOK *elem;  //存储空间基地址
    int length; // 图书个数
}SqList;

动态分配

//动态分配
/*
 typedef struct 
{
    int *elem;  
    int length; 
}SqList;
SqList L;
L.data=(int*)malloc(sizeof(int)*MAXSIZE);

free(p)   指针类型变量*/

/*c++
int *p1=new int; //申请内存空间 以初值赋值
delete p1;
*/

链表

单链表的定义

//单链表的定义
//嵌套定义
typedef struct Londe
{
    int data;//数据域
    struct Londe *next;//指针域
    
}Lnode,*LinkList;//linklist 为指向结构体londe的指针类型

存储学生学号姓名成绩的单链表定义

//eg

//存储学生学号姓名成绩的单链表定义类型
typedef struct student
{
    char num[8];
    char name[8];
    int score;
    struct student*next;//指针域
   
}Londe,*LinkList;

另一种定义方法

//<=>通常使用这种定义方法
typedef struct 
{
    char num[8];
    char name[8];
    int score;
}ElemTpye;  //数据域
typedef struct Londe
{
    ElemTpye data;//数据域
    struct Londe *next;//指针域

}Londe,*LinkList;

单链表的初始化

//单链表的初始化
/* Status_InitList_l(LinkList &L){
    l=new LNode;//c++
    //c  l=(LinkList)malloc(sizeof(LNode));
    l->next=NULL;
    return OK;
} */

判断链表是否为空

//判断链表是否为空
//等价于判断指针域是否为空
int ListEmpty(LinkList L){
if(L->next)//非空有值
    return 0;
else    return 1;

}

单链表的销毁

//单链表的销毁
//等价于从头指针开始，依次释放所有结点
Status DestoryList_L(LinkList &L){
    Londe *p;//或者LinkList p;
    while(L){
        p=L;//指针p指向l的结点
        L=L->next;//将指针指向下一结点的地址
        delete p;
        }
    return OK;
}

清空链表

//清空链表
Status ClearList_L(LinkList &L){
    Londe *p,*q;//或者LinkList p,q;
    p=L->next;
    while (p)   //没到标尾
    {
        q=p->next;
        delete p;
        p=q;
    }
    L->next=NULL;//头节点指针域为空
    return OK;
}

求单链表表长

//求单链表表长   
//等价于统计除头节点外结点的数量
int ListLength_L(LinkList L){
LinkList p;
p=L->next;          //p指向第一个结点
int i=0;

while (p)            //遍历链表，统计个数
{
   i++;
   p=p->next; //下一个
}
return i;
}

取单链表中第i个元素的内容

//取单链表中第i个元素的内容
//1等价于 从第一个结点顺链扫描，用指针p指向当前扫描到的结点，p初值p=L->next
//2j做计数器 累计当前扫描过的结点数，j初值为1
//3 当p指向扫描到下一结点时，计数器j加一
//4 j==i时，p所指向的结点就是要找到的第一个结点
Status GetElem_L(LinkList L,int i,ElemTpye &e){
p=L->next;
int j=1;//初始化
while (p&&j<i)    //&&：逻辑与，前后条件同时满足表达式为真  ||：逻辑或，前后条件只要有一个满足表达式为真
{
    p=p->next;
    ++j;
}
if(!p||j>i)
return ERROR;
e=p->data;//取值
return  ok;

}

按值查找

//按值查找
Londe *LocateElem_L(LinkList L,ElemTpye e){
//查找为e的值，找到返回数据元素的   地址，
p=L->next;//指向首源节点
while (p&&p->data!=e)
   p=p->next;
   return p;
}

按值查找该数据位置序号

//按值查找并根据指定数据获取该数据的   位置序号
int LocateElem_L(LinkList L,ElemTpye e){
p=L->next;
j==1;
while (p&&p->data!=e)
{
    p=p->next;j++;

}
if(p)
return j;
else return 0;

}

插入——新节点

//插入——在i个结点前插入为e的新节点
Status ListInsert_L(LinkList &L,int i,ElemTpye e){
    p=L;j=0;
    while(p&&j<i-1){//寻找地i-1个结点
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
    return ERROR;//非法判断语句
    s=new Lnode; s->date=e;//生成新节点s
    
    s->next=p->next;//将结点s插入l  关键插入语句 
    p->next=s;
    
    return OK;

删除第i个结点

//删除第i个结点
Status deleteInsert_L(LinkList &L,int i,ElemTpye e){
    p=L;j=0;
    while(p&&j<i-1){//寻找地i-1个结点
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
    return ERROR;//非法判断语句
if(!p||j>i-1)
    return ERROR;    //非法判断语句
    q=p->next;  //用q暂存要删除的结点
    p->next=q->next;//指向下一结点
    e=q->data;    //保存删除结点的数据域
    delete q;  //释放q结点
    return OK;
}

头插法建立单链表

//头插法建立单链表
void CreateList_H(LinkList &L,int n){
    L=new LNode;
    L->next=NULL;//建立一个带头结点的单链表
for(i=n;i>0;i++)
{   p=new Londe;
    cin>>p->data;//c语言scanf(&p->data)//输入元素
   
    p->next=l->next;
    l->next=p;
}}

尾插法建立单链表


//尾插法建立单链表
//正位序输入n个元素插入
void CreatList_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;//c语言scanf(&p->data)//输入元素
        p->next=NULL;
        r->next=p;//插入到表尾
        r=p;//r指向新的尾结点}}

循环链表

//循环链表 带尾指针循环链表的合并
LinkList Connect(LinkList Ta,LinkList Tb){
//设Ta,Tb 都是非空的单循环链表 尾指针
p=Ta->net;//p存表头的结点
Ta->next=Tb->next->next;//tb表头连结ta表尾
delte Tb->next;
Tb->next=p;//修改指针
return b;
}

双向链表的插入

//双向链表的插入（循环双链表）
void LIstInsert_DUL(DULinkList &L,int i,Elem tpye e){
    //在带头节点的双向循环链表L中的第i个位置之前插入元素e
    if(!(p=GetElemP_Dul(L,i)))
            return ERROR;
            s=new DuLNode;
            s->date=e;
            s->prior=p->prior;
            p->priror->next=s;
            s->next=p;
            p->prior=s;
            return OK;
}

双向链表的删除

//双向链表的删除
void Delete_DUL(DULinkList &L,int i,ElemTpye e)
//a b c删b  p->piror->next=p->next    p->next->prior=p-prior;
    if(!(p=GetElemP_Dul(L,i)));
    return ERROR;//找到第i个节点，并用指针变量指向
    e=p->data;
    p->priror->next=p->next;//修改前驱结点的后继   p->prior存放前一结点的地址

    p->next->prior=p->prior;//修改后继结点的前驱
    free (p);
    return OK;}

example

线性表的合并

//线性表的合并
//La=(7,5,3,11),Lb=(2,6,3)分别表示两个集合ab，合成一个新的集合LA=(7,5,3,11,2,6)
//依次取出Lb的每个元素，如果a中没有则插入到a的La的最后
void union(List &La,List Lb){
    La_len=ListLength(La);
    Lb_len=ListLength(Lb);
    for(i=1;i<=Lb_len;i++){
        GetElem(Lb,i,e);
        if(!LocateElem(La,e))
            ListInsert(&La,++La_len,e);}}

有序表的合并

//有序表的合并--顺序表实现
//la=(1,7,8)  lb=(2,4,6,8,10,11) lc=(1,2,4,6,7,8,8,10,11)
//创建空表Lc
//依次从表中摘取元素值小的结点插入到Lc的表后，直到一个表为空
//继续将剩余表中的节点插入到lc的最后
void MergrList(SqList LA,SqList LB,SqList &LC){
pa=LA.elem;
pb=LB.elem;//指针分别指向两个表的第一个元素
LC.length.LA.length+LB.length;//新表长度为代合并两表长度之和
LC.elem=new ElemType[LC.length];//为合并后的新表分配数组空间
pc=Lc.elem;//指向新表的第一个元素
pa_last=LA.elem+LA.length-1;//指向lA的最后一个元素
pb_last=LB.elem+LB.length-1;//指向lB的最后一个元素
//准备工作
//加入lc
while (pa<=pa_last&&pb<=pb_last)//两表非空
{S
    if(*pa<=*pb)
    *pc++=*pa++;//依次摘取两表中较小的结点
        else *pc++=*pb++;

}
while (pa<=pa_last) *pc++=*pa++;//lb表到表尾，la中剩余元素加入lc
while (pb<=pb_last) *pc++=*pb++;//la表到表尾，lb中剩余元素加入lc

//时间复杂度为o(LIStLengeh(la)+LIStLength(Lb))
//空间复杂度o(LIStLengeh(la)+LIStLength(Lb))
}

两个多项式线性运算

//完成一元多项式的   两个多项式线性运算
//系数 转化成为两个线性表的线性运算 同此项对应相加


//稀疏多项式的运算——存在很多为零的项
//----顺序表
//每个多项式的项存储 系数和指数即可 两项看成整体看成线性表  egLA=（（7,0）,(3,1)）LB=((8,1),(22,7))
//创建新的数组c 
//从头遍历比较 系数相同则系数相加，指数不同将指数较小的复制到c

//------链表
typedef struct PNode{
    float coef;//系数
    int expn;//指数
    struct PNode *next;//指针域
}PNode,*Polunomial;
void CreatPOlyn(Polynomial &P,int n){
    P=new PNode;
    P->next=NULL;
    for(i=1;i<=n;i++){
        s=new PNode;
        cin>>s->coef>>s->expn;
        pre=P;
        q=p->next;
        while(q&&q->expn<s->expn){
            pre=q;
            q=q->next;
        }
        s->next=q;
        pre->next=s;
    }}

图书馆管理系统

//图书馆管理系统
//实现对图书的增删改查
//数据模型为线性表  or 链表
//选择方法：经常按序号查找用线性表   经常增删操作 链表
struct Book{
    char id[20];
    char name[500];
    int price;
};
//顺序表:
typedef struct{
    Book *elem;
    int length;
}Sqlist;
//链表
typedef struct LNode{
    Book data;
    struct LNode *next;
}LNode,*LinkList;

二、栈

顺序栈

顺序栈的实现

//顺序栈的实现
//表示
#define MASIZE 100
typedef struct{
    SElemType *base;//栈底指针
    SElemTPye *top;//栈顶指针
    int stacksize;//栈可用的最大容量
}SqStack;

栈初始化

//初始化
void InitStack(SqStack &S){
S.base=new SEemTpte[MAXSIZE];
//c:   S.base=(SELemtpye*)malloc(MAXSIZE*sizeof(SElemTpye));
if(!S.base) exit (OVERFLOW);//分配失败
S.top=S.base;//栈顶等于栈底指针
S.stacksize=MAXSIZE;
return OK;
}

栈判空

//判空
    vio  StackEmpty(SqStack S){
        if (S.top==S.base)
        return TRUE;
        else
        return FALSRE；
    }

求栈长

//求栈长
int StackLength(SqStck S){
    return S.top-S.base;
}

清空栈

//清空顺序栈
//top指向栈底相等就是空
void ClearStcak(SqStack S){
if(S.base)
S.top=S.base;
return OK;
}

销毁栈

//销毁顺序栈
void DsstoryStack(SqStack &S){
if(S.base){
    delete S.base;
    S.stacksize=0;
    S.base=S.top=NULL;
}
return OK;
}

入栈

//入栈
bool PUSH(SqStack &S,SElemTPye e){
if(S.top-s.base==s.stacksize)//判断是否满
    return ERROR;
*s.top=e;
*s.top++;//or *s.top++=e;

}

出栈

//出栈
bool POP(SqStack &S,SElemTPye &e){
if(S.top==S.base)//等价于if(StackEmpty(S))
    return ERROR;
e=*--S.top;
return OK;
}

链栈

链栈定义

//链栈定义

typedef struct StackNode{
    SELemTpye data;
    struct StackNode *next;
}StackNode,*LinkStack;

链栈初始化

//链栈初始化
void INitStack(LinkStack &s){
    S=NULL;
    return OK;
}

链栈判空

//链栈判空
void STackEmpty(LinkStack &S){
    if(s=NULL)return TRUE;
    else return FALSE;
}

入链栈

//链栈入栈
bool PUSH(SqStack &S,SElemTPye e){
    p=new Stacknode;
    p->data=e;  //新结点数据域为e
    p->nex=s;//新节点插入栈顶
    s=p;//修改栈顶指针
    return ok;   
}

出链栈

//链栈出栈
bool POP(SqStack &S,SElemTPye &e){
   if(s=NULL)
    return ERROR;
    e=S->data;  //删除的数据域暂存
    p=s;
    s=s->next;
    delete p;
    return ok;   
}

取栈顶

//取栈顶元素
void GETtop(LinkeStack S){
    if(s!=NULL)
    return S->data;
}

队列

顺序队列

队列顺序表示

//队列的顺序表示
#define MAXQSIZE 100
typedef struct{
    QElemType *base;//初始化动态分配空间
    int front;//头指针
    int rear;//
}SqQueue

队列初始化

//队列的初始化
void InitQueue)(sqQueue &Q){
    Q.nase=new QELemType[MAXQSIZE]//分配数组空间 0-MAXSIZE-1
    if(!Q.base) exit(OVERFLOW);//分配失败处理
    Q.front=Q.rear=0;//头指针尾指针置零
    return OK;
}

队列存储元素长度


//队列存储元素长度
int QLength(SqQueue Q){
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

循环入队

//循环入队
void 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;//队尾指针加一
    rerurn ok;
}

循环出队

//循环出队
void EnQueue(SqQueue &Q,QElemType &e){
    if(Q.rear==Q.front)
        return ERROR;//队空
    e=Q.base[Q.front];//存放在数组下标为队头的元素取出
    Q.front=(Q.front+1)%MAXSIZE;//队尾指针加一
    rerurn ok;
}

取队头元素

//取队头元素
vo  GetHead(SqQue Q){
    if(Q.front!=Q.rear){
        return Q.base[Q.front];//直接返回队头指针元素
        
    }
}

链队

链队列类型定义

//链队列类型定义
#define MAXSIZE 100
typedef struct  Qnode
{
    QElemType data;
    struct Qnode *next;//递归定义
}QNode,*Queneptr;
typedef struct 
{
    Queneptr front;//队头指针
    Queneptr rear;//队尾指针
}LinkQueue;

链队列初始化

//链队列初始化
void InitQueue(LinkeQueue &Q){
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNOde));
    if(!Q.front)
    exit(OVERFLOW);
    Q.front->next=NULL;
    return OK;
}

链队的销毁

//链队列的销毁
void DestoryQueue(LinkQueue &Q){

    while(Q.front){
        p=Q.front->next;
        free(Q.front);
        Q.front=p;
    }
return OK;
}

链队入队

//链队列入队
void insertQ(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;
}

链队出队

//链队列出队
void DeQ(LinkQueue &Q,ELemType &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;
delete p;
return ok;
}

第四章：串

顺序串

顺序串的顺序存储

#define MAXLEN 255
typedef struct{
    char ch[MAXLEN+1];//存储串的一维数组
    int length;//串当前的长度
}SString;

//BF暴力破解
int Index_BF(SString S,SString T){
    int i,j=1;
    while(i<=S.length&&j<=T.length{
        if(s.ch[i]==t.ch[j])
        {++i;++j;}//主串和字串依次匹配
            else{i=i-j+2;j++;}//主串和字串依次回溯，主串回到起始位置的下一位置
    if(j>=T.length)return i.T.length;//成功则返回匹配的第一个字符串的下标
    else return 0;
    })
}

第五章：树

二叉树的遍历和线索二叉树

先序遍历——递归

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

伪代码先序遍历

void Pre(BiTree *T){
    if(T!=NULL){
        print("%d\t",T->data);
        pre(T->lchild);
        pre(T->rchild);
    }
}

中序遍历

Status INOrderTraverse(BiTree T){
    if(T==NULL)
        return OK;//空二叉树
    else{
        INOrdertraverse(T->lchild);//递归遍历左子树
        visit(T);//访问根节点
        INOrderTraverse(T->rchild);//递归 遍历右子树
    }
}

后序遍历

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

非递归算法

Status InorderTraverse(BiTree T){
    BillTreep;
    InitStack(S);
    p=T;
    while (p||!StackEmpty(S))
    {
       if(p){Push(S,p);
       p=p->lchild;}
    }
        else{
            Pop(S,q);
            print("%c",q->data);
            p=q->rchild;
        }
    return OK;    
}

层次遍历

typedef struct{
    BTNode *p;
    SqQueue *qu;
    InitQueue(qu);//初始化队列
    enQueue(qu,b);//根节点指针进入
    while(!QueueEmpty(qu)){
        deQueue(qu,p);//出队结点p
        print("%c",p->data);//访问结点p
        if(p->lchild!=NULL)
        enQueue(qu,p->lchild);
        if(p->rchild!=NULL)
        enQueue(qu,p->rchild);//有右孩子时进队
    }
}

二叉树顺序读入字符

Status CreateBiTree(BiTree &T){
    scanf(&ch);//cin>>ch;
    if(ch=="#")T=NULL;
    else{
        if(!(T=(BiTNode*)malloc(sizeof(BiTNode))))
        exit(OVERFLOW);
        T->data=ch;
        createBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return OK;
}

复制二叉树

int Copy(BiTree T,BiTree &NewT){
    if(T==NULL){NewT=NULL;return 0;}
}
else{NewT=new BiTNode;
NewT->data=T->data;
Copy(T->lchild,NewT->lchild);
Copy(T->rchild,NewT->rchild);}}

计算二叉树的深度

int Depth(BiTree T){
    if(T==NULL)return 0;
    else{
        m=Depth(T->lchild);
        n=Depth(T->eChild);
        if(m>n)return (m+1);
        else return(n+1);
    }
}

计算二叉树结点总数

int NodeCount(BiTree T){
    if(T==NULL)
    return 0 ;
    else
    return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}

叶子结点数

int LeadCount(BiTree T){
    if(T==NULL)
    return 0;
    if(t->Lchild==NULL&&T->rchild==NULL)
    return 1;
    else
    return LeafCount(T->lchild)+LeafCount(T->rchild)+1;
}

哈夫曼树

哈夫曼树的构造

void CraetHuffmanTree(HuffmanTree HT,int n){
    if(n<=1)return ;
    m=2*n-1;//共2n-1个结点
    HT=new HTNode[m+1];//0号单元未使用
    for(i=1;i<=m;++i){
        HT[i].lch=0;HT[i].rch=0;HT[i].parent=0;
    }
    for(i=1;i<=n;i++) cin>>HT[i].weight;//输入前n个元素的weight值
    for(i=n+1;i<=m;i++){
        Select(HT,i-1,s1,s2);//选择两个权值最小的结点
        HT[s1].parent=i;
        HT[s2].parent=i;
        HT[i].lch=s1;
        HT[i].rch=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;
    }

}

第六章图

图的遍历

邻接矩阵表示图的深度优先遍历（DFS）

void DFS(AMGRaph G,int v){

cout<<v;
visited[v];//访问标记数组
for(w=0;w<G.vexnum;w++){//依次检查邻接矩阵v所在的行
    if((G.arcs[v][w]!=0)&&(!visited[w]))
    DFS(G,w);
    //w是v的邻接点，如果w没访问，递归调用DFS
}
}

广度优先非递归遍历连通图

void BFS(Graph G,int v){
    cout<<v;
    visited[v]=true;//访问第v个节点
    InitQueue(q);//辅助队列q初始化置空
    EnQueue(q,v);//v进队
    while(!QueueEmpty(Q)){
        DeQueue(q,u);
        for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
        if(!visited[w]){


            count<<w;visited[w]=true;
            EnQueue(Q,w);//w进队}
        }
    }
}

第七章查找

顺序查找

int Search_Seq(SSTable ST,keyType key){

    //若成功返回其信息位置，否则为0
    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
    for(i=ST.length;STR[i].key!=key;--i)
        if(i<=0)
           break;;
           if(i>0)return i;
    else return 0;
}

改进——设置监视哨的顺序查找

int Search_Sqe(SSTable ST,KeyType key){
    ST.R[0].key=key;
    for(i=ST.length;ST.R[i].key!=key;--i);
    return i;


}

折半查找

int Search_Bin(SSTable ST,keyType key){
    low=1;high=ST.length;
    while (low<=high)
    {
        mid=(low+high)/2;
        if(ST.R[mid].key==key)return mid;
        else if(key<ST.R[mid].key)
        high=mid-1;
        else low=mid+1;

    }
    return 0;
    
}

二叉排序树递归查找

BSTree SearchBST(BSTree T,KeyType key){
    if((!T)||key==T->data.key)return T;//t为空或者第一个就是要找到的
     else if(key<T->data.key)
    return SearchBST(T->lchild,key);//在左子树中继续查找
    else return SearchBST(T->rchild,key);//在右子树中继续查找
}

第八章插入

直接插入-哨兵法

viod InsertSort(SqList &L){
if(i=2;i<=L.length;i++){
    if(L.r[i].key<L.r[i-1].key){
        L.r[0]=L.r[i];
        for(j=j-1;L.r[0].key<L.r[j].key;--j){
            L.r[j+1]=L.r[j];
        }
        L.r[j+1]=L.r[0];
    }
}
}

折半查找排序

void BInsertSort(SqList &L){
    for(i=2;i<L.length;++i){
        Lr.[0]=Lr.[i];//当前插入元素存入到哨兵
        low=1;high=i-1;
        while(low<=high){
            mid=(low+high)/2;
            if(Lr.[0].key<Lr.[mid].key) high=mid-1;
            else low=mid+1;}
            for(j=i-1;j>=high+1;--j)
            Lr.[j+1]=L.r[j];
            Lr.[high+1]=Lr.[0];
        }
    }
}

希尔排序

void ShellSort (Sqlist &L,int dltap[],int t){
    for(k=0;k<t;++t)
    ShellInsert(L,dlta[k]);

}
void ShllInsert(SqList &L,int dk){
    for(i=dk+1;i<=L.length;++i)
    if(r[i].key<r[i-dk]){
        r[0]=r[i];
        for(j=i-dk;j>0&&(r[0].key<r[j].key);j=j-dk)
        r[j-dk]=r[j];
        r[j+dk]=r[0];

        
    }
}

冒泡排序

void buble_sort(Sqlist &L){
    int m,i,j;
    RedType x;
    for(m=1;m<=n-1;m++){
        for(j=1;j<=n-m;j++)
        if(L.r[j].key)>L.r[j+1].key{
            x=Lr.[j];L.r[j=lr[j+1];L.r[j+1]=x;]
                }        }
    }
}

快速排序算法

void main(){
    QSort(L,1,L.length);
}
void Qsort(SqList &L,int low,int high){
    if(low<high){
        //长度大于一
        pivotloc=Partition(L,low,high);
        //将L.r[low...high]一分为二，pivotloc为枢纽元素排好序的位置
        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=Lr.[low].key;
    while(low<high){
        while(low<high&&L.r[high].key>=pivotkey)
        --high;
        L.r[low]=L.r[high];
        whiel(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.lentgh;++i){
        k=i;
        for(k=i+1;j<=L.length;j++)
        if(L.r[j].key<L.r[k].key)l=j;//记录最小值位置
        if(k!=i)
        L.r[i]<-->L.r[k];//交换
    }
}

堆排序

void  HeapSort(elem R[]){
    int i;
    for(i=n/2;i>=1;i--)
    HeapAdjust(R,i,n);//建初始堆
    for(i=n;i>1;i--){
        Swap(R[1],R[i]);
        HeapAdjust(R,1,i-1);//对重新建堆
    }}