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

于 2022-03-29 21:41:08 发布
阅读量400 收藏 3
点赞数
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123805622
版权

Example024

原文链接：Example024

题目

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

分析

本题考查的知识点：

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

分析：

  • 注意，本题题目中没有说明顺序表是有序的，所以可能顺序表中的元素是无序的，所以值在 [s, t] 范围的元素在顺序表中可能是离散分布的，而非像上一道题中是连续的。
  • 本题解法是包括边界的，即如果顺序表中有元素等于 s 或者 t，则是需要删除的。即删除顺序表中范围在 [s, t] 中的数。
  • 本题有两种解法，它们的时间复杂度是不同的。算法思想如下：
  • 第一种解法，从头到尾扫描顺序表，如果当前元素处于 [s, t] 范围内，则将该元素之后的所有元素都向前移动一位，移动完成之后顺序表的 length 减去 1；如果当前元素不在 [s, t]
    范围内，则继续顺序表的下一个元素的判断比较。
  • 第二种解法，从头到尾扫描顺序表，用一个变量 k 来记录在 [s, t] 范围内的元素的个数。对于当前扫描的元素，如果值不在 [s, t] 范围内则将该数前移 k 个位置；否则执行 k++。

图解

解法一图解：
请添加图片描述

解法二图解：
请添加图片描述

C实现

解法一核心代码：

/**
 * 删除顺序表中值在 [s, t] 之间的所有元素
 * @param list 顺序表
 * @param s 指定起始值，包括本身
 * @param t 指定结束值，包括本身
 */
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);
    }

    // 变量，记录扫描顺序表中元素的下标
    int i = 0;

    // 1.从头到尾扫描顺序表，通过双层 for 循环删除元素
    while (i < list->length) {
        // 1.1 如果当前元素处于 [s, t] 范围内
        if (list->data[i] >= s && list->data[i] <= t) {
            // 1.1.1 则将该元素之后的所有元素向前移动一位
            for (int j = i; j < list->length - 1; j++) {
                list->data[j] = list->data[j + 1];// 用后面的元素覆盖前一位的元素
            }
            // 1.1.2 移动之后顺序表的长度减 1
            list->length--;
        }
        // 1.2 如果扫描的当前元素不在 [s, t] 范围内
        else {
            // 1.2.1 则继续顺序表的下一个元素的判断比较
            i++;
        }
    }
}

解法二核心代码：

/**
 * 删除顺序表中值在 [s, t] 之间的所有元素
 * @param list 顺序表
 * @param s 指定起始值，包括本身
 * @param t 指定结束值，包括本身
 */
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);
    }

    // 变量，记录顺序表中不在 [s, t] 范围内的数
    int k = 0;

    // 1.从头到尾扫描顺序表
    for (int i = 0; i < list->length; i++) {
        // 1.1如果遇到的数在 [s, t] 范围内，则 k 加 1
        if (list->data[i] >= s && list->data[i] <= t) {
            k++;
        }
            // 1.2 如果遇到的数不在 [s, t] 范围内，则将该数前移 k 个位置
        else {
            list->data[i - k] = list->data[i];
        }
    }
    // 2.修改顺序表的 length
    list->length = list->length - k;
}

完整代码：

#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 指定结束值，包括本身
 */
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);
    }

    // 变量，记录顺序表中不在 [s, t] 范围内的数
    int k = 0;

    // 1.从头到尾扫描顺序表
    for (int i = 0; i < list->length; i++) {
        // 1.1如果遇到的数在 [s, t] 范围内，则 k 加 1
        if (list->data[i] >= s && list->data[i] <= t) {
            k++;
        }
            // 1.2 如果遇到的数不在 [s, t] 范围内，则将该数前移 k 个位置
        else {
            list->data[i - k] = list->data[i];
        }
    }
    // 2.修改顺序表的 length
    list->length = list->length - k;
}


/**
 * 打印顺序表
 * @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, 4);
    add(&list, 2);
    add(&list, 1);
    add(&list, 7);
    add(&list, 3);
    add(&list, 6);
    print(list);

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

执行结果：

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

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("顺序表为空，不能删除！");
        }

        // 变量，记录顺序表中不在 [s, t] 范围内的数
        int k = 0;

        // 1.从头到尾扫描顺序表
        for (int i = 0; i < list.length; i++) {
            // 1.1如果遇到的数在 [s, t] 范围内，则 k 加 1
            if (list.data[i] >= s && list.data[i] <= t) {
                k++;
            }
            // 1.2 如果遇到的数不在 [s, t] 范围内，则将该数前移 k 个位置
            else {
                list.data[i - k] = list.data[i];
            }
        }
        // 2.修改顺序表的 length
        list.length = list.length - k;
    }

完整代码：

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("顺序表为空，不能删除！");
        }

        // 变量，记录顺序表中不在 [s, t] 范围内的数
        int k = 0;

        // 1.从头到尾扫描顺序表
        for (int i = 0; i < list.length; i++) {
            // 1.1如果遇到的数在 [s, t] 范围内，则 k 加 1
            if (list.data[i] >= s && list.data[i] <= t) {
                k++;
            }
            // 1.2 如果遇到的数不在 [s, t] 范围内，则将该数前移 k 个位置
            else {
                list.data[i - k] = list.data[i];
            }
        }
        // 2.修改顺序表的 length
        list.length = list.length - k;
    }

    /**
     * 打印顺序表
     */
    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(7);
        list.add(3);
        list.add(3);
        list.add(4);
        list.add(2);
        list.add(6);
        list.print();

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

执行结果：

[7, 3, 3, 4, 2, 6]
[7, 2]
二木成林
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--每天一题-王道 -删除顺序线性表中s到t元素
weixin_46493164的博客
04-26 869
数据结构--每天一题-王道 leetcode -删除顺序线性表中s到t元素
2020王道课后习题P18，综合应用题4，5：从顺序表中删除其值在给定值S与T之间的所有元素。
weixin_42426690的博客
06-27 1056
2020王道课后习题P18，综合应用题4：从顺序表中删除其值在给定值S与T之间的所有元素。要求（S<T）,此题难度较小，代码如下： #include<stdio.h> #include<stdlib.h> #include<time.h> #define InitSize 100 typedef int ElemType; typedef struct...
从顺序表中删除其值在给定值s与t之间的所有元素
bravvve_dreamer的博客
04-23 8460
问题描述：从顺序表中删除其值在给定值s与t之间（包含s和t，要求s&lt;t）的所有元素。情况1：有序顺序表。分析：因为是有序表，所以删除的元素必然是相连的整数。于是，我们可以先寻找值大于等于s的第一个元素（即第一个删除的元素），然后再寻找大于t的第一个元素（即最后一个删除的元素的下一个元素），要讲这段元素删除，则只需直接将后面大于t的元素前移就可以了。void del_1(int *a, int...
从有序顺序表中删除其值在给定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 之间的所有元素
笔生花的博客
07-11 724
解析：题目中的意思是删除 所有大于等于s 小于等于 t的所有的有序表的元素，加入有如下的列表。假设此时s 为3，t为7 也就是说此时要删除表格中所有红色部分的元素。 思路： 因为表是有序的，所以说找到第一个要删除的元素的位置，也就是图片中两个箭头之间的所有数据都需要删除。 既然如此，只需要找到第一个要删除的元素的位置，以及第一个不被删除的元素的位置 然后将要保留的元素整个平移到被删除的元素的位置即可。 c++伪代码如下：for 循环跳出的时候意味着当前元素的下标不满足条件。 找到第一个...
数据结构学习--线性表及其应用--顺序表
06-25
本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是可以实现随机存取，用数组对其进行定义， 主要操作时针对数组下标的运算。本实验相对比较简单，通过本实验，对顺序表...
从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行
01-15
从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行
线性表--顺序表操作
12-12
这有线性表的操作:顺序存储,链存储结构, 单链表,顺序表,循环链表,双向链表
C语言_线性表之顺序表
01-16
C语言实现顺序表，代码约200行，附赠测试案例(带菜单选择功能) 实现的操作： 1，头插、尾插、指定位置插 2，头删、尾删、指定位置和元素删除 3，求大小、判断是否为NULL 4，排序、查找、翻转
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
代码对应的博客：https://blog.csdn.net/u011017694/article/details/109196934
删除顺序表中的元素
10-26
利用顺序表的操作，实现以下函数： （1）从顺序表中删除具有最小值的元素并由函数返回被删元素的值，空出的位置由最后一个元素填补。 （2）从顺序表中删除具有给定值x的所有元素。 （3）从有序顺序表中删除其值在给定值s与t之间（s<t）的所有元素，
顺序表-删除值在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纪录当前值在给定.
【数据结构】从有序顺序表中删除其值在给定值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[
从有序顺序表中删除其值在给定值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
王道数据结构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之间的所有元素
vivi_and_qiao的博客
09-18 3489
typedef int type; typedef struct { int len; type data[MAX]; }sqList; int delsure4(sqList *a,type min,type max) { int k; if(min&gt;=max||a-&gt;len&lt;=0) return -1; for(int i=0;i...
在无序顺序表中删除s-t之间的元素
lz846525719的博客
09-06 582
删除无序顺序表中的元素 为了使算法更高效，我们只需用k记录下扫描过程中在s-t之间元素的个数，然后将不再区间内的往前平移K即可，代码如下： #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define initsize 100 typedef int Datatype; typedef struct{ Datatype *data; in...
王道课后习题2.2.4：有序顺序表中删除值在给定s与t之间的所有元素
qq_34941153的博客
08-16 685
题目描述： 从有序顺序表中删除值在给定s与t之间的所有元素，要求s<t。 算法思想： 算法思想： 【0,1,2,3,4,5,6,7】删除[3,5]之间的即删除元素3,4,5。s为3，t为5。 1.找到与s相等的第一个元素和等于t的第一个元素，记录下标a[3],a[5] 2.往前覆盖元素 3.修改length 核心代码： int del_s_t(SqList &L,int s,...
从顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素如果s或t不合理或顺序
最新发布
05-01
顺序表是一种线性表，相邻元素之间的关系是顺序的。删除顺序表中某个范围内的元素可以通过遍历整个顺序表，将符合条件的元素删除。 具体实现的过程如下： 1. 首先判断s和t是否合理，若s>=t或s或t超出了表的范围，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值