精华内容
下载资源
问答
  • 删除线性表中重复元素
    2021-05-19 08:42:20

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    帮你改好了:

    #include

    #include

    #define    MAXSIZE    20

    typedef    int datatype;

    typedef struct

    {datatype    data[MAXSIZE];

    int    last;    /*顺序表中最后一个元素的序号*/

    }SeqList;

    /*创建顺序表*/

    void    input(SeqList *L)

    {int i,x;

    i=0;

    printf("\n输入顺序表元素值,-1结束:");

    scanf("%d",&x);

    while(x!=-1)

    {L->data[i]=x;i++;

    if(i==MAXSIZE)printf("表空间已满!");

    else scanf("%d",&x);

    }

    L->last=i-1;

    }

    /*删除重复元素*/

    void Del(SeqList *L)

    {int i,j,k,h;

    h=(*L).last;                                            // len改成last

    if(h==0)

    printf("List is empty\n");

    else

    for(i=0;i

    for(j=i+1;j

    {if((*L).data[j]==(*L).data[i]) /*找相同元素*/

    {for(k=j;k

    (*L).data[k]=(*L).data[k+1]; /*元素前移*/

    (*L).last--;                                          // len改成last

    }

    }

    }

    /*输出顺序表*/

    void output(SeqList    *L)

    {int i;

    printf("\n输出顺序表中的各个元素值:\n");

    for(i=0;i<=L->last;i++)

    printf("%d    ",L->data[i]);

    }

    /*主函数*/

    void main()

    {SeqList *L;

    L=(SeqList    *)malloc(sizeof(SeqList));

    input(L);

    Del(L);

    output(L);

    //getch();                                       // 注释掉这句

    }

    更多相关内容
  • 删除线性表相同元素

    2015-11-26 17:36:53
    删除线性表相同元素的代码,以运行
  • 删除有序线性表中所有重复元素
    #include <bits/stdc++.h>
    
    using namespace std;
    
    const int MAX_N = 1e4;
    
    typedef struct SqList
    {
        int data[MAX_N];
        int length;
    } SqList;
    
    void deleteRepeat(SqList &L)
    {
        int k = 0;
        for (int i = 0; i < L.length; i++)
        {
            if (i == 0 || L.data[i] != L.data[i - 1])
            {
                L.data[k] = L.data[i];
                ++k;
            }
        }
        L.length = k;
    }
    
    int main()
    {
        SqList L;
        L.data[0] = 1;
        L.data[1] = 2;
        L.data[2] = 3;
        L.data[3] = 3;
        L.data[4] = 7;
        L.data[5] = 7;
        L.data[6] = 7;
        L.data[7] = 7;
        L.data[8] = 8;
        L.data[9] = 10;
        L.length = 10;
        cout << "begin: ";
        for (int i = 0; i < L.length; i++)
        {
            cout << L.data[i] << " ";
        }
        deleteRepeat(L);
        cout << "\nafter: ";
        for (int i = 0; i < L.length; i++)
        {
            cout << L.data[i] << " ";
        }
        return 0;
    }
    
    展开全文
  • 线性表——删除重复元素

    千次阅读 2021-09-16 20:30:41
    题目:移除线性表中的所有重复元素;不要使用额外的数组空间,在使用 O(1) 额外空间的条件下完成。 typedef int DataType; struct seqList { int MAXNUM; // 能存放的最大元素个数 int curNum; // 数据...

    题目:移除线性表中的所有重复元素;不要使用额外的数组空间,在使用 O(1) 额外空间的条件下完成。

    typedef int DataType;
    struct seqList
    {
      int MAXNUM;				// 	能存放的最大元素个数   
      int curNum;				// 	数据元素的个数  
      DataType *element;		
    };
    typedef struct seqList *PseqList;
    

    实现的两种思路

    void delDuplicate_seq(PseqList L){
    	for(int i=0;i<L->curNum;){
        	int ret=0;										// 判断该元素是否为重复值 
        	for(int j=i+1;j<L->curNum;){
          		if(L->element[j]==L->element[i]){
            		deletePos_seq(L,j);								// 对位置在下标 i 之后的 进行删除。		如果进行了删除,就不用 j++,因为下面的元素已经移到刚才的位置上了。
            		ret=1;		// 标记 位置 i上的元素是重复元素 
          		}else{
              		j++;              
          		}      
        	}
    		if(ret){
          		deletePos_seq(L,i);							// 删除下标为 i的元素 本身。
        	}else{
          		i++;
        	}
      	}
    }
    
    void delDuplicate_seq(PseqList L){
    	for(int i=0;i<L->curNum;){
        	int ret=1;
        	for(int j=i+1;j<L->curNum;j++){
          		if(L->element[j]==L->element[i]){
            		delete_seq(L,L->element[i]);				// 删除所有值为 element[i]的元素
            		ret=0;
            		break;
          		}
        	}
        	if(ret){
          		i++;						// 如果 位置 i上的元素不是重复值,则跳到下一个index。如果是重复值,则不用跳到下一索引,因为删除操作会自动移位。
        	}  
      	}
    }
    

    附调用的函数:

    int delete_seq(PseqList L,int x)
    {	// 删除与x值相同的数据元素,返回删除数据元素的个数
      //可以使用之前已完成的操作
        int count=0;
      while(locate_seq(L,x)>=0){
        deletePos_seq(L,locate_seq(L,x));
        count++;
      }
      return count; 
    }
    
    // 给定值x首次出现的位置,若不存在,则返回-1
    int locate_seq(PseqList L,int x){
        for(int i=0;i<L->curNum;i++){
          if(L->element[i]==x){
            return i;
          }
        }return -1;
    }
    
    int deletePos_seq(PseqList L,int pos)
    {	// 删除下标pos处的数据元素,若pos非法,则返回-1;否则返回1
        if(pos<0||pos>=L->curNum){
          return -1;
        }
        for(int q=pos;q<L->curNum-1;q++){
          L->element[q]=L->element[q+1];
        }
        L->curNum=L->curNum-1;
        return 1;
    }
    

    在这里插入图片描述

    展开全文
  • 删除线性表中重复元素

    千次阅读 2017-02-27 17:32:05
    一、leetcode原题:删除已排序数组重复元素 先给出leetcode原题照片: 原题大意就是对于一个已经排好序的数组,删除重复元素。要求空间复杂度为O(1)。也就是不能重新申请新的数组。 解题思路:对于已经排好序的...

    小记:烦躁ing,看不进去其它东西,就来刷刷leetcode的题目,今天刷到一道比较基础的删除已排序数组的题目,感觉很典型,就记录了一下。

    一、leetcode原题:删除已排序数组重复元素

    先给出leetcode原题:

    Given a sorted array, remove the duplicates in place such that each element appear only once and return the new length.
    
    Do not allocate extra space for another array, you must do this in place with constant memory.
    
    For example,
    Given input array nums = [1,1,2],
    
    Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the new length.

    原题大意就是对于一个已经排好序的数组,删除重复元素。要求空间复杂度为O(1)。也就是不能重新申请新的数组。

    解题思路:对于已经排好序的数组,那么重复元素必然是聚集在一起的,也就是属于前驱后继的关系,所以可以通过比较相邻的元素进行删除。

    1.空间换时间的方法(哈希思想)

    如果不考虑空间的话,可以申请一个新的数组arrayFlag[n],这个数组的大小n必须要满足大于或者等于给定数组的最大值。这个时候的哈希思想就是:以原数组的的值作为下标,那么这样一个下标就只能对应一个元素,即使哈希一个重复的元素到同一下标,也只能存储一次。

    for(int i = 0;i <array.size();i++)
    {
           arrayFlag[array[i]] = array[i];
    }
    
    for(int j = 0;j < arrayFlag.size(),j++)
    {
            if(arrayFlag[j] != False)
                  array[newSize++] = arrayFlag[j];
    }

    以上这种方法针对于无序数组也适用,但是缺点是新的生成的数组是不固定的,它是随着原数组的最大元素决定的,所以不是很适合大数据。


    2.逆向思维:保存不相同的元素(leetcode上的解决办法)

    删除重复的元素,所以对于不相同的元素是需要存储保留起来的,那么我们可以设置一个变量就是存储数组中不同元素的个数。具体的算法如下:

    class Solution {
    public:
        int removeDuplicates(vector<int>& nums) {
            int newSize = 1;
            if(nums.size() <= 1)
                return nums.size();
            for(int i = 1;i < nums.size();i++){
                if(nums[i] != nums[i-1]){
                    nums[newSize] = nums[i];
                    newSize++;
                    }
                }
            return newSize;
        }
    };
    

    以上算法的优点在于时间和空间复杂度都是目前最低的情况了。用一个变量newSize来存储不同的元素个数,如果前后两个元素不同,那么就保存不同的元素。需要注意的是如果只有一个元素或者为空数组,那么就返回数组原来的大小即可。还需要注意的是newSize的初始值是1,如果是0的话,那么就会在只有两个相同元素的数组总出现错误。

    当然,这种思想也可以用在删除某个给定的数组元素,保留不等于给定元素的的其它元素,然后就可以在O(n)的时间复杂度内实现删除某个给定的元素了。(leetcode中的另外 一题)


    二、拓展:删除线性表中的重复元素

    1.删除无序数组中的重复元素

    之前在一中提到的第一种方法也是可以针对无序数组的情况,第二种方法在针对无序数组之前,可以先调用其它一些排序算法对其进行排序。

    2.删除无序链表中的重复元素

    线性表中除了数组,还有链表,针对链表的删除重复元素,可以采用最能想到的算法:就是重新构造一个链表。先遍历,从第一个元素开始依次将所有的元素都与其它元素进行比较,就可以得到一个新的没有重复元素的链表,这种情况下的时间复杂度会是O(N^2).


    以上就是刷到这题之后的一个想法,欢迎补充。

    展开全文
  • 包含一个函数,参数为链表表头地址,返回经过处理的新的链表表头地址。该函数将一个按照升序排列的链表重复元素删除,时间复杂度为(n)
  • 题目:给定一个长度为n(n≤10000)的非递减序列a,删除其中所有的重复元素,得到一个严格单调递增序列。例如:输入 n=5 ,元素为 1 2 3 2 4,输出1 2 3 4 以下是题目解析: 小伙伴们觉得不错的话给个赞赞吧~ /*...
  • 若存储方式为单链表,设计算法去掉数值相同的元素,使表不再有重复元素。 输入 输入长度:6 输入数据:2 3 4 5 5 7 输出 2 3 4 5 7 样例输入 6 8 9 10 11 22 22 样例输出 8 9 10 11 22 提示 #...
  • 将一个递增有序的线性表中重复元素删去。 2.基本思想: 1. 跳过重复元素: 利用*p指向最后一个不重复的指针,num记录最后一个不重复的data,当遇到重复元素时,L=L->next;当遇到不重复值时,p->next=L,num...
  • #include <stdio.h> using namespace std; #define Max 50 struct SqlList{ int a[Max]={1,2,3,3,3,5,5,7,7,8,9,10,11,11,22,22,23}; int length=17; };... printf("线性表为空\n"); ...
  • 1.假如有一串数据元素,要求删除其中的重复元素。 首先想到的是用两层循环,第一层从第一个元素开始,第二层从第一层元素的下一个元素开始。 就是假如第一层是ai元素,则第二层就为ai+1元素。 函数实现: 1 ...
  • 满意答案puiawxsj1推荐于 2017.11.25采纳率:40%...因为你没有写出具体的线性表,所以我假设该线性表是需要手动输入的!代码如下运行通过:#include #include #include typedef int ElemType;typedef struct Node{...
  • //该程序用于删除递增排列的线性表中重复元素
  • 83. 删除排序链表重复元素 给定一个排序链表,删除所有重复的元素,使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 示例 2: 输入: 1->1->2->3->3 输出: 1->2->3 直观...
  • 本博文源于博主的一次数据结构的练习,标题为:删除线性表中值相同的元素(值相同的元素仅保留第一个)。博文里含有对其完整源码实现,并对其进行人脑试运行代码,堪比是新手菜鸟级别教程.
  • 删除顺序表重复数据,数据表有数据重复时, 保留最前面的数据,删除后面的重复数据。 请注意,本题有预置代码,只需提交所要求的函数定义代码即可。 预置代码: ...
  • #include <stdio.h> #include <stdlib.h> typedef struct number //定义结构体,NUM为结构体变量名 { int date; struct number *link; //指向下一个结点的指针 struct number *before;...del.
  • 删除线性表(数组)重复元素

    千次阅读 2013-06-26 19:23:34
    typedef int datatype;     typedef struct _seqlist {  datatype data[20];... //表最后一个元素的下标,从0开始。-1表示该线性表为空表  }seqlist; int del_repeat_seqlist(seq
  • 第08话:线性表删除某个元素

    千次阅读 2021-03-16 21:58:23
    根据之前定义的线性表ADT,现在还剩下一个操作,就是删除了。今天把这个操作弄完。了解线性表的插入,就很容易理解线性表删除了。删除就是插入的逆过程。删除算法的思路:如果删除位置不合理,抛出异常;取出删除...
  • 删除线性表中所有值为x的数据元素,要求时间复杂度为O(n),空间复杂度为O(1)。删除线性表中所有值重复的数据元素
  • #include<bits/stdc++.h> using namespace std; int main() { int data[]={1,2,2,2,2,2,3,3,4,4,5}; int lenghth=11; int i,j; for(i=0,j=1;j<lenghth;j++){ if(data[i]!=data[j]) ...k.
  • 从有序顺序表中删除所有其值重复元素,使表所有元素的值均不同。
  • 题目 .../* 删除顺序表重复元素 */ /* &list指的是要执行删除重复元素操作的顺序表 */ void deleteRe(SqlList &list){ for(int i=0;i<list.length-1;i++){ if(list.a[i]==list.a
  • 合并两个线性表中元素,相同的元素只保留一个 SeqList.h #pragma once #define ListSize 200 #include &lt;iostream&gt; using namespace std; typedef int DataType; typedef struct { DataType list...
  • 前言  第一次写博客,问题虽然简单,但是我写的很认真的,,尽量将... 在一堆数据可能存在重复的数据,请将重复删除,只留下独一无二的值。  例如:1,2,2,6,2,2,6,9,6  删除后:1,2,6,9 2.思路分析 ...
  • 文章目录删除排序数组重复项java解决python也可以一行搞定移除元素java解决方案python解决方案 删除排序数组重复项 java解决 1.排序后比较 对数组进行排序,然后遍历数组, 如果 i +1 = i 的value 就把这个数...
  • 这个问题跟前面的删除所有值为X的相似,主要的思想就是用了一个指针,表示当前有效元素的位置 #include <iostream> #include <string.h> #include <time.h> using namespace std; #define ...
  • 一个长度不超过10000数据的顺序表,可能存在着一些值相同的“多余”数据元素(类型为整型),编写一个程序将“多余”的数据元素从顺序表中删除,使该表由一个“非纯表”(值相同的元素在表可能有多个)变成一个...
  • 用c语言去实现线性表的合并,删除重复(不重新排序) 老师留了一个作业,有两个集合A和B,设A={7,5,3,11},B={2,6,3},合并后A={7,5,3,11,2,6} 自己没有思路百度了好久,找到的大多都是其他语言的,要不就是直接重新排序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,265
精华内容 7,306
热门标签
关键字:

删除线性表中重复元素