数据结构线性表课后题

已于 2025-03-28 16:52:20 修改
阅读量115 收藏 1
点赞数
文章标签： 数据结构 算法
于 2023-10-15 14:45:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Shmiwy/article/details/133579848
版权

希望可以早日掌握！！！加油！！

1.线性表中删除具有最小值的元素（假设唯一），由函数返回被删除元素的值，空出的位置由最后一个元素填补，若为空则显示出错信息并推出运行。

//思路：首元素设为min，搜索整个顺序表，查找元素确定位置
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 创建顺序表
typedef struct {
    int data[MAX_SIZE];
    int length;
} SeqList;
// 初始化顺序表
void InitList(SeqList* L){
    L->length = 0;
}
// 从顺序表中删除最小值元素
int DeleteMin(SeqList* L) {
    if (L->length == 0) {
        printf("Error: The sequence list is empty\n");
        exit(1);
    }
    int min = L->data[0];
    int pos = 0;
    // 找到最小值元素的下标
    for (int i = 1; i < L->length; ++i) {
        if (L->data[i] < min) {
            min = L->data[i];
            pos = i;
        }
    }
    // 用末尾元素覆盖被删除的元素
    L->data[pos] = L->data[L->length - 1];
    L->length--;
    return min;
}
int main() {
    SeqList L;
    InitList(&L);
    // 数值插入顺序表，顺序表下标由1开始
    for (int i = 1; i <= 10; ++i) {
            scanf("%d",&L.data[L.length++]);
    }
    // 从顺序表中删除最小值元素
    int min = DeleteMin(&L);
    printf("The minimum value is %d\n", min);
    // 输出删除最小值元素后的顺序表
    printf("The sequence list after delete min: ");
    for (int i = 0; i < L.length; ++i) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
    return 0;
}

2.算法将顺序表中所有元素逆置，要求算法的空间复杂度为O(1)

#include<stdio.h>
#define MAXSIZE 100  // 定义顺序表的最大长度
typedef struct {
    int data[MAXSIZE];
    int length;
}SqList;
void InitList(SqList *L) {
    L->length = 0;
}
void ReverseList(SqList *L) {
    int i, temp;
    for(i=0; i<L->length/2; i++) {
        temp = L->data[i];
        L->data[i] = L->data[L->length-1-i];
        L->data[L->length-1-i] = temp;
    }
}
int main() {
    SqList L;
    InitList(&L);
    int i;
    for(i=0; i<10; i++) {
        L.data[i] = i+1;
        L.length++;//这里取1-10，方便观察逆置情况
    }
    printf("顺序表逆置前：");
    for(i=0; i<L.length; i++) {
        printf("%d ", L.data[i]);
    }
    ReverseList(&L);
    printf("\n顺序表逆置后：");
    for(i=0; i<L.length; i++) {
        printf("%d ", L.data[i]);
    }
    return 0;
}

3.长度为n的顺序表L，编写时间复杂度为O(n)，空间复杂度为O(1)算法，实现删除所有值为x的元素（书上另一种代码也可！！）

//算法思路：找不等于x的元素，移动位置，修改表长
#include<stdio.h>
#define MAXSIZE 100
typedef struct {
    int data[MAXSIZE];
    int length;
} SqList;
void InitList(SqList *L) {
    L->length = 0;
}
void deleteAllX(SqList *L, int x) {
    int i = 0, j = 0;
    for (; i < L->length; i++) {
        if (L->data[i] != x) {
            L->data[j++] = L->data[i];
        }
    }
    L->length = j;
}
int main() {
    SqList L;
    InitList(&L);
    int i,x;
    scanf("%d", &x);
    for(i=0; i<10; i++) {
        scanf("%d",&L.data[L.length++]);
    }
    deleteAllX(&L,x);
     for(i=0; i<L.length; i++) {
        printf("%d ", L.data[i]);
    }
}

4，从有序表中删除其值在给定值s与t之间（要求s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并推出运行。

#include <stdio.h>
#define MAXSIZE 100 // 可根据实际情况调整
typedef struct {
    int data[MAXSIZE];
    int length;
} SqList;
// 初始化有序表
void initList(SqList *L) {
    L->length = 0;
}
// 打印有序表
void printList(SqList L) {
    int i;
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}
// 从有序表中删除值在s和t之间的元素
int deleteBetweenST(SqList *L, int s, int t) {
    if (L->length == 0 || s >= t) {// 非法情况
        return 0;
    }
    int i, j;
    for (i = 0; i < L->length && L->data[i] < s; i++);
    if (i >= L->length) {
        // 所有元素都小于s
        return 0;
    }
    for (j = i; j < L->length && L->data[j] <= t; j++);
        for (; j < L->length; i++, j++) {
            L->data[i] = L->data[j];
        }
    L->length = i;
    return 1;
}
int main() {
    SqList L;
    initList(&L);
    int i;
    for (i = 1; i <= 10; i++) {
        L.data[i - 1] = i;
        L.length++;
    }
    printList(L);
    deleteBetweenST(&L, 3, 8);
    printList(L);
    return 0;
}

5，从有序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。

#include <stdio.h>
#define MAXSIZE 100 // 假设顺序表最大长度为100
typedef struct {
    int data[MAXSIZE];
    int length;
} SqList;
// 删除有序表中值在s和t之间的元素
int deleteBetweenST(SqList *L, int s, int t) {
    int i, k=0;
    if (s >= t || L->length == 0) { // 如果s或t不合理或顺序表为空，则显示错误信息并返回
        return false;
    }
    for (i = 0; i < L->length; i++) { // 找到第一个大于等于s的元素位置
        if (L->data[i] >= s&&L->data[i]<=t) {
            k++;
        }else
            L->data[i - k] = L->data[i];
    }
    L->length -= k; // 修改顺序表长度
    return 1; // 删除成功
}
int main() {
    SqList L = {{1, 2, 3, 4, 5, 6, 7, 8, 9}, 9}; // 初始化有序表,有点懵这一步
    int i;
    printf("Before deleting: ");
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
    deleteBetweenST(&L, 3, 7); // 删除值在3和7之间的元素
    printf("After deleting: ");
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
    return 0;
}

6.有序表中删除所有其值重复的元素，使表中所有元素的值均不同。

有bug，输入111222356，会把12删除

#include <stdio.h>
#define MAX_SIZE 100
typedef struct {
    int data[MAX_SIZE];
    int length;
} SqList;
void initList(SqList *list) {
    list->length = 0;
}
int deleteDuplicates(SqList *list) {
    if (list->length <= 1) {
        return 0;
    }
    int i, j;
    int count = 0;
    for (i = 0, j = 1; j < list->length; j++) {
        if (list->data[i] != list->data[j]) {
            i++;
            list->data[i] = list->data[j];
        } else {
            count++;
        }
    }
    list->length = i + 1;
    return count;
}
void printList(SqList *list) {
    int i;
    for (i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}
int main() {
    SqList list;
    initList(&list);
    int n, i;
    printf("请输入有序表的长度:\n");
    scanf("%d", &n);
    printf("请输入有序表的元素:\n");
    for (i = 0; i < n; i++) {
        scanf("%d", &list.data[i]);
    }
    list.length = n;
    int count = deleteDuplicates(&list);
    printf("删除了%d个重复元素后，有序表的元素为:\n", count);
    printList(&list);
    return 0;
}

7.将两个有序表合并成一个新的有序表，并由函数返回结果顺序表。

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100 //定义最大长度
//定义顺序表
typedef struct {
    int data[MAXSIZE];
    int length;
} SqList;
//合并两个有序表
void merge(SqList La, SqList Lb, SqList *Lc) {
    int i = 0, j = 0, k = 0;
    while (i < La.length && j < Lb.length) {
        if (La.data[i] <= Lb.data[j]) {
            Lc->data[k++] = La.data[i++];
        } else {
            Lc->data[k++] = Lb.data[j++];
        }
    }
    while (i < La.length) {
        Lc->data[k++] = La.data[i++];
    }
    while (j < Lb.length) {
        Lc->data[k++] = Lb.data[j++];
    }
    Lc->length = k;
}

int main() {
    SqList La, Lb, Lc;
    int n, m, i;
    //输入La和Lb的元素个数
    printf("请输入La和Lb的元素个数：\n");
    scanf("%d%d", &n, &m);
    //输入La的元素
    printf("请输入La的元素：\n");
    for (i = 0; i < n; i++) {
        scanf("%d", &La.data[i]);
    }
    La.length = n;
    //输入Lb的元素
    printf("请输入Lb的元素：\n");
    for (i = 0; i < m; i++) {
        scanf("%d", &Lb.data[i]);
    }
    Lb.length = m;
    merge(La, Lb, &Lc); //合并La和Lb
    //输出合并后的Lc
    printf("合并后的Lc为：\n");
    for (i = 0; i < Lc.length; i++) {
        printf("%d ", Lc.data[i]);
    }
    return 0;
}
8,已知一个数组A[m+n]中依次存放两个线性表，编写一个函数，将两个线性表的位置互换。
#include <stdio.h>
#define MAX_SIZE 100
// 将两个线性表的位置互换
void swap(int A[], int m, int n, int len1, int len2) {
    int i, temp;
    if (m > n) {  // 交换m和n，保证m小于n
        int t = m;
        m = n;
        n = t;
    }
    for (i = 0; i < (n - m) / 2; i++) {  // 交换m到n之间的元素
        temp = A[m + i];
        A[m + i] = A[n - i - 1];
        A[n - i - 1] = temp;
    }
    for (i = 0; i < (m + len2 - len1) / 2; i++) {  // 交换前半部分和后半部分
        temp = A[i];
        A[i] = A[m + len2 - len1 + i];
        A[m + len2 - len1 + i] = temp;
    }
    for (i = 0; i < (m + n - 2 * len1 + len2) / 2; i++) {  // 交换后半部分和前半部分
        temp = A[m - len1 + i];
        A[m - len1 + i] = A[m + len2 + i];
        A[m + len2 + i] = temp;
    }
}
int main() {
    int A[MAX_SIZE], m, n, len1, len2, i;
    printf("请输入数组A的长度，以及两个线性表的长度：\n");
    scanf("%d%d%d", &m, &len1, &len2);
    n = m - len1;
    printf("请输入数组A中的元素：\n");
    for (i = 0; i < m; i++) {
        scanf("%d", &A[i]);
    }
    swap(A, m - len2, m, len1, len2);

    printf("交换后的数组A为：\n");
    for (i = 0; i < m; i++) {
        printf("%d ", A[i]);
    }
    printf("\n");

    return 0;
}

‌Freiheit
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值