数据结构——顺序表删除练习

代码功能：
1. 删除顺序表中第一个值为x的元素
2. 删除顺序表中所有值为x的元素
3. 删除顺序表中下标为p的连续k个元素

函数说明：

1. 函数声明：PSeqList createNullList_seq(int m)
   函数功能：建立一个顺序表
   函数参数：m为申请结点的个数
   函数返回值：返回生成的线性表

2. 函数声明：int locate_seq(PSeqList palist, int x)
   函数功能：顺序表的查找
   函数参数：palist为需处理的顺序表，x为查找的元素
   函数返回值：元素存在则返回下标，不存在返回FALSE

3. 函数声明：int deleteV_seq(PSeqList palist, DataType x)
   函数功能：删除顺序表中第一个值为x的元素
   函数参数：palist为需处理的顺序表，x为欲删除元素
   函数返回值：删除成功返回1，失败返回0

4. 函数声明：int deletesV_seq(PSeqList palist, DataType x)
   函数功能：删除顺序表中所有值为x的元素
   函数参数：palist为需处理的顺序表，x为欲删除元素
   函数返回值：删除成功返回1，失败返回0

5. 函数声明：int deletesP_seq(PSeqList palist, int p, int k)
   函数功能：删除顺序表中下标为p的连续k个元素
   函数参数：palist为需处理的顺序表，p为欲删除元素下标，k为连续元素个数
   函数返回值：删除成功返回1，否则直接结束程序。

6. 函数声明：void print(PSeqList palist)
   函数功能：打印顺序表
   函数参数：palist为需处理的数据表
   函数返回值：无

#include
#include
#include 
#define FALSE 0
#define TRUE 1
typedef int DataType;

// 顺序表数据类型
struct SeqList
{
    int MAXNUM;  // 顺序表最大的容量
    int n;       // 顺序表中已有的元素个数
    DataType *element; // 真正存放元素的其实地址
};
typedef struct SeqList *PSeqList;


// 顺序表建立的算法，m为申请的结点个数
PSeqList createNullList_seq(int m)
{
    PSeqList palist = (PSeqList)malloc(sizeof(struct SeqList));
    if(palist != NULL)
    {
        palist->element = (DataType *)malloc(sizeof(DataType)*m);
        if(palist->element)
        {
            palist->MAXNUM = m;
            palist->n = 0;
            return(palist);
        }
        else
        {
            free(palist);
        }
    }
    printf("out of space!\n");
    return NULL;
}

// 顺序表的查找。存在返回下标，不存在返回FALSE
int locate_seq(PSeqList palist, int x)
{
    int q;
    for (q=0; qn; q++)
    {
        if (palist->element[q] == x)
        {
            return q;
        }
    }
    return FALSE;
}

// 删除顺序表中第一个值为x的元素
int deleteV_seq(PSeqList palist, DataType x)
{
    int p, q, flag=0;
    for(p=0; pn; p++)
    {
        q = locate_seq(palist, x);
        if (q)
        {
            flag = 1;
            deletesP_seq(palist, q, 1);
            break;
        }
    }
    if(flag == 0)
    {
        printf("元素不存在\n");
        return TRUE;
    }
    return FALSE;
}


// 删除顺序表中所有值为x的元素
int deletesV_seq(PSeqList palist, DataType x)
{
    int p, q, flag=0;
    for(p=0; pn; p++)
    {
        q = locate_seq(palist, x);
        if (q)
        {
            flag = 1;
            deletesP_seq(palist, q, 1);
        }
    }
    if(flag == 0)
    {
        printf("元素不存在\n");
        return FALSE;
    }

    return TRUE;
}


// 删除顺序表中下标为j的连续k个元素
int deletesP_seq(PSeqList palist, int p, int k)
{
    int q, i;

    if(p+k > palist->n)
    {
        printf("out of range\n");
        exit(0);
    }
    if(p == 0 && k == palist->n)
    {
        printf("顺序表被删空。\n");
        exit(0);
    }
    for(i=0; iif(p<0 || p > palist->n)
        {
            printf("Not exist!\n");
            exit(0);
        }
        for(q=p; qn-1; q++)
        {
            palist->element[q] = palist->element[q+1];
        }
        palist->n = palist->n-1;
    }
    return TRUE;
}


// 打印顺序表
void print(PSeqList palist)
{
    int i;
    for(i=0; in; i++)
        printf("%d\t", palist->element[i]);
    printf("\n");
}


int main()
{
    PSeqList lx_alist;
    int max,len,i,x,q;
    int temp;
    int j,k;

    printf("\n请输入线性表的最大长度值(<100)：");
    scanf("%d",&max);
    lx_alist = createNullList_seq(max);

    for(i=0; i<10; i++)
    {
        lx_alist->element[i] = i+3;
        lx_alist->n++;
    }
    printf("对数组赋初值：\n");
    printf("现在的顺序表为：\n");
    print(lx_alist);

    printf("\n修改其中一个元素的值：\n");
    lx_alist->element[3] = 9;
    printf("现在的顺序表为：\n");
    print(lx_alist);

    temp = 8;
    printf("\n删除第一个值为%d元素：\n", temp);
    deleteV_seq(lx_alist, temp);
    printf("现在的顺序表为：\n");
    print(lx_alist);

    temp = 9;
    printf("\n删除全部值为%d元素：\n", temp);
    deletesV_seq(lx_alist, temp);
    printf("现在的顺序表为：\n");
    print(lx_alist);

    temp = 0;
    k = 7;
    printf("\n删除下标为%d的连续%d个元素值：\n", temp, k);
    deletesP_seq(lx_alist, temp, k);
    printf("现在的顺序表为：\n");
    print(lx_alist);

    system("pause");
    return 0;
}