线性结构相关例题

主要代码部分
1.二分查找

Position BinarySearch( List L, ElementType X )//指针L里面数组有与查找的数X
{
    int l=1,r=L->Last;   //l为查询的最小下标，从1开始，r为最大下标
    while(l<=r)       //l小于等于r代表两者越界了，就代表没找到
    {
        if(L->Data[(l+r)/2] > X)        //取中间，如果大于要找到的值，最右边就往左移
        {
            r = (l+r)/2 - 1;
        }
        else if(L->Data[(l+r)/2] < X) //取中间，如果小于要找到的值，最左边就往右移
        {
            l = (l+r)/2 + 1;
        }
        else
        {
             return (l+r)/2;        //等于，就返回这个下标
        }
    }
    return NotFound;     //跳出来了，代表没找到
}

2.有序数组的插入

bool Insert( List L, ElementType X )
{
    if(L -> Last + 1 == 10) return false;          //如果插入后最大下标超过10，代表越界了
    for (int i = 0; i <= L -> Last; i ++ )     //通过最大下标的限制不断遍历数组下标
    {
        if (L -> Data[i] == X) return false;      //如果有相同的，就不需要插入了
        else if (L -> Data[i] < X)               //如果小于，代表找到，就找到插入的位置
        {
            for (int j = L ->Last; j >= i; j -- )  //从插入位置的数据全部从尾往后移动一位
            {
                L -> Data[j + 1] = L -> Data[j];
            }
            L -> Data[i] = X;      //插入位赋值
            L -> Last += 1;        //最大下标加一
            break;           
        }
        else if (i == L -> Last && L -> Data[i] > X)//到尾了
        {
            L -> Data[L -> Last + 1] = X;          //插入到最后新开的下标位
            L -> Last += 1;                         最大下标加一
            break;
        }
    }
    return true;         //这里都是代表通过break跳出来的，则是插入成功
}

3.有序链表的插入

List Insert( List L, ElementType X )
{
    List temp, pre,h;      //建立3个链表，用于转换数据
    h = pre = L;
    while(pre->Next != NULL && pre->Data < X)  
    {
        h = pre;               //h存前一个位置
        pre = pre->Next;       //pre存下一个位置，插入需要前后两个位置，从中间开一个位置
    }
    if(pre->Next!=NULL)                 //中间位置，正常情况
    {
        temp = (List)malloc(sizeof(struct Node));
        temp->Data = X;         //分配空间于对应赋值
        temp->Next = pre;      //该空间的尾指向尾
        h->Next = temp;       //前一个空间指向新建立的空间
    }
    else           //尾部
    {
        temp = (List)malloc(sizeof(struct Node));
        temp->Data = X;
        if(X > pre->Data)      //在尾部进行链接
        {
            pre->Next = temp;    //正常尾部操作
            temp->Next = NULL;
        }
        else
        {
            X = L->Data;
            L = temp;
            L->Next = temp;
            temp->Data = X;
            temp->Next = NULL;
        }
    }
    return L;
}

4.两个有序链表序列的合并

List Merge( List L1, List L2 )
{
    List A,B,temp;
    A = L1;     
    int t;
    while(A->Next)
    {
        A = A->Next;       //把A指到尾部，就是链表L1的尾部
    }
    A->Next = L2->Next;       //尾部指向下一个链表的头，连接两个链表
    A = L1;                   //A重新指向新的连接两个链表的一个链表
    for(;A!=NULL;A=A->Next)  //这里用的是冒泡法不断改变顺序
    {
        for(B=A;B!=NULL;B=B->Next)
        {
            if(B->Data <= A->Data )
            {
                t = B->Data;
                B->Data = A->Data;
                A->Data = t;
            }
        }
    }
    temp = (List)malloc(sizeof(struct Node)); //新建立一个空来取代L1
    temp->Data =L1->Data;
    temp->Next = L1->Next;
    L1->Next = NULL; //使原本的链表赋予空
    L2->Next = NULL;
    return temp;
}

5.线性表元素的区间删除

List Delete( List L, ElementType minD, ElementType maxD )
{
    List H = L;
    int sum = H->Last;
    for(int i=0;i<=H->Last;i++)        //这一步先找到位于该区间的值，把他们都赋予-1，sum对应的最大长度减一
    {
        if(H->Data[i]>minD &&H->Data[i]<maxD)
        {
            H->Data[i] = -1;
            sum--;
        }
    }
    //我们的思想是把不是-1的值继续按顺序存入，最后改变最大上限H->Last
    for(int i=0,j=0;i<=H->Last;i++)
    {
        if(H->Data[i]!=-1) //不是-1的值按存入
        {
            H->Data[j] = H->Data[i];
            j++;         //j++存入下一位
        }
    }
    H->Last = sum;
    return L;
}

6.求链表的倒数第m个元素

ElementType Find( List L, int m )
{
    List h = L;
    int len=0;
    while(h->Next!=NULL) //找链表长度
    {
        len++;
        h = h->Next;
    }
    m = len - m;   //转换为正序寻找
    if(m<0)       //m<0代表越界了
    {
        return ERROR;
    }
    len = 0;
    h = L;
    while(len <=m)   不断递归到倒数第m的位置
    {
        len++;
        h = h->Next;
    }
    return  h->Data;      //返回该位置的数据
}

7.队列的入队与出队

bool AddQ( Queue Q, ElementType X )  //入队
{
    if(Q->Count == Q->MaxSize )   //队列满了
    {
        printf("Queue Full\n");
        return false;
    }
    Q->Count++;            //数据存储个数加一
    Q->Data[(Q->Front + Q->Count) % Q->MaxSize] = X;    //队列的往返，虽然到尾部到了，头可能还有空间，就看最前坐标与最后坐标
}
ElementType DeleteQ( Queue Q )//出队
{
    if(Q->Count == 0)  //没有数据了
    {
        printf("Queue Empty\n");
        return ERROR;
    }
    Q->Count--;//数据存储个数减一
    Q->Front = (Q->Front+1) % Q->MaxSize; //减一首先肯定是尾下标操作，但是注意尾下标可能会跑到前面
    return Q->Data[Q->Front];//返回数据
}

8.堆栈的入栈与出栈

bool Push( Stack S, ElementType X)  //出
{
    if(S->Top == (S->MaxSize))  //满了
    {
        printf("Stack Full\n");
        return false;
    }
    else
    {
        S->Top++;      //栈顶加一
        S->Data[S->Top] = X;  //数据存入
        return true;
    }
}
ElementType Pop( Stack S ) //入
{
    int X;
     if(S->Top == 0)
    {
        printf("Stack Empty\n");  //没有数据了
        return ERROR;
    }
    else
    {
         X = S->Data[S->Top];    //先得到数据
         S->Top--;              //栈顶减一
         return X;
    }
}