线性表练习之Example023-从有序顺序表种删除值在 (s, t) 之间的所有元素

最新推荐文章于 2022-09-12 09:01:21 发布
最新推荐文章于 2022-09-12 09:01:21 发布
阅读量2.2k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123805527
版权

Example023

原文链接：Example023

题目

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

分析

本题考查的知识点：

  • 顺序表
  • 顺序表删除元素

分析：

  • 注意，本题中的顺序表是有序的（如 [1, 2, 3, 4, 5, 6]），所以我们如果要删除的数一定是指定范围内的一组数（如 s=3, t=6），则会删除 [4, 5]，最后得到的结果是 [1, 2, 3, 6]，发现它是删除多个数，而非删除单个数。
  • 本题解法是删除是不包括边界的，即如果顺序表中有元素等于 s 或者 t，则是不需要删除的。即只删除顺序表中范围在 (s, t) 之内的数。但书中的解法是包括 s 和　t 的，考虑到书中下一道题是明确说明包括 s 和 t的，所以本题是不包括边界的。
  • 注意删除的三种情况（如顺序表是 [1, 2, 3, 4, 5, 6] ）：第一种情况，删除顺序表中间的元素（如s=3, t=6 那么结果是 [1, 2, 3, 6]）；第二种情况，删除顺序表开头的元素（如 s=0, t=4 那么结果是 [4, 5, 6]）；第三种情况，删除顺序表结尾的元素（如 s=3, t=7）。
  • 本题的算法思想是，先寻找要删除的第一个元素的起始下标（即第一个大于 s 的元素），再寻找要删除的最后一个元素的下标（即第一个小于 t 的元素），然后将这段元素删除，直接用后面的元素覆盖前面的元素，最后修改顺序表的长度即完成删除。

图解

请添加图片描述

C实现

核心代码：

/**
 * 删除顺序表中值在 (s, t) 之间的所有元素
 *
 * @param list 顺序表
 * @param s 指定起始值，不包括本身
 * @param t 指定结束值，不包括本身
 *
 * @throws Exception 如果参数不合法则抛出异常
 */
void deleteByRange(SeqList *list, int s, int t) {
    // 0.参数校验
    // 0.1 s必须小于t
    if (s >= t) {
        printf("s 应该小于 t: s=%d, t=%d", s, t);
        exit(0);
    }
    // 0.2 顺序表为空则不能进行删除
    if (list->length == 0) {
        printf("顺序表为空，不能删除！");
        exit(0);
    }

    // 1.计算起始边界和结束边界，包括边界本身
    // 1.1 计算要删除的第一个元素的下标，包含本身
    int start = 0;
    while (list->data[start] <= s) {
        start++;
    }
    // 1.2 计算要删除的最后一个元素的下标，包含本身
    int end = list->length - 1;
    while (list->data[end] >= t) {
        end--;
    }

    // 2.删除 [start, end] 所表示的所有元素
    // 2.1 移动 end 之后的所有元素（包括 end 所指向的元素）到 start 及之后的位置
    for (int i = 0; i < list->length - 1 - end; i++) {
        list->data[start + i] = list->data[end + 1 + i];
    }
    // 2.2 最重要的是，修改顺序表的 length 属性，删除了 end-start+1 个元素
    list->length -= end - start + 1;
}

完整代码：

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

#define MAXSIZE 20

/**
 * 顺序表的结构体
 */
typedef struct {
    /**
     * 顺序表，实际上一个长度为 MAXSIZE 的数组，存储的数据类型为整型，当然可以设置为其他类型，但推荐使用宏定义类型，方便替换
     */
    int data[MAXSIZE];
    /**
     * 顺序表长度，即数组中实际元素个数
     */
    int length;
} SeqList;

/**
 * 初始化顺序表，仅需要将 length 置为 0 即可
 * @param list 待初始化的顺序表
 */
void init(SeqList *list) {
    // 仅需要将 length 置为 0 即可
    (*list).length = 0;
    // 或者可以用下面的语法
    // list->length=0;
}

/**
 * 直接添加新元素到顺序表的尾部
 * @param list 顺序表
 * @param ele 待添加的新元素
 * @return 如果插入成功则返回 1，否则返回 0
 */
int add(SeqList *list, int ele) {
    // 0.校验
    // 0.1 向顺序表中插入元素要检查顺序表是否已经满了，如果已经满了则不能再插入新元素则添加失败
    if (list->length == MAXSIZE) {
        return 0;
    }
    // 1.插入新元素
    // 1.1 直接获取顺序表的 length，然后将新元素的值赋予到 length 位置即可
    list->data[list->length] = ele;
    // 1.2 注意修改 length
    list->length++;
    return 1;
}

/**
 * 删除顺序表中值在 (s, t) 之间的所有元素
 *
 * @param list 顺序表
 * @param s 指定起始值，不包括本身
 * @param t 指定结束值，不包括本身
 *
 * @throws Exception 如果参数不合法则抛出异常
 */
void deleteByRange(SeqList *list, int s, int t) {
    // 0.参数校验
    // 0.1 s必须小于t
    if (s >= t) {
        printf("s 应该小于 t: s=%d, t=%d", s, t);
        exit(0);
    }
    // 0.2 顺序表为空则不能进行删除
    if (list->length == 0) {
        printf("顺序表为空，不能删除！");
        exit(0);
    }

    // 1.计算起始边界和结束边界，包括边界本身
    // 1.1 计算要删除的第一个元素的下标，包含本身
    int start = 0;
    while (list->data[start] <= s) {
        start++;
    }
    // 1.2 计算要删除的最后一个元素的下标，包含本身
    int end = list->length - 1;
    while (list->data[end] >= t) {
        end--;
    }

    // 2.删除 [start, end] 所表示的所有元素
    // 2.1 移动 end 之后的所有元素（包括 end 所指向的元素）到 start 及之后的位置
    for (int i = 0; i < list->length - 1 - end; i++) {
        list->data[start + i] = list->data[end + 1 + i];
    }
    // 2.2 最重要的是，修改顺序表的 length 属性，删除了 end-start+1 个元素
    list->length -= end - start + 1;
}

/**
 * 打印顺序表
 * @param list 待打印的顺序表
 */
void print(SeqList list) {
    printf("[");
    for (int i = 0; i < list.length; i++) {
        printf("%d", list.data[i]);
        if (i != list.length - 1) {
            printf(", ");
        }
    }
    printf("]\n");
}

int main() {
    // 声明顺序表
    SeqList list;
    init(&list);
    // 添加测试数据
    add(&list, 1);
    add(&list, 2);
    add(&list, 3);
    add(&list, 4);
    add(&list, 5);
    add(&list, 6);
    print(list);

    // 调用函数进行删除
    int s = 3, t = 6;
    deleteByRange(&list, s, t);
    print(list);
}

执行结果：

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 6]

Java实现

核心代码：

    /**
     * 删除顺序表中值在 (s, t) 之间的所有元素
     *
     * @param s 指定起始值，不包括本身
     * @param t 指定结束值，不包括本身
     * @throws Exception 如果参数不合法则抛出异常
     */
    public void deleteByRange(int s, int t) throws Exception {
        // 0.参数校验
        // 0.1 s必须小于t
        if (s >= t) {
            throw new Exception("s 应该小于 t: s=" + s + ", t=" + t);
        }
        // 0.2 顺序表为空则不能进行删除
        if (list.length == 0) {
            throw new Exception("顺序表为空，不能删除！");
        }

        // 1.计算起始边界和结束边界，包括边界本身
        // 1.1 计算要删除的第一个元素的下标，包含本身
        int start = 0;
        while (list.data[start] <= s) {
            start++;
        }
        // 1.2 计算要删除的最后一个元素的下标，包含本身
        int end = list.length - 1;
        while (list.data[end] >= t) {
            end--;
        }

        // 2.删除 [start, end] 所表示的所有元素
        // 2.1 移动 end 之后的所有元素（包括 end 所指向的元素）到 start 及之后的位置
        for (int i = 0; i < list.length - 1 - end; i++) {
            list.data[start + i] = list.data[end + 1 + i];
        }
        // 2.2 最重要的是，修改顺序表的 length 属性，删除了 end-start+1 个元素
        list.length -= end - start + 1;
    }

完整代码：

public class SeqList {
    /**
     * 顺序表最大能存放元素个数
     */
    private final int MAXSIZE = 20;

    /**
     * 声明的顺序表，未初始化
     */
    private List list;

    /**
     * 初始化顺序表
     */
    public void init() {
        list = new List();
        // 指定数据数组长度为 MAXSIZE
        list.data = new int[MAXSIZE];
        // 但指定顺序表实际元素个数为 0
        list.length = 0;
    }

    /**
     * 直接添加新元素到顺序表的尾部
     *
     * @param ele 待插入的新元素
     */
    public void add(int ele) throws Exception {
        // 0.校验
        // 0.1 向顺序表中插入元素要检查顺序表是否已经满了，如果已经满了则不能再插入新元素则抛出异常
        if (list.length == MAXSIZE) {
            throw new Exception("顺序表已满，不能再插入了！");
        }
        // 1.插入新元素
        // 1.1 直接获取顺序表的 length，然后将新元素的值赋予到 length 位置即可
        list.data[list.length] = ele;
        // 1.2 注意修改 length
        list.length++;
    }

    /**
     * 删除顺序表中值在 (s, t) 之间的所有元素
     *
     * @param s 指定起始值，不包括本身
     * @param t 指定结束值，不包括本身
     * @throws Exception 如果参数不合法则抛出异常
     */
    public void deleteByRange(int s, int t) throws Exception {
        // 0.参数校验
        // 0.1 s必须小于t
        if (s >= t) {
            throw new Exception("s 应该小于 t: s=" + s + ", t=" + t);
        }
        // 0.2 顺序表为空则不能进行删除
        if (list.length == 0) {
            throw new Exception("顺序表为空，不能删除！");
        }

        // 1.计算起始边界和结束边界，包括边界本身
        // 1.1 计算要删除的第一个元素的下标，包含本身
        int start = 0;
        while (list.data[start] <= s) {
            start++;
        }
        // 1.2 计算要删除的最后一个元素的下标，包含本身
        int end = list.length - 1;
        while (list.data[end] >= t) {
            end--;
        }

        // 2.删除 [start, end] 所表示的所有元素
        // 2.1 移动 end 之后的所有元素（包括 end 所指向的元素）到 start 及之后的位置
        for (int i = 0; i < list.length - 1 - end; i++) {
            list.data[start + i] = list.data[end + 1 + i];
        }
        // 2.2 最重要的是，修改顺序表的 length 属性，删除了 end-start+1 个元素
        list.length -= end - start + 1;
    }

    /**
     * 打印顺序表
     */
    public void print() {
        String str = "[";
        for (int i = 0; i < list.length; i++) {
            str += list.data[i];
            if (i != list.length - 1) {
                str += ", ";
            }
        }
        str += "]";
        System.out.println(str);
    }
}

/**
 * 顺序表
 */
class List {
    /**
     * 数据域，保存数据的数组
     */
    int[] data;
    /**
     * 数组中实际元素个数
     */
    int length;
}

测试代码：

public class SeqListTest {
    public static void main(String[] args) throws Exception {
        // 实例化顺序表对象
        SeqList list = new SeqList();
        list.init();
        // 为顺序表添加测试数据
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.print();

        // 调用函数删除所有指定范围内的元素
        int s = 3, t = 7;
        list.deleteByRange(s, t);
        list.print();
    }
}

执行结果：

[1, 2, 3, 4, 5, 6]
[1, 2, 3]
二木成林
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
20、LeetCode 2021/1/31 27. 移除元素
qq_42847094的博客
01-31 567
20、LeetCode 2021/1/31 27. 移除元素 27. 移除元素 难度简单758 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 示例 1： 输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2] 解释：函数应该返回新的长度 2, 并且 nu
从有序顺序表中删除其值在给定值s与t之间（要求s ＜ t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。
qq_43687652的博客
03-23 899
#include<iostream> using namespace std; #define MaxSize 50 typedef int ElemType; typedef struct { int data[MaxSize]; int length; }sqList; bool Del_s_t2(sqList &L, ElemType s, ElemType t){ //删除有序顺序表L中值在给定值s与t之间的所有元素 int i,j; i
线性表删除元素
qq_40694323的博客
08-13 5022
1197: 线性表删除元素 时间限制: 1 Sec  内存限制: 128 MB 提交: 14  解决: 13 [提交][状态][讨论版][命题人:uzzoj] 题目描述 利用线性表顺序存储的动态存储，实现创建线性表，以及删除线性表中的某个元素 输入 输入包括：输入元素个数，以及相应的线性表元素，以及要删除的位置 输出 输出删除后的线性表 样例输入 5 1 2 3 4 5 3...
浙大数据结构案例3-1.1线性表元素的区间删除
m0_68361357的博客
09-12 149
其中List结构定义如下：/* 保存线性表中最后一个元素的位置 */ };L是用户传入的一个线性表，其中元素可以通过>、==、
从有序顺序表中删除其值在给定s与t之间（要求s＜t）的所有元素，如果s或t不合理或者顺序表为空，则显示出错信息并退出运行
weixin_45722215的博客
05-07 1469
#include <iostream> using namespace std; #define MaxSize 100 //定义线性表的最大长度 typedef struct Sqlist { int data[MaxSize]; int length; }Sqlist; //初始化 void Init(Sqlist& L) { L.length = 0; } //插入操作：在表中第i个位置上插入x void Insert(Sqlist&..
从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行
01-15
从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行
数据结构学习--线性表及其应用--顺序表
06-25
本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是可以实现随机存取，用数组对其进行定义， 主要操作时针对数组下标的运算。本实验相对比较简单，通过本实验，对顺序表...
小白算法积累——顺序表6#有序顺序表 +删除重复元素
01-07
题目：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 关键字：有序顺序表 删除重复元素 思路 关注：因为是有序表，所以值相同的元素一定在连续的位置上， 用类似于直接插入排序的思想 1.初始时...
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
代码对应的博客：https://blog.csdn.net/u011017694/article/details/109196934
C语言_线性表之顺序表
01-16
C语言实现顺序表，代码约200行，附赠测试案例(带菜单选择功能) 实现的操作： 1，头插、尾插、指定位置插 2，头删、尾删、指定位置和元素删除 3，求大小、判断是否为NULL 4，排序、查找、翻转
【数据结构】从有序顺序表中删除其值在给定值s与t之间（要求s＜t）的所有元素，如果s或t 不合理或者顺序表为空则显示出错信息并退出运行。
Anton的博客
09-16 1605
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #define MaxSize 100 typedef int ElemType; typedef struct{ ElemType data[MaxSize]; int length; }SqList; int Delst(SqList *, ElemType, ElemType); void print(SqList *); int main(int argc, char* argv[
2.2.5 从顺序表中删除其值在给定值s与t之间（包含s和t,要求s小于t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行
weixin_45837835的博客
03-27 350
从顺序表中删除其值在给定值s与t之间（包含s和t,要求s小于t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行 这题跟前两题很像，上一题我“误打误撞”的那个思路就刚好适用这题 void DelST(Sqlist& L, Elemtype s, Elemttype t) { int j = 0; if (s < t) { for (int i = 0; i < L.length; i++) { if (L.data[i] > s &&
王道数据结构2.2.3——4、从有序顺序表中删除其值在s与t之间的所有元素（包括s和t）
Hillbox
09-26 566
思路 因为顺序表是有序的，故只需用for循环找出第一个大于等于s的元素位置 i，再从 i 开始找大于t的元素，然后进行删除操作。 代码 bool del_st(SqList &L,ElemType s,ElemType t){ if(s>=t||L.length==0){ return false; } int i,j; //找...
顺序表-删除值在s~t之间的所有元素(无序)
qq_61706112的博客
09-09 172
/*从顺序表中删除其值在给定值s与t之间(包含s和t，要求s<t)的所有元素， 若s或t不合理或顺序表为空，则显示出错信息并退出运行*/ #include<stdio.h> #include<stdlib.h> #define InitSize 10 typedef int ElemType; typedef struct{ ElemType *data; int length; }SqList; bool InitList(SqList &L) { L.da.
从顺序表中删除其值在给定值s与t之间（包含s和t,要求s小于t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行
Mr____Cheng的博客
05-11 2648
题目： 从顺序表中删除其值在给定值s与t之间（包含s和t,要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行 算法思想： 第一步：从前往后扫描顺序表，用k纪录当前值在给定值s与t之间（包含s和t，s<t）的元素的个数 第二步：如果当前元素值满足s与t之间，则k++;如果当前元素值不满足s与t之间，则将当前元素前移k个位置 第三步：顺序表的长度-k 代码： bool Del_s_t2(Sqlist &L) { int k = 0;//用k纪录当前值在给定.
线性表的删除
weixin_34337265的博客
03-11 1519
　　学习了线性表之后发现删除的方式有多种多样，同时出题的方式也千奇百怪。 首先是最简单的删除：把要删除元素之后的元素全部往前挪，将欲删除的覆盖掉。 但是这种删除方式的局限性太大了，首先就是时间复杂度，这个算法的时间复杂度为O（n^2）. bool Delete( List L, Position P ) { int i; if(P>=L->Last|...
线性表顺序存储插入和删除新节点时平均移动次数
weixin_34080903的博客
10-31 7987
对于长度为n的顺序存储的线性表，当随机插入和删除一个元素时，需平均移动元素的个数是不同的。 1、当对n个元素进行插入操作时，有n+1个位置可以进行插入，如下所示（“.”代表可以插入的位置）。 .1.2.3.4. －－ .n. 在每个位置插入时需要移动的元素个数分别为n,n-1,n-2...,1,0，所以，总共需要移动的元素个数为(1+2+3+4+...+n)=n...
从有序顺序表中删除其值在给定s与t之间，（要求s小于t）的所有元素，如果s或t不合理或者顺序表为空则显示错误信息并退出运行
Miss_lanmao的博客
08-20 2112
#include<stdio.h> #include <stdlib.h> #include<iostream> using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 2 typedef struct { int *data; int length; in...
顺序表经典题目
qq_59961221的博客
10-09 688
1.删除最小值（假设唯一） //---------------------删除最小值（假设唯一）----------------------- //从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值 //若顺序表为空则显示出错信息并退出运行 //下面已经给出了函数名称和参数类型，删除L中的最小值，并用min_value返回， //把代码（包含注释）复制到b中，请完善函数主体内容，并在主函数中调用(注意在head.h中声明函数名) Status Del_Min(SqList &L,
从顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素如果s或t不合理或顺序
最新发布
05-01
顺序表是一种线性表，相邻元素之间的关系是顺序的。删除顺序表中某个范围内的元素可以通过遍历整个顺序表，将符合条件的元素删除。 具体实现的过程如下： 1. 首先判断s和t是否合理，若s>=t或s或t超出了表的范围，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值