数据结构从0起步代码实操

第一题：
要求：给定一个顺序存储的线性表，请设计一个函数删除所有值大于min而且小于max的元素。
删除后表中剩余元素保持顺序存储，并且相对位置不能改变。
L是用户传入的一个线性表，其中ElementType元素可以通过>、==、<进行比较；
minD和maxD分别为待删除元素的值域的下、上界。函数Delete应将Data[]中所有值大于minD而且小于
maxD的元素删除，同时保证表中剩余元素保持顺序存储，并且相对位置不变，最后返回删除后的表。

List Delete(List L,ElementType minD, ElementType maxD)
{
    int i=0,s=0;
    while(i<=L->Last)//循环，循环次数为链表L的长度
    {
        if(L->Data[i]>minD&&L->Data[i]<maxD)
        s++;//s起标志的作用，代表着下次找到符合要求的数时该节点要前移几位
        else
        L->Data[i-s]=L->Dtata[i];//第i个节点前面有几个不符合要求的数字i节点就前移几位
        i++;    
    }
    L->Last=L->Last-s;//重构链表删除掉不符合要求的数字
    return L; 
}

第二题：
要求：实现一个函数merge，将长度为m的升序数组a和长度为n的升序数组b合并到一个新的数组c，
合并后的数组仍然按升序排列。
输入包含两行。
第一行为有序数组a，其中第一个数为数组a的长度m，紧接着m个整数。
第二行为有序数组b，其中第一个数为数组b的长度n，紧接着n个整数。 

void merge(int* a, int m, int* b, int n, int* c)
{
    int aflag=0,bflag=0,cflag=0;//用来记录插入数据到数组中的第几个元素
    while(aflag<m&&bflag<n)
    {
        if(*(a+aflag)<*(b+bflag)) 
        {
            *(c+cflag)=*(a+aflag);//将较小的元素插入到数组c中
            aflag++;
            cflag++;
        }
        else
        {
            *(c+cflag)=*(b+bflag);//同上
            bflag++;
            cflag++;
        }
    }
    while(aflag<m)//若a中元素未插入完，则继续插入c数组
    {
        *(c+cflag)=*(a+aflag);
        aflag++;
        cflag++;
    }
    while(bflag<n)//若b中元素未插入完，则继续插入c数组
    {
        *(c+cflag)=*(b+bflag);
        bflag++;
        cflag++;
    }
}

第三题：
本题要求实现顺序表的操作集
各个操作函数的定义为：

List MakeEmpty()：创建并返回一个空的线性表；

Position Find( List L, ElementType X )：返回线性表中X的位置。若找不到则返回ERROR；

bool Insert( List L, ElementType X, Position P )：将X插入在位置P并返回true。若空间已满，
则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ILLEGAL POSITION”并返回false；

bool Delete( List L, Position P )：将位置P的元素删除并返回true。若参数P指向非法位置，
则打印“POSITION P EMPTY”（其中P是参数值）并返回false。

List MakeEmpty()
{
    List L=(List)malloc(sizeof(struct LNode));//为链表分配空间
    L->Last=-1;//空链表，L->last指向-1，它的值跟Ax（a0，a1）等下标一致
    return L;
    
}
Position Find( List L, ElementType X )
{
    for(int i=0;i<=L->Last;i++)
    {
        if(X==L->Data[i]) //比较
              return i;
    }
    return ERROR;
}
bool Insert( List L, ElementType X, Position P )
{
    if(L->Last==MAXSIZE-1)//当链表长度已经等于MAXSIZE时再插入下一个元素会输出FULL并false
    {
        printf("FULL");
        return false;
    }
    if(P<0||P>L->Last+1)//判断插入位置是否合法
    {
        printf("ILLEGAL POSITION");
        return false;
    }
    for(int i=L->Last+1;i>P;i--)//将P后的元素都向后移一位为X腾出位置
    {
        L->Data[i]=L->Data[i-1];
        
    }
    L->Data[P]=X;//插入X在位置P
    L->Last++;
    return true;
}
bool Delete( List L, Position P )
{
    if(P<0||P>L->Last)//判断删除位置是否合法
    {
        printf("POSITION %d EMPTY",P);
        return false;
    }
    for(int i=P;i<L->Last;i++)//从位置P开始后一个元素覆盖前一个
    {
        L->Data[i]=L->Data[i+1];
    }
    L->Last--;//链表长度-1
    return true;
}

第四题
要求：本题实现一个函数，在递增的整数序列链表（带头结点）中插入一个新整数，并保持该序列的有序性。
L是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Insert要将X插入L，
并保持该序列的有序性，返回插入后的链表头指针。

List Insert( List L, ElementType X )
{
    List head=L;//定义头节点
    L=L->Next;//L指向第一个节点
    
    List p=(List)malloc(sizeof(struct Node));//开辟要插入的节点P
    p->Data=X;//定义p数据域
    p->Next=NULL;//定义p指针域
    List q=head;//定义一个新的节点Q同HEAD
    
    if(L==NULL)//空链表
    {
        head->Next=p;//直接将P当头节点
        return head; 
    } 
    while(L->Data<X)//比较大小，保证递增
    {
        q=L;//若不满足则q向后移
        L=L->Next;//L也向后移动一位
        if(L->Next==NULL)//若移动到表尾证明要插入到表尾
        {
            L->Next=p;
            return head;
        }
         
    }//插入p到表中
                q->Next=p;//设定p的前一个结点
     p->Next=L;//P的后一个节点
    return head; //保证头节点不变
}