c语言 非递减有序顺序表 输入元素，再插入元素使代码仍为递增

思路：

1. 首先输入非递减有序顺序表，即输入一个有序数组；

2. 输入一个待插入的元素；

3. 遍历有序数组，找到第一个大于等于待插入元素的位置；

4. 将待插入元素插入到该位置，并将该位置后面的元素向后移动一个位置；

5. 输出插入后的有序数组。

代码实现：

#include<stdio.h>
#define MAXSIZE 100

int main()
{
    int a[MAXSIZE];
    int n, i, j, x;
    printf("请输入非递减有序顺序表：\n");
    scanf("%d", &n);
    for(i=0; i<n; i++)
        scanf("%d", &a[i]);
    printf("请输入要插入的元素：\n");
    scanf("%d", &x);
    for(i=0; i<n; i++)
        if(a[i]>=x) break;
    for(j=n; j>i; j--)
        a[j]=a[j-1];
    a[i]=x;
    n++;
    printf("插入后的有序顺序表为：\n");
    for(i=0; i<n; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

相关问题

c语言非递减有序顺序表输入元素，再插入元素使代码仍递增

以下是一个示例代码：

#include <stdio.h>

#define MAX_SIZE 100

void insert(int arr[], int *size, int value);

int main() {
    int arr[MAX_SIZE];
    int size = 0;
    int value;

    // 输入元素
    printf("请输入非递减有序顺序表：\n");
    while (size < MAX_SIZE) {
        if (scanf("%d", &arr[size]) != 1) {
            break;
        }
        size++;
    }

    // 插入元素并保持递增
    printf("请输入要插入的元素：\n");
    if (scanf("%d", &value) == 1) {
        insert(arr, &size, value);
    }

    // 输出有序顺序表
    printf("有序顺序表为：\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

void insert(int arr[], int *size, int value) {
    int i;
    for (i = *size - 1; i >= 0 && arr[i] > value; i--) {
        arr[i + 1] = arr[i];
    }
    arr[i + 1] = value;
    (*size)++;
}

首先，我们定义了一个 `insert` 函数，该函数接受一个有序顺序表 `arr`、该有序顺序表的大小 `size` 和要插入的值 `value`。函数通过将元素依次向右移动直到找到要插入的位置，最后将 `value` 插入到该位置来实现在有序顺序表中插入元素并保持递增。

在 `main` 函数中，我们首先输入一个非递减有序顺序表，然后输入要插入的值，并调用 `insert` 函数来将该值插入到有序顺序表中。最后，我们输出有序顺序表。

需要注意的是，在输入有序顺序表时，我们使用了一个循环来读取输入值，并在输入错误或达到最大容量时退出循环。在输入要插入的值时，我们只读取一个值，因为我们只需要一个值来插入到有序顺序表中。

c语言动态非递减有序顺序表输入元素，插入元素使代码仍递增

下面是一个实现动态非递减有序顺序表输入元素，并插入元素使代码仍递增的示例代码：

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

typedef struct {
    int *data;
    int length;
    int capacity;
} SeqList;

void initList(SeqList *list, int capacity) {
    list->data = (int *)malloc(sizeof(int) * capacity);
    list->length = 0;
    list->capacity = capacity;
}

void destroyList(SeqList *list) {
    free(list->data);
    list->data = NULL;
    list->length = list->capacity = 0;
}

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

void insert(SeqList *list, int value) {
    if (list->length == list->capacity) {
        int *newData = (int *)realloc(list->data, sizeof(int) * (list->capacity * 2));
        if (newData == NULL) {
            printf("Memory allocation failed.\n");
            return;
        }
        list->data = newData;
        list->capacity *= 2;
    }
    int i = list->length - 1;
    while (i >= 0 && list->data[i] > value) {
        list->data[i + 1] = list->data[i];
        i--;
    }
    list->data[i + 1] = value;
    list->length++;
}

int main() {
    SeqList list;
    int capacity = 5;
    initList(&list, capacity);
    int value;
    printf("Please input the elements of the list (non-negative integers, -1 to end):\n");
    do {
        scanf("%d", &value);
        if (value >= 0) {
            insert(&list, value);
            displayList(list);
        }
    } while (value != -1);
    destroyList(&list);
    return 0;
}

该代码中的 `insert()` 函数实现了将元素按非递减有序插入到顺序表中的功能。具体的实现方法是，从顺序表的末尾开始向前遍历，如果当前元素比待插入元素大，则将当前元素后移一位，直到找到一个比待插入元素小或相等的元素，然后将待插入元素插入到该位置后面。由于顺序表是非递减有序的，因此当遍历到的元素比待插入元素小时，就可以结束遍历了，因为后面的元素都比待插入元素大。

在主函数中，先通过 `initList()` 函数初始化一个容量为 5 的顺序表。然后通过 `insert()` 函数将用户输入的元素插入到顺序表中，并输出当前的顺序表。当用户输入 -1 时，退出输入循环，通过 `destroyList()` 函数销毁顺序表并释放内存。