数据结构

在已知的顺序表中某个位置加入一个元素。图示中第二至四行是键盘输入的，最后一行是输出。第二行表示初始元素的个数。第三行是输入相应元素。第四行是输入需要加入的位置和元素的值（图示合法位置是1到6）。请在/******start******/和/******end******/注释之间添加代码完成插入元素操作。

分数: 100

请勿频繁操作

#include <stdio.h>

int insert(int a[], int n, int pos, int value);

int main(void)
{
	int i, n, pos, value, flag;
	int a[100];
	
	printf("Input: \n");
	scanf("%d", &n);			//初始元素个数
	for (i = 0; i < n; i++)
	{
		scanf("%d", &a[i]);
	}

	scanf("%d%d", &pos, &value);			//需要插入元素的位置和值

	flag = insert(a, n, pos, value);

	printf("Output: ");
	if (flag == 0)
	{
		printf("position is wrong!\n");
	}
	else if (flag == -1)
	{
		printf("table is already full!\n");
	}
	else
	{
		for (i = 0; i <= n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("\n");
	}
	return 0;
}

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

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

#include <stdio.h>

int insert(int a[], int n, int pos, int value);

int main(void)
{
	int i, n, pos, value, flag;
	int a[100];
	
	printf("Input: \n");
	scanf("%d", &n);			//初始元素个数
	for (i = 0; i < n; i++)
	{
		scanf("%d", &a[i]);
	}

	scanf("%d%d", &pos, &value);			//需要插入元素的位置和值

	flag = insert(a, n, pos, value);

	printf("Output: ");
	if (flag == 0)
	{
		printf("position is wrong!\n");
	}
	else if (flag == -1)
	{
		printf("table is already full!\n");
	}
	else
	{
		for (i = 0; i <= n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("\n");
	}
	return 0;
}

/******start******/
int insert(int a[], int n, int pos, int value) {
    int i;
    if (pos < 1 || pos > n + 1)
        return 0;
    if (n >= 100)
        return -1;
    for (i = n; i >= pos; i--) {
        a[i] = a[i - 1];
    }
    a[i] = value;
    return 1;
}
/******end******/

查找顺序表中最小两个元素下标。其中pos1获得最小元素的下标，pos2获得次小元素的下标。如果有两个相等元素需要选择一个时，返回下标小的。

图中10和2 8 5 7 3 1 6 9 10 4是键盘输入的数据。

分数: 100

请勿频繁操作

//查找顺序表中最小的两个元素位置，pos1得到最小元素下标，pos2得到次小元素下标
#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

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

int InitList(pSeqList L);
int InsertList(pSeqList L, int x);
int Destroy(pSeqList);
void select(SeqList L, int *p1, int *p2);

int main(void)
{
	int i, n, pos1, pos2, value;
	SeqList L;
	
	if (InitList(&L) < 0)
	{
		return 0;
	}

	printf("输入需要录入到顺序表的元素个数:");
	scanf("%d", &n);

	printf("输入元素数据:");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &value);
		if (InsertList(&L, value) < 0)
		{
			return 0;
		}
	}

	if (L.length < 2)
	{
		return 0;
	}
	select(L, &pos1, &pos2);

	printf("output:\n最小两个元素:pos1=%d, pos2=%d\n", pos1, pos2);

	Destroy(&L);
	return 0;
}

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

int InsertList(pSeqList L, int x)
{
	if (L->length >= L->listsize)
	{
		return -1;
	}

	L->elem[L->length] = 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******/

//查找顺序表中最小的两个元素位置，pos1得到最小元素下标，pos2得到次小元素下标
#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

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

int InitList(pSeqList L);
int InsertList(pSeqList L, int x);
int Destroy(pSeqList);
void select(SeqList L, int *p1, int *p2);

int main(void)
{
	int i, n, pos1, pos2, value;
	SeqList L;
	
	if (InitList(&L) < 0)
	{
		return 0;
	}

	printf("输入需要录入到顺序表的元素个数:");
	scanf("%d", &n);

	printf("输入元素数据:");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &value);
		if (InsertList(&L, value) < 0)
		{
			return 0;
		}
	}

	if (L.length < 2)
	{
		return 0;
	}
	select(L, &pos1, &pos2);

	printf("output:\n最小两个元素:pos1=%d, pos2=%d\n", pos1, pos2);

	Destroy(&L);
	return 0;
}

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

int InsertList(pSeqList L, int x)
{
	if (L->length >= L->listsize)
	{
		return -1;
	}

	L->elem[L->length] = 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******/
void select(SeqList L, int *p1, int *p2)
{
    int i, min, min2;
    min = L.elem[0];
    min2 = L.elem[1];
    *p1 = 0;
    *p2 = 1;
    if (min > min2)
    {
        min = L.elem[1];
        min2 = L.elem[0];
        *p1 = 1;
        *p2 = 0;
    }
    for (i = 2; i < L.length; i++)
    {
        if (L.elem[i] < min)
        {
            min2 = min;
            min = L.elem[i];
            *p2 = *p1;
            *p1 = i;
        }
        else if (L.elem[i] < min2)
        {
            min2 = L.elem[i];
            *p2 = i;
        }
    }
}
/******end******/

查找顺序表中最小两个元素下标。其中pos1获得两个元素中前面那个元素的下标，pos2获得两个元素后面那个元素的下标。如果有两个相等元素需要选择一个时，返回下标小的。

图中10和2 8 5 7 3 1 6 9 10 4是键盘输入的数据。

分数: 100

请勿频繁操作

//查找顺序表中最小的两个元素位置，pos1得到最小元素下标，pos2得到次小元素下标
#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

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

int InitList(pSeqList L);
int InsertList(pSeqList L, int x);
int Destroy(pSeqList);
void select(SeqList L, int *p1, int *p2);

int main(void)
{
	int i, n, pos1, pos2, value;
	SeqList L;
	
	if (InitList(&L) < 0)
	{
		return 0;
	}

	printf("输入需要录入到顺序表的元素个数:");
	scanf("%d", &n);

	printf("输入元素数据:");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &value);
		if (InsertList(&L, value) < 0)
		{
			return 0;
		}
	}

	if (L.length < 2)
	{
		return 0;
	}
	select(L, &pos1, &pos2);

	printf("output:\n最小两个元素:pos1=%d, pos2=%d\n", pos1, pos2);

	Destroy(&L);
	return 0;
}

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

int InsertList(pSeqList L, int x)
{
	if (L->length >= L->listsize)
	{
		return -1;
	}

	L->elem[L->length] = 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******/

//查找顺序表中最小的两个元素位置，pos1得到最小元素下标，pos2得到次小元素下标
#include <stdio.h>
#include <stdlib.h>

#define LISTSIZE 100

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

int InitList(pSeqList L);
int InsertList(pSeqList L, int x);
int Destroy(pSeqList);
void select(SeqList L, int *p1, int *p2);

int main(void)
{
	int i, n, pos1, pos2, value;
	SeqList L;
	
	if (InitList(&L) < 0)
	{
		return 0;
	}

	printf("输入需要录入到顺序表的元素个数:");
	scanf("%d", &n);

	printf("输入元素数据:");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &value);
		if (InsertList(&L, value) < 0)
		{
			return 0;
		}
	}

	if (L.length < 2)
	{
		return 0;
	}
	select(L, &pos1, &pos2);

	printf("output:\n最小两个元素:pos1=%d, pos2=%d\n", pos1, pos2);

	Destroy(&L);
	return 0;
}

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

int InsertList(pSeqList L, int x)
{
	if (L->length >= L->listsize)
	{
		return -1;
	}

	L->elem[L->length] = 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******/
void select(SeqList L, int *p1, int *p2) {
    int i, min, min2;
    min = L.elem[0];
    min2 = L.elem[1];
    *p1 = 0;
    *p2 = 1;
    if (min > min2) {
        min = L.elem[1];
        min2 = L.elem[0];
        *p1 = 1;
        *p2 = 0;
    }
    for (i = 2; i < L.length; i++) {
        if (L.elem[i] < min) {
            min2 = min;
            min = L.elem[i];
            *p2 = *p1;
            *p1 = i;
        } else if (L.elem[i] < min2) {
            min2 = L.elem[i];
            *p2 = i;
        }
    }
    if (*p1 > *p2) {
        i = *p1;
        *p1 = *p2;
        *p2 = i;
    }
}
/******end******/

从顺序结构（n个元素）中第i个（1 <= i <= n）位置连续删除k个（k > 0）元素，第1,3,5行为输入提示，第2,4,6行需要用户输入，第8行为输出。

分数: 100

请勿频繁操作

#include <stdio.h>

#define Maxsize 40

int DelArray(int array[], int *last, int i, int k) {
    int j;
    if (i > *last || i <= 0) {
        printf("Output: \n");
        printf("给出的起始位置不合法\n");
        return 1;
    }
    if (i + k - 1 > *last || k <= 0) {
        printf("Output: \n");
        printf("删除个数值不合法!\n");
        return 1;
    }
    for (j = i - 1; j + k < *last; j++) {
        array[j] = array[j + k];
    }
    *last -= k;
    return 0;
}

int main() {
    int array[Maxsize], last, i, j, k;
    printf("请输入数组元素个数:\n");
    scanf("%d", &last);
    printf("请输入数组:\n");
    for (j = 0; j < last; j++) {
        scanf("%d", &array[j]);
    }
    printf("请输入删除起始位置及个数:\n");
    scanf("%d%d", &i, &k);
    if (DelArray(array, &last, i, k) == 1) {
        return 0;
    }
    printf("Output:\n");
    for (j = 0; j < last; j++) {
        printf("%d ", array[j]);
    }
    printf("\n");
    return 0;
}

编写一个程序，判断输入的字符串是否为回文；所谓“回文”指字符串从左向右读取的结果与从右向左读取的结果相同。程序结果中第一行“Enter a number:”为固定输入，后接输入的字符串；第二行：“output:”为固定输出，后接判断结果；若为回文，则输出"It's a huiwen number"；若不为回文，则输出"It's not a huiwen number"

分数: 100

请勿频繁操作

#include<stdio.h>
#include<string.h>

#define MAX 20

struct stack {
    char str[MAX];
    int top;
};

void Initstack(struct stack *sp) /*初始化栈*/
{
    strcpy(sp->str, " ");
    sp->top = -1;
}

void push(struct stack *sp, char c) /*压栈函数*/
{ sp->str[++sp->top] = c; }

char pop(struct stack *sp) /*退栈函数*/
{ return sp->str[sp->top--]; }

int main() {
    struct stack sk, *sp; /*定义一个栈sk和一个指向栈的指针sp*/
    int len, k, i;
    char num[MAX], *p;
    sp = &sk;
    Initstack(sp);
    printf("Enter a number:");
    scanf("%s", num);
    len = strlen(num);
    k = len / 2;
    p = num;
    for (i = 0; i < k; i++) /*将num的前k位压入栈内*/
    {
        push(sp, *p);
        p++;
    }
    if (len - 2 * k == 1) p++; /*如果这个数为奇数位则要让p前进一位*/
    for (i = 0; i < k; i++) {
        if (sp->str[sp->top] == *p) /*若是和对称的数位的值相同,则进行出栈的处理*/
        {
            pop(sp);
            p++;
        } else break; /*若是和对称的数位的值不相同,则退出循环*/
    }
    if (sp->top == -1) /*如果栈为空则表示为回文数,否则为是回文数*/
    {
        printf("output:");
        printf("It's a huiwen number\n");
    } else {
        printf("output:");
        printf("It's not a huiwen number\n");
    }
    return 0;
}

将Lb中不存在于La的元素添加到La线性表表尾。其中已有顺序表La和Lb，其中各自线性表内的元素均不重复。编写函数完成将Lb线性表中的不存在于La线性表的元素添加到La线性表的后面。

图中第一行的10，第三行的1 5 2 3 7 8 9 10 6 4，第四行的5，第六行的2 11 30 4 5是键盘输入的数据。

分数: 100

请勿频繁操作

//将Lb与La不重复的元素插入到La的表尾，初始化的La和Lb无重复元素
#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 Destroy(pSeqList L);
void output(SeqList L);
void Merge(pSeqList La, pSeqList Lb);

int main(void)
{
	int i, n, temp, flag;
	SeqList La, Lb;
	
	La.elem = NULL;
	Lb.elem = NULL;
	La.listsize = 100;
	Lb.listsize = 100;
	if (InitList(&La, La.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}
	if (InitList(&Lb, Lb.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		Destroy(&La);
		return 0;
	}

	printf("输入需要插入到顺序表La的元素个数:");
	scanf("%d", &n);
	printf("按序列输入元素值到顺序表La:\n");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &temp);
		flag = InsertList(&La, temp);		//将temp插入到顺序表表尾
		if (flag == -1)
		{
			printf("output:\n该线性顺序表La已满，无法再插入元素\n");
			return 0;
		}
	}
	
	printf("输入需要插入到顺序表Lb的元素个数:");
	scanf("%d", &n);
	printf("按序列输入元素值到顺序表Lb:\n");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &temp);
		flag = InsertList(&Lb, temp);		//将temp插入到顺序表表尾
		if (flag == -1)
		{
			printf("output:\n该线性顺序表Lb已满，无法再插入元素\n");
			return 0;
		}
	}
	
	Merge(&La, &Lb);

	output(La);
	Destroy(&La);
	Destroy(&Lb);
	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;
}

//插入的元素在尾部
int InsertList(pSeqList L, int x)
{
	if (L->length >= L->listsize)
	{
		return -1;
	}

	L->elem[L->length++] = x;
	return 1;
}

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

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

//将Lb与La不重复的元素插入到La的表尾，初始化的La和Lb无重复元素
#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 Destroy(pSeqList L);
void output(SeqList L);
void Merge(pSeqList La, pSeqList Lb);

int main(void)
{
	int i, n, temp, flag;
	SeqList La, Lb;
	
	La.elem = NULL;
	Lb.elem = NULL;
	La.listsize = 100;
	Lb.listsize = 100;
	if (InitList(&La, La.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		return 0;
	}
	if (InitList(&Lb, Lb.listsize) <= 0)
	{
		printf("output:\n初始化顺序表失败\n");
		Destroy(&La);
		return 0;
	}

	printf("输入需要插入到顺序表La的元素个数:");
	scanf("%d", &n);
	printf("按序列输入元素值到顺序表La:\n");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &temp);
		flag = InsertList(&La, temp);		//将temp插入到顺序表表尾
		if (flag == -1)
		{
			printf("output:\n该线性顺序表La已满，无法再插入元素\n");
			return 0;
		}
	}
	
	printf("输入需要插入到顺序表Lb的元素个数:");
	scanf("%d", &n);
	printf("按序列输入元素值到顺序表Lb:\n");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &temp);
		flag = InsertList(&Lb, temp);		//将temp插入到顺序表表尾
		if (flag == -1)
		{
			printf("output:\n该线性顺序表Lb已满，无法再插入元素\n");
			return 0;
		}
	}
	
	Merge(&La, &Lb);

	output(La);
	Destroy(&La);
	Destroy(&Lb);
	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;
}

//插入的元素在尾部
int InsertList(pSeqList L, int x)
{
	if (L->length >= L->listsize)
	{
		return -1;
	}

	L->elem[L->length++] = x;
	return 1;
}

/******start******/
void Merge(pSeqList La, pSeqList Lb) {
    int i;
    for (int j = 0; j < Lb->length; j++) {
        for (i = 0; i < La->length; i++) {
            if (Lb->elem[j] == La->elem[i]) {
                break;
            }
        }
        if (i == La->length) {
            InsertList(La, Lb->elem[j]);
        }
    }
}
/******end******/

将两个顺序存储的有序（升序）表合并成一个有序表（设用户输入的是有序表，忽略检测用户有序状况的检查），合并后输出。第1,3,5,7行为用户输入提示，2,4,6,8行为用户输入，第10行为输出的结果。

分数: 100

请勿频繁操作

#include <stdio.h>

void step(int a[], int m, int k) {
    int i;
    for (i = m - 1; i >= k; i--) {
        a[i + 1] = a[i];
    }
}

int main(void) {
    int a[80];
    int b[10];
    int m, n;
    int i, j;
    int count;
    int ina = 0, inb = 0;
    printf("请输入第一个序列的元素个数:\n");
    scanf("%d", &m);
    printf("请依次输入第一个序列的所有元素:\n");
    for (i = 0; i <= m - 1; i++) {
        scanf("%d", &a[i]);
    }
    printf("请输入第二个序列的元素个数:\n");
    scanf("%d", &n);
    printf("请依次输入第二个序列的所有元素:\n");
    for (j = 0; j <= n - 1; j++) {
        scanf("%d", &b[j]);
    }
    i = 0;
    j = 0;
    count = m;
    while (ina < m && inb < n) {
        if (b[j] < a[i]) {
            step(a, count, i);
            a[i] = b[j++];
            count++;
            inb++;
        } else
            ina++;
        i++;
    }
    if (inb < n) {
        while (j < n) {
            a[i++] = b[j++];
        }
    }
    printf("output:\n");
    for (i = 0; i < m + n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}