线性表练习之Example025-从有序顺序表中删除所有其值重复的元素

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

Example025

原文链接：Example025

题目

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

分析

本题考查的知识点：

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

分析：

  • 本题中的顺序表是有序顺序表，所以所有的重复值元素是连续相邻的。
  • 本题有两种解法，它们的时间复杂度都不一样，如下：
  • 第一种解法，从头到尾扫描顺序表，比较顺序表中的相邻元素是否相等。如果相等则用后面的所有元素向前移动一位，并且顺序表长度减 1；如果不相等则继续比较顺序表的下一对相邻元素。
  • 第二种解法，设定两个变量 i 和 j 都用来存放顺序表下标，其中 i 指向顺序表中非重复元素，而 j 从头到尾扫描顺序表（从第二个元素开始，初始时将第一个元素视为非重复元素）。之后依次判断 i 和 j
    所指向的元素是否相等，如果相等则 j 继续前进直到遇到不等的情况；如果不相等则让 i 加 1（因为初始第一个元素是非重复元素，所以要让下一个位置来存储非重复元素），然后存储 j
    所表示的非重复元素，直至判断道表尾为止。该解法的时间复杂度为 O(n)，推荐学习。

图解

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

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

C实现

解法一核心代码：

/**
 * 删除顺序表中连续重复的元素
 * @param list 有序顺序表
 */
void deleteRepeat(SeqList *list) {
    // 记录顺序表中元素的下标
    int i = 0;

    // 1.从头到尾扫描顺序表中所有元素，但注意由于要相邻元素比较是否相等，所以循环结束的条件是 i<list.length-1，如果是 i<list.length 则会超出边界报错
    while (i < list->length - 1) {
        // 1.1比较相邻元素是否相等
        if (list->data[i] == list->data[i + 1]) {
            // 1.1.1 如果相等则将后面的所有元素都向前移动一位，删除相邻元素
            for (int j = i; j < list->length - 1; j++) {// 注意结束条件是 j<list->length-1，而不是 j<list->length
                list->data[j] = list->data[j + 1];// 后面的元素覆盖前面的元素
            }
            // 1.1.2 删除元素后，记得将 length 属性减去 1
            list->length--;
        }
        // 1.2 如果不相等，则继续比较下一个元素，即将 i 变量指向顺序表的下一个元素
        else {
            i++;
        }
    }
}

解法二核心代码：

/**
 * 删除顺序表中连续重复的元素
 * @param list 有序顺序表
 */
void deleteRepeat(SeqList *list) {
    // 变量，指向顺序表中非重复元素的下标，初始时将第一个元素视为非重复元素
    int i = 0;
    // 变量，从头到尾扫描顺序表，从第二个元素开始
    int j = 1;

    // 从头到尾扫描顺序表
    while (j < list->length) {
        // 如果 i 指向的元素与 j 指向的元素不相等
        if (list->data[i] != list->data[j]) {
            // 则变量 i 加 1，因为初始第一个元素已经被视为非重复元素了，所以要下一个位置来存放这个非重复元素 data[j]
            i++;
            // 让 i 位置来存放非重复元素 data[j]
            list->data[i] = list->data[j];
        }
        // 继续顺序表的下一个元素
        j++;
    }
    // 删除后，修改顺序表的 length，其中 i+1 就是非重复元素的个数
    list->length = i + 1;
}

完整代码：

#include <stdio.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;
}

/**
 * 删除顺序表中连续重复的元素
 * @param list 有序顺序表
 */
void deleteRepeat(SeqList *list) {
    // 记录顺序表中元素的下标
    int i = 0;

    // 1.从头到尾扫描顺序表中所有元素，但注意由于要相邻元素比较是否相等，所以循环结束的条件是 i<list.length-1，如果是 i<list.length 则会超出边界报错
    while (i < list->length - 1) {
        // 1.1比较相邻元素是否相等
        if (list->data[i] == list->data[i + 1]) {
            // 1.1.1 如果相等则将后面的所有元素都向前移动一位，删除相邻元素
            for (int j = i; j < list->length - 1; j++) {// 注意结束条件是 j<list->length-1，而不是 j<list->length
                list->data[j] = list->data[j + 1];// 后面的元素覆盖前面的元素
            }
            // 1.1.2 删除元素后，记得将 length 属性减去 1
            list->length--;
        }
        // 1.2 如果不相等，则继续比较下一个元素，即将 i 变量指向顺序表的下一个元素
        else {
            i++;
        }
    }
}


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

    // 调用函数进行删除
    deleteRepeat(&list);
    print(list);
}

执行结果：

[1, 1, 2, 2, 3, 3]
[1, 2, 3]

Java实现

核心代码：

    /**
 * 删除顺序表中连续重复的元素
 */
public void deleteRepeat(){
        // 记录顺序表中元素的下标
        int i=0;
        // 从头到尾扫描顺序表中所有元素，但注意由于要相邻元素比较是否相等，所以循环结束的条件是 i<list.length-1，如果是 i<list.length 则会超出边界报错
        while(i<list.length-1){
        // 比较相邻元素是否相等
        if(list.data[i]==list.data[i+1]){
        // 如果相等则将后面的所有元素都向前移动一位，删除相邻元素
        for(int j=i;j<list.length-1;j++){
        list.data[j]=list.data[j+1];// 后面的元素覆盖前面的元素
        }
        // 删除元素后，记得将 length 属性减去 1
        list.length--;
        }else{
        // 如果不相等，则继续比较下一个元素，即将 i 变量指向顺序表的下一个元素
        i++;
        }
        }
        }

完整代码：

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++;
    }

    /**
     * 删除顺序表中连续重复的元素
     */
    public void deleteRepeat() {
        // 记录顺序表中元素的下标
        int i = 0;
        // 从头到尾扫描顺序表中所有元素，但注意由于要相邻元素比较是否相等，所以循环结束的条件是 i<list.length-1，如果是 i<list.length 则会超出边界报错
        while (i < list.length - 1) {
            // 比较相邻元素是否相等
            if (list.data[i] == list.data[i + 1]) {
                // 如果相等则将后面的所有元素都向前移动一位，删除相邻元素
                for (int j = i; j < list.length - 1; j++) {
                    list.data[j] = list.data[j + 1];// 后面的元素覆盖前面的元素
                }
                // 删除元素后，记得将 length 属性减去 1
                list.length--;
            } else {
                // 如果不相等，则继续比较下一个元素，即将 i 变量指向顺序表的下一个元素
                i++;
            }
        }
    }

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

        // 调用函数删除所有重复的元素
        list.deleteRepeat();
        list.print();
    }
}

执行结果：

[2, 2, 3, 3, 3, 5]
[2, 3, 5]
二木成林
关注
  • 8
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
王道课后习题2.2.6：从有序顺序表中删除所有其值重复的元素
qq_34941153的博客
08-16 1571
题目描述： 从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 算法思想： 核心代码： int del_repeat_elment_3(SqList &L) { int i=0; for(int j=1;j<L.length;j++) { if(L.data[i]!=L.data[j]) L....
从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行
01-15
从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最基本的一个。线性表按存储结构分，可 分为顺序表和链表，它们各有特色。本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是可以实现随机存取，用数组对其进行定义， 主要操作时针对数组下标的运算。本实验相对比较简单，通过本实验，对顺序表基本操作及 其组合应用的演练，加深对线性表顺序存储方法及其基本操作的理解，为以后进一步学习更 复杂的数据结构打下基础。
从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同
weixin_41554427的博客
01-07 2762
由于是有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否是与前面非重复有序表的最后一个元素相同，若相同则继续向后判断，若不同则插入到前面的非重复有序表的最后，直至判断到表尾为止。 #define InitSize 100 typedef struct{ ElemType *data; int MaxSize; int length; }SeqList; bool Delete_Same(Seq
从有序顺序表中删除其值重复的元素 C++实现
m0_53171456的博客
03-04 4512
文章目录1.例题2.算法思想3.代码演示4.运行结果 1.例题 （1）题目描述 从一个长度为N有序顺序表中删除所有其值重复的元素，使表中所有元素均不同。 （2）输入样例： 11 1 2 2 2 3 3 5 6 4 4 7 (3) 输出样例： 2.算法思想 3.代码演示 4.运行结果 ...
数据结构之从有序的顺序表中删除所有其值重复的元素，使表中的元素均不相同
热门推荐
mmayanshuo的博客
09-30 1万+
题目：从有序的顺序表中，删除所有其值相同的元素，使表中的所有元素的值均不相同。算法思想：因为是顺序表，用类似于直接插入排序的思想，将第一个元素看作非重复的有序表，之后依序判断后面的元素是否和前面非重复的有序表中的最后一个元素相同，相同则舍弃，不同则加入有序表，直至判断到表尾。#include<stdio.h> #include<stdlib.h> #include<stdbool.h> #defin
顺序表之有序顺序表重复元素删除
sinat_41613258的博客
06-16 5935
（2.2.4-6）从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 不考虑时间复杂度，空间复杂度为o(1) 思路：例SqList L = { 1, 2, 2, 3, 4, 4 },将每一个元素与之后面的元素进行比较，1与2比较不相等不做任何处理，1再次与2比较不做任何处理，1与3比较不做任何处理…1与之后面的所有元素比较不做任何处理；2与2比较，相同第2个2删除即需要将之后的元素向前移动，3需要向前移动1步（即此轮（即内层循环的重复数）遍历的重复次数），后面的两个4需要向前移动1步；
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
代码对应的博客：https://blog.csdn.net/u011017694/article/details/109196934
数据结构与算法c++实现 删除顺序表中大于x的元素
06-04
数据结构与算法c++实现 删除顺序表中大于x的元素 可直接运行 适合初学数据结构与算法大二学生
C语言_线性表之顺序表
01-16
C语言实现顺序表，代码约200行，附赠测试案例(带菜单选择功能) 实现的操作： 1，头插、尾插、指定位置插 2，头删、尾删、指定位置和元素删除 3，求大小、判断是否为NULL 4，排序、查找、翻转
从有序表中删除所有其值重复的元素
bravvve_dreamer的博客
04-23 5748
问题描述：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同。方法一：用k记录顺序表a中不重复的元素的个数，用temp记录不重复的元素。在遍历过程中让每个元素与temp比较，若该元素与temp不同则统计k的个数并将该不重复的元素向前放置在k位置上，若相同则是重复元素则继续向后判断，直至判断到表尾为止。void delRept_1(int *a, int &amp;n) { int ...
有序表删除重复元素
已末的博客
08-07 1342
有序表删除重复元素
【数据结构】从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。
Anton的博客
09-16 1262
#include <stdio.h> #include <stdlib.h> #define N 8 // 定义结构体 typedef struct node{ int data; struct node * next; }ElemSN; // 创建链表 ElemSN * CreatLink(int a[]) { ElemSN *head, *tail; // 创建第一个结点 head = tail = (ElemSN *)malloc(sizeof(ElemSN
关于数据结构中线性表的顺序存储结构删除相同的数据
m0_63993103的博客
03-18 1204
顺序表中相同元素进行删除，避开bug
删除有序顺序表中所有重复的元素
qq_43148788的博客
01-02 2988
算法思想： 等同于设置快慢指针，快指针寻找与慢指针所指元素不等的元素，慢指针扫描整个顺序表，一旦找到不相等的元素，慢指针就向前走一步，并且赋值为快指针所指向元素。这样就可以保证， 慢指针每向前走一步所被赋值的元素都是不重复的，一遍下来，就可以删除所有重复的元素。 代码如下： void DeleteSimple(SeqList &L){ int i,j; for(i=0, j=1; j<L.lengh; j++) if(L.data[i]!=L.data[j]) L.data[++
从有序顺序表中删除所有其值重复的元素（用不同的负数代替），使所有元素的值均不同。
最新发布
猪儿君的博客
06-24 541
题目要求：从有序顺序表中删除所有其值重复的元素（用不同的负数代替），使所有元素的值均不同。 0：有序顺序表 1：删除所有其值重复的元素 2：用不同的负数代替 3：顺序表中所有元素的值均不同
顺序表元素的多种删除方式——删除重复元素和删除掉所有相同元素
weixin_52211313的博客
09-20 8847
大家好，初来乍到请多关照~ 最近老师给留的编程作业里有一道题让我相当困惑：题目是这个样子的： 任务描述 本关任务： （1）使用将顺序表L中值为x的数据元素替换为y； （2）此处假设线性表中的元素用于表示集合，不考虑线性表中元素的位置，移除线性表中的所有重复元素；不要使用额外的数组空间，必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。 第一个替换元素的代码很简单，直接遍历顺序表里的元素，如果相同将其赋值为目标元素。 以下为replace_seq函数的代码： void re
A - 顺序表应用1：多余元素删除之移位算法
weixin_45726784的博客
10-21 741
A - 顺序表应用1：多余元素删除之移位算法 Description 一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。 要求： 1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能； 2、本题的目标是熟悉顺序表的移位算法，因此题目必须要用元素的移位实现删除； Input 第一行输入
【数据结构—顺序表】顺序表中删除所有其值重复的元素
wanshuai12138的博客
11-21 2761
【数据结构—顺序表】顺序表中删除所有其值重复的元素 描述：有了一个顺序表（a 0 ,a 1 ,…,a n-1），元素中可能存在重复的值，元素是无优先的，从顺序表中删除其值重复的所有元素，即值相同的元素仅仅保留一个，输出删除后的顺序表。要求：该删除函数不属于类的成员函数，定义一个独立的函数，通过使用顺序表的基本操作（即成员函数）实现。 #include<iostream> using namespace std; void shanchu(int a[],int *n){ int i=0,j=*
线性表-顺序存储-删除重复元素
03-31
思路：遍历线性表，将不重复的元素依次存放在前面的位置上，记录不重复元素的个数，最后将多余的元素删除。 具体实现： 1. 初始化一个变量count表示不重复元素的个数，初始值为1，因为第一个元素一定不重复。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值