数据结构

该程序是动态创建的顺序表。完成删除元素的函数（DeleteList），该删除函数删除该顺序表的第k个（k介于1~N）元素。若k值不合法显示删除不合法。

顺序表删除位置1.jpg

顺序表删除位置2.jpg

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int DeleteList(pSeqList L, int pos);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n, pos;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, 2 * (i + 1), i + 1);
	}

	printf("输入需要删除的元素位置:");
	scanf("%d", &pos);
	if (DeleteList(&L, pos) > 0)
	{
		output(L);
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

/******start******/

		printf("删除位置不合法!\n");

/******end******/

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int DeleteList(pSeqList L, int pos);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n, pos;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, 2 * (i + 1), i + 1);
	}

	printf("输入需要删除的元素位置:");
	scanf("%d", &pos);
	if (DeleteList(&L, pos) > 0)
	{
		output(L);
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

/******start******/
int DeleteList(pSeqList L, int pos){
    if (pos < 1 || pos > L -> length ){
        printf("删除位置不合法!\n");
return -1;
    }

    for (int i = pos; i < L -> length; i++){
        L -> elem[i - 1] = L -> elem[i];
    }
    L -> length--;
    return 1;
}

/******end******/

已有顺序表s、t，将顺序表s在顺序表t中出现的最后1个数据值及位置下标返回输出。

图中第1行的5，第4行的5，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq s, Seq t, int *value, int *position){
    int flag = 0;
    for (int i = 0; i < s.length; ++i) {
        for (int j = 0; j < t.length; ++j) {
            if (t.data[j]==s.data[i]){
                flag = 1;
                *value = s.data[i];
                *position = i;
            }
        }
    }
    if (flag == 1) {
        return 1;        
    }
}
/******end******/

已有顺序表s、t，将顺序表s在顺序表t中未出现的第1个数据值及位置下标返回输出。

图中第1行的5，第4行的5，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq s, Seq t, int *value, int *position) {
    int j;
    for (int i = 0; i < s.length; ++i) {
        for (j = 0; j < t.length; ++j) {
            if (t.data[j] == s.data[i]) {
                break;
            }
        }
        if (j == t.length) {
            *value = s.data[i];
            *position = i;
            return 1;
        }
    }
}
/******end******/

该程序是一个动态分配内存的线性顺序表。请补充完整构造该顺序表的函数（InitList）。

顺序表结构声明.jpg

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);		//构造存储量为listsize的顺序表
int InsertList(pSeqList L, int x, int position);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		InsertList(&L, i + 1, i + 1);
	}
	output(L);
	Destroy(&L);
	return 0;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);		//构造存储量为listsize的顺序表
int InsertList(pSeqList L, int x, int position);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		InsertList(&L, i + 1, i + 1);
	}
	output(L);
	Destroy(&L);
	return 0;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

/******start******/
int InitList(pSeqList L, int listsize){
    L->elem = malloc(listsize * sizeof(int));
	L->length = 0;
    return 1;
}
/******end******/

该程序功能：初始化线性顺序表，在顺序表中插入元素。

完成该程序的插入元素操作。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n, temp, pos, flag;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	printf("输入插入到顺序表的元素值及其位置:");
	for (i = 0; i < n; i++)
	{
		scanf("%d%d", &temp, &pos);
		flag = InsertList(&L, temp, pos);		//将temp插入到顺序表第pos个元素之前
		if (flag == -1)	
		{
			printf("output:\n在顺序表中插入元素的位置非法\n");
			return 0;
		}
		if (flag == -2)
		{
			printf("output:\n该线性顺序表已满，无法再插入元素\n");
			return 0;
		}
	}
	output(L);
	Destroy(&L);
	return 0;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n, temp, pos, flag;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	printf("输入插入到顺序表的元素值及其位置:");
	for (i = 0; i < n; i++)
	{
		scanf("%d%d", &temp, &pos);
		flag = InsertList(&L, temp, pos);		//将temp插入到顺序表第pos个元素之前
		if (flag == -1)	
		{
			printf("output:\n在顺序表中插入元素的位置非法\n");
			return 0;
		}
		if (flag == -2)
		{
			printf("output:\n该线性顺序表已满，无法再插入元素\n");
			return 0;
		}
	}
	output(L);
	Destroy(&L);
	return 0;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

/******start******/
int InsertList(pSeqList L, int x, int position) {
    int i;

    if (position < 1 || position > L->length + 1) {
        return -1;
    }
    if (L->length >= L->listsize) {
        return -2;
    }
    for (i = L->length; i >= position; i--) {
        L->elem[i] = L->elem[i - 1];
    }
    L->elem[i] = x;
    L->length += 1;
    return 1;
}
/******end******/

已有顺序表la，将la中是k倍数的元素全部删除。

图中第1行的10，第4行的3，第2行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
void function(Seq *la, int k);

int main(void)
{
	int n;
	int k;
	Seq la = {0};

	if (initseq(&la) <= 0)
	{
		return 0;
	}

	printf("Input la's number:");
	scanf("%d", &n);
	create(&la, n);
	printf("la: ");
	output(la);

	//删除k的倍数元素
	printf("Input k:");
	scanf("%d", &k);

	function(&la, k);

	printf("Output:\n");
	printf("la: ");
	output(la);
	destroy(la);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
void function(Seq *la, int k);

int main(void)
{
	int n;
	int k;
	Seq la = {0};

	if (initseq(&la) <= 0)
	{
		return 0;
	}

	printf("Input la's number:");
	scanf("%d", &n);
	create(&la, n);
	printf("la: ");
	output(la);

	//删除k的倍数元素
	printf("Input k:");
	scanf("%d", &k);

	function(&la, k);

	printf("Output:\n");
	printf("la: ");
	output(la);
	destroy(la);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
void function(Seq *la, int k) {
    int i, j;

    for (i = 0, j = 0; i < la->length; i++) {
        la->data[j] = la->data[i];
        if (la->data[i] % k != 0) {
            j++;
        }
    }
    la->length = j;
}
/******end******/

该程序为动态分配内存的顺序表。完成函数FindList查找第k个位置的元素（k介于1~N）。

顺序表查找位置值1.jpg

顺序表查找位置值2.jpg

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int FindList(pSeqList L, int pos, int *value);
int Destroy(pSeqList);
void output(SeqList L);
int prime(int n);

int main(void)
{
	int i, n, pos, value;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, prime(i + 1), i + 1);
	}
	output(L);

	printf("输入顺序表的位置:");
	scanf("%d", &pos);
	if (FindList(&L, pos, &value) > 0)
	{
		printf("该顺序表第%d个位置的元素是%d\n", pos, value);
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int prime(int n)
{
	int i, j;
	int cnt;
	if (n == 1)
	{
		return 2;
	}
	else if (n == 2)
	{
		return 3;
	}

	cnt = 2;
	for (i = 5; ; i++)
	{
		for (j = 2; j < i / 2 ; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (j >= i / 2)
		{
			cnt++;
			if (cnt == n)
			{
				return i;
			}
		}
	}
	return 0;
}

/******start******/

		printf("位置不合法!\n");

/******end******/

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int FindList(pSeqList L, int pos, int *value);
int Destroy(pSeqList);
void output(SeqList L);
int prime(int n);

int main(void)
{
	int i, n, pos, value;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, prime(i + 1), i + 1);
	}
	output(L);

	printf("输入顺序表的位置:");
	scanf("%d", &pos);
	if (FindList(&L, pos, &value) > 0)
	{
		printf("该顺序表第%d个位置的元素是%d\n", pos, value);
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int prime(int n)
{
	int i, j;
	int cnt;
	if (n == 1)
	{
		return 2;
	}
	else if (n == 2)
	{
		return 3;
	}

	cnt = 2;
	for (i = 5; ; i++)
	{
		for (j = 2; j < i / 2 ; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (j >= i / 2)
		{
			cnt++;
			if (cnt == n)
			{
				return i;
			}
		}
	}
	return 0;
}

/******start******/

int FindList(pSeqList L, int pos, int *value) {
    if (pos < 1 || pos > L->length) {
        printf("位置不合法!\n");
        return -1;
    }
    *value = L->elem[pos - 1];
    return 1;
}

/******end******/

将两个存放一元多项的顺序表one、two求和，存放在three顺序表。

图中第1行的3，第4行的3，第2行，第5行是键盘输入。

注：创建一元多项顺序表输入格式：系数指数系数指数系数指数……，要求指数是升序。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef struct _term
{
	int coefficient;
	int exponent;
} elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int insert(Seq *three, elemtype data);
int check(Seq list);
int function(Seq one, Seq two, Seq *three);

int main(void)
{
	int n;

	Seq one = {0}, two = {0}, three = {0};

	if (initseq(&one) <= 0)
	{
		return 0;
	}
	if (initseq(&two) <= 0)
	{
		destroy(one);
		return 0;
	}
	if (initseq(&three) <= 0)
	{
		destroy(one);
		destroy(two);
		return 0;
	}
	printf("Input one's number:");
	scanf("%d", &n);
	create(&one, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("one: ");
	output(one);

	printf("Input two's number:");
	scanf("%d", &n);
	create(&two, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("two: ");
	output(two);

	if (function(one, two, &three) == 1)
	{
		printf("Output:\n");
		printf("Result is: ");
		output(three);

		destroy(one);
		destroy(two);
		destroy(three);
	}
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d%d", &temp.coefficient, &temp.exponent);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length - 1; i++)
	{
		printf("%d*X^%d + ", list.data[i].coefficient, list.data[i].exponent);
	}
	printf("%d*X^%d", list.data[i].coefficient, list.data[i].exponent);
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

int insert(Seq *three, elemtype data)
{
	if (three->length == LISTSIZE)
	{
		return -1;
	}
	three->data[three->length] = data;
	three->length++;
	return 1;
}

int check(Seq list)
{
	int i;

	for (i = 0; i < list.length - 1; i++)
	{
		if (list.data[i].exponent >= list.data[i+1].exponent)
		{
			return -1;
		}
	}
	return 1;
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef struct _term
{
	int coefficient;
	int exponent;
} elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int insert(Seq *three, elemtype data);
int check(Seq list);
int function(Seq one, Seq two, Seq *three);

int main(void)
{
	int n;

	Seq one = {0}, two = {0}, three = {0};

	if (initseq(&one) <= 0)
	{
		return 0;
	}
	if (initseq(&two) <= 0)
	{
		destroy(one);
		return 0;
	}
	if (initseq(&three) <= 0)
	{
		destroy(one);
		destroy(two);
		return 0;
	}
	printf("Input one's number:");
	scanf("%d", &n);
	create(&one, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("one: ");
	output(one);

	printf("Input two's number:");
	scanf("%d", &n);
	create(&two, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("two: ");
	output(two);

	if (function(one, two, &three) == 1)
	{
		printf("Output:\n");
		printf("Result is: ");
		output(three);

		destroy(one);
		destroy(two);
		destroy(three);
	}
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d%d", &temp.coefficient, &temp.exponent);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length - 1; i++)
	{
		printf("%d*X^%d + ", list.data[i].coefficient, list.data[i].exponent);
	}
	printf("%d*X^%d", list.data[i].coefficient, list.data[i].exponent);
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

int insert(Seq *three, elemtype data)
{
	if (three->length == LISTSIZE)
	{
		return -1;
	}
	three->data[three->length] = data;
	three->length++;
	return 1;
}

int check(Seq list)
{
	int i;

	for (i = 0; i < list.length - 1; i++)
	{
		if (list.data[i].exponent >= list.data[i+1].exponent)
		{
			return -1;
		}
	}
	return 1;
}

/******start******/
int function(Seq one, Seq two, Seq *three) {
    int i = 0, j = 0;

    while (i < one.length && j < two.length) {
        if (one.data[i].exponent < two.data[j].exponent) {
            if (insert(three, one.data[i]) < 0) {
                return -1;
            }
            i++;
        } else if (one.data[i].exponent > two.data[j].exponent) {
            if (insert(three, two.data[j]) < 0) {
                return -1;
            }
            j++;
        } else {
            one.data[i].coefficient += two.data[j].coefficient;
            if (one.data[i].coefficient != 0) {
                if (insert(three, one.data[i]) < 0) {
                    return -1;
                }
            }
            i++;
            j++;
        }
    }

    if (i < one.length) {
        while (i < one.length) {
            if (insert(three, one.data[i]) < 0) {
                return -1;
            }
            i++;
        }
    } else {
        while (j < two.length) {
            if (insert(three, two.data[j]) < 0) {
                return -1;
            }
            j++;
        }
    }
    return 1;
}
/******end******/

将两个存放一元多项的顺序表one、two求积，存放在three顺序表。

图中第1行的3，第4行的3，第2行，第5行是键盘输入。

注：创建一元多项顺序表输入格式：系数指数系数指数系数指数……，要求指数是升序。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef struct _term
{
	int coefficient;
	int exponent;
} elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int insert(Seq *list, elemtype data);
int merge(Seq *list, elemtype data);
int find(Seq list, elemtype data);
int check(Seq list);
int function(Seq one, Seq two, Seq *three);

int main(void)
{
	int n;

	Seq one = {0}, two = {0}, three = {0};

	if (initseq(&one) <= 0)
	{
		return 0;
	}
	if (initseq(&two) <= 0)
	{
		destroy(one);
		return 0;
	}
	if (initseq(&three) <= 0)
	{
		destroy(one);
		destroy(two);
		return 0;
	}
	printf("Input one's number:");
	scanf("%d", &n);
	create(&one, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("one: ");
	output(one);

	printf("Input two's number:");
	scanf("%d", &n);
	create(&two, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("two: ");
	output(two);

	if (function(one, two, &three) == 1)
	{
		printf("Output:\n");
		printf("Result is: ");
		output(three);
	}
	else
	{
		printf("Program Error!\n");
	}
	destroy(one);
	destroy(two);
	destroy(three);
	
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d%d", &temp.coefficient, &temp.exponent);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length - 1; i++)
	{
		printf("%d*X^%d + ", list.data[i].coefficient, list.data[i].exponent);
	}
	printf("%d*X^%d", list.data[i].coefficient, list.data[i].exponent);
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

int insert(Seq *list, elemtype data)
{
	int i;
	if (list->length == LISTSIZE)
	{
		return -1;
	}

	for (i = list->length - 1; i >= 0; i--)
	{
		if (list->data[i].exponent > data.exponent)
		{
			list->data[i + 1]  = list->data[i];
		}
		else if (list->data[i].exponent == data.exponent)
		{
			return -2;
		}
		else
		{
			break;
		}
	}
	
	list->data[i + 1] = data;
	list->length++;
	return 1;
}

int merge(Seq *list, elemtype data)
{
	int i, j;
	for (i = 0; i < list->length; i++)
	{
		if (list->data[i].exponent == data.exponent)
		{
			list->data[i].coefficient += data.coefficient;
			if (list->data[i].coefficient == 0)
			{
				for (j = i; j < list->length - 1; j++)
				{
					list->data[j] = list->data[j + 1];
				}
				list->length--;
			}
			return 1;
		}
	}
	return -1;
}

int find(Seq list, elemtype data)
{
	int i;

	for (i = 0; i < list.length; i++)
	{
		if (list.data[i].exponent == data.exponent)
		{
			return 1;
		}
	}
	return 0;
}

int check(Seq list)
{
	int i;

	for (i = 0; i < list.length - 1; i++)
	{
		if (list.data[i].exponent >= list.data[i+1].exponent)
		{
			return -1;
		}
	}
	return 1;
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef struct _term
{
	int coefficient;
	int exponent;
} elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int insert(Seq *list, elemtype data);
int merge(Seq *list, elemtype data);
int find(Seq list, elemtype data);
int check(Seq list);
int function(Seq one, Seq two, Seq *three);

int main(void)
{
	int n;

	Seq one = {0}, two = {0}, three = {0};

	if (initseq(&one) <= 0)
	{
		return 0;
	}
	if (initseq(&two) <= 0)
	{
		destroy(one);
		return 0;
	}
	if (initseq(&three) <= 0)
	{
		destroy(one);
		destroy(two);
		return 0;
	}
	printf("Input one's number:");
	scanf("%d", &n);
	create(&one, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("one: ");
	output(one);

	printf("Input two's number:");
	scanf("%d", &n);
	create(&two, n);
	if (check(one) < 0)
	{ 
		destroy(one);
		destroy(two);
		destroy(three);
		return 0;
	}
	printf("two: ");
	output(two);

	if (function(one, two, &three) == 1)
	{
		printf("Output:\n");
		printf("Result is: ");
		output(three);
	}
	else
	{
		printf("Program Error!\n");
	}
	destroy(one);
	destroy(two);
	destroy(three);
	
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d%d", &temp.coefficient, &temp.exponent);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length - 1; i++)
	{
		printf("%d*X^%d + ", list.data[i].coefficient, list.data[i].exponent);
	}
	printf("%d*X^%d", list.data[i].coefficient, list.data[i].exponent);
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

int insert(Seq *list, elemtype data)
{
	int i;
	if (list->length == LISTSIZE)
	{
		return -1;
	}

	for (i = list->length - 1; i >= 0; i--)
	{
		if (list->data[i].exponent > data.exponent)
		{
			list->data[i + 1]  = list->data[i];
		}
		else if (list->data[i].exponent == data.exponent)
		{
			return -2;
		}
		else
		{
			break;
		}
	}
	
	list->data[i + 1] = data;
	list->length++;
	return 1;
}

int merge(Seq *list, elemtype data)
{
	int i, j;
	for (i = 0; i < list->length; i++)
	{
		if (list->data[i].exponent == data.exponent)
		{
			list->data[i].coefficient += data.coefficient;
			if (list->data[i].coefficient == 0)
			{
				for (j = i; j < list->length - 1; j++)
				{
					list->data[j] = list->data[j + 1];
				}
				list->length--;
			}
			return 1;
		}
	}
	return -1;
}

int find(Seq list, elemtype data)
{
	int i;

	for (i = 0; i < list.length; i++)
	{
		if (list.data[i].exponent == data.exponent)
		{
			return 1;
		}
	}
	return 0;
}

int check(Seq list)
{
	int i;

	for (i = 0; i < list.length - 1; i++)
	{
		if (list.data[i].exponent >= list.data[i+1].exponent)
		{
			return -1;
		}
	}
	return 1;
}

/******start******/
int function(Seq one, Seq two, Seq *three) {
    int i, j;
    elemtype temp;

    for (i = 0; i < one.length; i++) {
        for (j = 0; j < two.length; j++) {
            temp.coefficient = one.data[i].coefficient * two.data[j].coefficient;
            temp.exponent = one.data[i].exponent + two.data[j].exponent;
            if (find(*three, temp) == 1) {
                if (merge(three, temp) < 0) {
                    return -1;
                }
            } else {
                if (insert(three, temp) < 0) {
                    return -1;
                }
            }
        }
    }
    return 1;
}
/******end******/

已有顺序表s、t，将顺序表s在顺序表t中未出现的元素个数返回输出。

图中第1行的5，第4行的5，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t);

int main(void)
{
	int n;
	int cnt;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	cnt = function(s, t);
	printf("Output:\n");
	printf("Result: %d\n", cnt);

	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t);

int main(void)
{
	int n;
	int cnt;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	cnt = function(s, t);
	printf("Output:\n");
	printf("Result: %d\n", cnt);

	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq s, Seq t) {
    int i, j;
    int cnt = 0;

    for (i = 0; i < s.length; i++) {
        for (j = 0; j < t.length; j++) {
            if (s.data[i] == t.data[j]) {
                break;
            }
        }
        if (j == t.length) {
            cnt++;
        }
    }
    return cnt;
}
/******end******/

该程序是动态分配空间的线性顺序表。完成删除值为value的函数（DeleteList）。

顺序表删除x值1.jpg

顺序表删除x值2.jpg

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;
 
int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int DeleteList(pSeqList L, int value);
int Destroy(pSeqList);
void output(SeqList L);
int prime(int n);

int main(void)
{
	int i, n, value;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, prime(i + 1), i + 1);
	}

	printf("输入需要删除的元素值:");
	scanf("%d", &value);
	if (DeleteList(&L, value) > 0)
	{
		output(L);
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int prime(int n)
{
	int i, j;
	int cnt = 0;
	for (i = 2; ; i++)
	{
		for (j = 2; j < i / 2 ; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (j >= i / 2)
		{
			cnt++;
			if (cnt == n)
			{
				return i;
			}
		}
	}
	return 0;
}

/******start******/

	printf("删除的元素不存在!\n");

/******end******/

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;
 
int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int DeleteList(pSeqList L, int value);
int Destroy(pSeqList);
void output(SeqList L);
int prime(int n);

int main(void)
{
	int i, n, value;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, prime(i + 1), i + 1);
	}

	printf("输入需要删除的元素值:");
	scanf("%d", &value);
	if (DeleteList(&L, value) > 0)
	{
		output(L);
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int prime(int n)
{
	int i, j;
	int cnt = 0;
	for (i = 2; ; i++)
	{
		for (j = 2; j < i / 2 ; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (j >= i / 2)
		{
			cnt++;
			if (cnt == n)
			{
				return i;
			}
		}
	}
	return 0;
}

/******start******/

int DeleteList(pSeqList L, int value) {
    int i, j;

    for (i = 0; i < L->length; i++) {
        if (L->elem[i] == value) {
            for (j = i; j < L->length - 1; j++) {
                L->elem[j] = L->elem[j + 1];
            }
            L->length -= 1;
            return 1;
        }
    }
    printf("删除的元素不存在!\n");
    return -1;
}

/******end******/

该程序是一个动态分配内存构造的线性顺序表。请补充完整该顺序表的结构声明以及相关类型声明。顺序表结构声明.jpg

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

/******start******/

/******end******/

int InitList(pSeqList L, int listsize);		//构造存储量为listsize的顺序表
int InsertList(pSeqList L, int x, int position);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		InsertList(&L, i + 1, i + 1);
	}
	output(L);
	Destroy(&L);
	return 0;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

#include <stdio.h>
#include <stdlib.h>

/******start******/
typedef struct _SeqList {
    int *elem;
    int length;
    int listsize;
} SeqList, *pSeqList;
/******end******/

int InitList(pSeqList L, int listsize);		//构造存储量为listsize的顺序表
int InsertList(pSeqList L, int x, int position);
int Destroy(pSeqList);
void output(SeqList L);

int main(void)
{
	int i, n;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		InsertList(&L, i + 1, i + 1);
	}
	output(L);
	Destroy(&L);
	return 0;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

已有顺序表s、t，将顺序表s在顺序表t中出现的元素个数返回输出。

图中第1行的5，第4行的5，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t);

int main(void)
{
	int n;
	int cnt;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	cnt = function(s, t);
	printf("Output:\n");
	printf("Result: %d\n", cnt);

	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t);

int main(void)
{
	int n;
	int cnt;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	cnt = function(s, t);
	printf("Output:\n");
	printf("Result: %d\n", cnt);

	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq s, Seq t) {
    int i, j;
    int cnt = 0;

    for (i = 0; i < s.length; i++) {
        for (j = 0; j < t.length; j++) {
            if (s.data[i] == t.data[j]) {
                cnt++;
                break;
            }
        }
    }
    return cnt;
}
/******end******/

已有顺序表s、t，将顺序表s在顺序表t中出现的第1个数据值及位置下标返回输出。

图中第1行的5，第4行的5，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq s, Seq t, int *value, int *position) {
    int i, j;

    for (i = 0; i < s.length; i++) {
        for (j = 0; j < t.length; j++) {
            if (s.data[i] == t.data[j]) {
                *value = s.data[i];
                *position = i;
                return 1;
            }
        }
    }
    return 0;
}
/******end******/

已有顺序表la、lb，将lb中再现的元素从la中全部删除。

图中第1行的8，第4行的3，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
void function(Seq *la, Seq lb);

int main(void)
{
	int n;
	Seq la = {0}, lb = {0};

	if (initseq(&la) <= 0)
	{
		return 0;
	}
	if (initseq(&lb) <= 0)
	{
		destroy(la);
		return 0;
	}

	printf("Input la's number:");
	scanf("%d", &n);
	create(&la, n);
	printf("la: ");
	output(la);

	printf("Input lb's number:");
	scanf("%d", &n);
	create(&lb, n);
	printf("lb: ");
	output(lb);

	function(&la, lb);

	printf("Output:\n");
	printf("la: ");
	output(la);
	printf("lb: ");
	output(lb);
	destroy(la);
	destroy(lb);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
void function(Seq *la, Seq lb);

int main(void)
{
	int n;
	Seq la = {0}, lb = {0};

	if (initseq(&la) <= 0)
	{
		return 0;
	}
	if (initseq(&lb) <= 0)
	{
		destroy(la);
		return 0;
	}

	printf("Input la's number:");
	scanf("%d", &n);
	create(&la, n);
	printf("la: ");
	output(la);

	printf("Input lb's number:");
	scanf("%d", &n);
	create(&lb, n);
	printf("lb: ");
	output(lb);

	function(&la, lb);

	printf("Output:\n");
	printf("la: ");
	output(la);
	printf("lb: ");
	output(lb);
	destroy(la);
	destroy(lb);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
void function(Seq *la, Seq lb) {
    int i, j, k;

    for (i = 0; i < lb.length; i++) {
        for (j = 0; j < la->length; j++) {
            if (la->data[j] == lb.data[i]) {
                break;
            }
        }

        if (j < la->length) {
            for (k = j; k < la->length - 1; k++) {
                la->data[k] = la->data[k + 1];
            }
            la->length--;
            i--;
        }
    }
}
/******end******/

已有顺序表s、t，将顺序表s在顺序表t中未出现的最后1个数据值及位置下标返回输出。

图中第1行的5，第4行的5，第2行，第5行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq s, Seq t, int *value, int *position);

int main(void)
{
	int n;
	int value, position;

	Seq s = {0}, t = {0};

	if (initseq(&s) <= 0)
	{
		return 0;
	}
	if (initseq(&t) <= 0)
	{
		destroy(s);
		return 0;
	}

	printf("Input s's number:");
	scanf("%d", &n);
	create(&s, n);
	printf("s: ");
	output(s);

	printf("Input t's number:");
	scanf("%d", &n);
	create(&t, n);
	printf("t: ");
	output(t);

	printf("Output:\n");
	if (function(s, t, &value, &position) == 1)
	{
		printf("Result Value: %d, Position: %d\n", value, position);
	}
	else
	{
		printf("Not Find!\n");
	}
	destroy(s);
	destroy(t);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq s, Seq t, int *value, int *position) {
    int i, j;

    for (i = s.length - 1; i >= 0; i--) {
        for (j = 0; j < t.length; j++) {
            if (s.data[i] == t.data[j]) {
                break;
            }
        }
        if (j == t.length) {
            *value = s.data[i];
            *position = i;
            return 1;
        }
    }
    return 0;
}
/******end******/

该程序为动态分配内存的顺序表。完成函数FindList查找值为value的元素位置。

顺序表查找元素1.jpg

顺序表查找元素2.jpg

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int FindList(pSeqList L, int value);
int Destroy(pSeqList);
void output(SeqList L);
int prime(int n);

int main(void)
{
	int i, n, pos, value;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, prime(i + 1), i + 1);
	}
	output(L);

	printf("输入要查找的元素:");
	scanf("%d", &value);
	pos = FindList(&L, value);
	if (pos > 0)
	{
		printf("值为%d的元素在顺序表的第%d的位置上\n", value, pos);
	}
	else
	{
		printf("顺序表上没有要查找的元素值\n");
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int prime(int n)
{
	int i, j;
	int cnt;
	if (n == 1)
	{
		return 2;
	}
	else if (n == 2)
	{
		return 3;
	}

	cnt = 2;
	for (i = 5; ; i++)
	{
		for (j = 2; j < i / 2 ; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (j >= i / 2)
		{
			cnt++;
			if (cnt == n)
			{
				return i;
			}
		}
	}
	return 0;
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

typedef struct _SeqList
{
	int *elem;
	int length;
	int listsize;
} SeqList, *pSeqList;

int InitList(pSeqList L, int listsize);
int InsertList(pSeqList L, int x, int position);
int FindList(pSeqList L, int value);
int Destroy(pSeqList);
void output(SeqList L);
int prime(int n);

int main(void)
{
	int i, n, pos, value;
	SeqList L;
	
	printf("输入初始化线性顺序表的长度:");		//即该顺序表可放的元素个数
	scanf("%d", &L.listsize);
	if (InitList(&L, L.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}

	printf("输入需要插入到顺序表的元素个数:");
	scanf("%d", &n);
	//生成顺序表的元素
	for (i = 0; i < n; i++)
	{
		InsertList(&L, prime(i + 1), i + 1);
	}
	output(L);

	printf("输入要查找的元素:");
	scanf("%d", &value);
	pos = FindList(&L, value);
	if (pos > 0)
	{
		printf("值为%d的元素在顺序表的第%d的位置上\n", value, pos);
	}
	else
	{
		printf("顺序表上没有要查找的元素值\n");
	}
	Destroy(&L);
	return 0;
}

int InitList(pSeqList L, int listsize)
{
	L->elem = (int *)malloc(listsize * sizeof(int));
	if (L->elem == NULL)
	{
		return -1;
	}
	L->length = 0;
	return 1;
}

void output(SeqList L)
{
	int i;
	printf("output:\n");
	for (i = 0; i < L.length; i++)
	{
		printf("%d ", L.elem[i]);
	}
	printf("\n");
}

int InsertList(pSeqList L, int x, int position)
{
	int i;

	if (position < 1 || position > L->length + 1)
	{
		return -1;
	}
	if (L->length >= L->listsize)
	{
		return -2;
	}
	for (i = L->length; i >= position; i--)
	{
		L->elem[i] = L->elem[i - 1];
	}
	L->elem[i] = x;
	L->length += 1;
	return 1;
}

int Destroy(pSeqList L)
{
	if (L->elem != NULL)
	{
		free(L->elem);
		L->elem = NULL;
		L->length = 0;
		L->listsize = 0;
	}
	return 1;
}

int prime(int n)
{
	int i, j;
	int cnt;
	if (n == 1)
	{
		return 2;
	}
	else if (n == 2)
	{
		return 3;
	}

	cnt = 2;
	for (i = 5; ; i++)
	{
		for (j = 2; j < i / 2 ; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (j >= i / 2)
		{
			cnt++;
			if (cnt == n)
			{
				return i;
			}
		}
	}
	return 0;
}

/******start******/
int FindList(pSeqList L, int value) {
    int i;

    for (i = 0; i < L->length; i++) {
        if (L->elem[i] == value) {
            return i + 1;
        }
    }
    return -1;
}
/******end******/

已有顺序表L1和空表L2，将顺序表L1中的奇数元素删除，并且存储在顺序表L2中。

图中第1行的5，第2行是键盘输入。

分数: 100

请勿频繁操作

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq *l1, Seq *l2);

int main(void)
{
	int n;

	Seq l1 = {0}, l2 = {0};

	if (initseq(&l1) <= 0)
	{
		return 0;
	}
	if (initseq(&l2) <= 0)
	{
		destroy(l1);
		return 0;
	}

	printf("Input L1's number:");
	scanf("%d", &n);
	create(&l1, n);
	printf("L1: ");
	output(l1);


	printf("Output:\n");
	if (function(&l1, &l2) == 1)
	{
		printf("L1: ");
		output(l1);
		printf("L2: ");
		output(l2);
	}
	else
	{
		printf("Error!\n");
	}
	destroy(l1);
	destroy(l2);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/

/******end******/

#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

typedef int elemtype;

typedef struct _seq
{
	elemtype *data;
	int length;
} Seq;

int initseq(Seq *list);
int create(Seq *list, int n);
void destroy(Seq list);
void output(Seq list);
int function(Seq *l1, Seq *l2);

int main(void)
{
	int n;

	Seq l1 = {0}, l2 = {0};

	if (initseq(&l1) <= 0)
	{
		return 0;
	}
	if (initseq(&l2) <= 0)
	{
		destroy(l1);
		return 0;
	}

	printf("Input L1's number:");
	scanf("%d", &n);
	create(&l1, n);
	printf("L1: ");
	output(l1);


	printf("Output:\n");
	if (function(&l1, &l2) == 1)
	{
		printf("L1: ");
		output(l1);
		printf("L2: ");
		output(l2);
	}
	else
	{
		printf("Error!\n");
	}
	destroy(l1);
	destroy(l2);
	return 0;
}

int initseq(Seq *list)
{
	list->data = (elemtype *)malloc(sizeof(elemtype) * LISTSIZE);
	if (list->data == NULL)
	{
		return -1;
	}
	list->length = 0;
	return 1;
}

int create(Seq *list, int n)
{
	int i;
	elemtype temp;

	for (i = 0; i < n && i < LISTSIZE; i++)
	{
		scanf("%d", &temp);
		list->data[i] = temp;
	}
	list->length = i;
	return 1;
}

void output(Seq list)
{
	int i;
	for (i = 0; i < list.length; i++)
	{
		printf("%d ", list.data[i]);
	}
	printf("\n");
}

void destroy(Seq list)
{
	if (list.data != NULL)
	{
		free(list.data);
	}
}

/******start******/
int function(Seq *l1, Seq *l2) {
    int i = 0, j;

    while (i < l1->length) {
        if (l1->data[i] % 2 != 0) {
            l2->data[l2->length] = l1->data[i];
            l2->length++;
            for (j = i; j < l1->length - 1; j++) {
                l1->data[j] = l1->data[j + 1];
            }
            l1->length--;
        } else {
            i++;
        }
    }
    return 1;
}
/******end******/