精华内容
下载资源
问答
  • 数据结构实验 有两个非递增有序的线性表A和B,采取顺序存储将两个合并成C,然后删除C中相同元素的多余元素
  • 题目:从有序顺序表中删除所有其值重复的元素,使表所有元素的值均不同。 关键字:有序顺序表 删除重复元素 思路 关注:因为是有序表,所以值相同元素一定在连续的位置上, 用类似于直接插入排序的思想 1.初始时...
  • 删除顺序表中值相同的多余元素

    万次阅读 多人点赞 2018-06-11 10:11:00
    设计并验证一下算法:设顺序表L的数据元素为整数且非递增有序,删除其值相同的多余元素,即顺序表L中相同元素只保留一个,并逆置删除后的顺序表L。(1)根据键盘输入数据建立顺序表L。(2)输出顺序表L、删除值...

    设计并验证一下算法:设顺序表L中的数据元素为整数且非递增有序,删除其值相同的多余元素,即顺序表L中相同的元素只保留一个,并逆置删除后的顺序表L。

    (1)根据键盘输入数据建立顺序表L。

    (2)输出顺序表L、删除值相同的多余元素后的顺序表L、逆置的顺序表L。

    (3)假设顺序表L长度为n,要求以O(n)的时间复杂度完成对值相同多余元素的删除。

    实验代码:

    #include <stdio.h>
    #include <malloc.h>
    #define LIST_INIT_SIZE 100 
    typedef int ElemType;
    typedef struct{
        ElemType *elem;//存储空间基址
        int length;  //当前长度
    }SqList; 
    void InitList(SqList *l){ //初始化顺序表 
      l->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
      l->length=0;
    }
    void CreateList(SqList *l){//创建顺序表   
      int data,i=0;
      scanf("%d",&data);
      while(!(data<0)){
      	  l->elem[i++]=data;
      	  l->length++;
      	  scanf("%d",&data);
      }
    }
    void print(SqList list){//打印顺序表 
    	int i=0;
    	while(i<list.length){
    		printf("%d ",list.elem[i++]);
    	}
    	printf("\n");
    }
    void distinc(SqList *l){//去除重复元素
    	int *p,*q,*r=l->length+l->elem;
    	for(p=l->elem,q=p+1;q<r;q++){
    		if(*p!=*q){
    		 *(p+1)=*q;
    			 p++;
    		}else{ 
    			l->length--;
    		}
    	}
    }
    void swap(ElemType *a,ElemType *b){//交换两个数 
    	ElemType temp;
    	temp=*a;
    	*a=*b;
    	*b=temp; 
    }
    void reverse(SqList l){//逆置顺序表 
    	int i;
    	for(i=0;i<l.length/2;i++){
    		swap(l.elem+i,l.elem+l.length-1-i);
    	}
    }
    int main(){
    	while(1){
    		SqList L;
    		InitList(&L);
    		printf("输入正整数:(负数代表结束输入)\n");
    		CreateList(&L);
    		printf("去除重复元素:");
    		distinc(&L);
    		print(L);
    		reverse(L);
    		printf("反转:"); 
    		print(L);
    	}
    	return 0;
    }
    /*
    样例输入:
    1 2 3 4 4 4 4 4 5 6 7 7 7 8 -1 
    */ 


    运行结果:


    展开全文
  • 删除顺序表中值重复的元素

    千次阅读 2018-12-07 18:19:00
    设计一个算法,删除顺序表中值重复的元素(值相同元素仅保留第一个),使得表所有元素的值均不相同。其中顺序表的动态分配用C语言描述如下: #define InitSize 100 //表长度的初始定义 typedef int DataType;...

    题目描述

    设计一个算法,删除顺序表中值重复的元素(值相同的元素仅保留第一个),使得表中所有元素的值均不相同。其中顺序表的动态分配用C语言描述如下:

     

    #define InitSize 100          //表长度的初始定义
    typedef int DataType;         //定义表元素的数据类型
    typedef struct {              //顺序表的定义
    	DataType *data;       //指示动态分配数组的指针
    	int maxSize, n;       //数组中最大容量和当前个数
    }SeqList;
    

     

    输入描述

    有多组测试数据,在每组测试数据的第一行输入顺序表中元素的个数 n;如果n不为0,第二行输入n 个数,用空格隔开。

    输出描述

    如果顺表不为空,输出删除后顺序表里的元素;

    如果顺序表为空,输出 EMPTY

    输入样例

    6
    1 -2 3 -2 4 1
    0
    8
    -1 5 7 9 5 3 -1 2
    

    输出样例

    1 -2 3 4
    EMPTY
    -1 5 7 9 3 2 

     

     

    #include<stdio.h>
    
    int a[100000],vis1[100000+10]={0},vis2[100000+10];
    
    int main()
    {
    	int n,m,j,k,i,T;
    	while (~scanf("%d",&n))
    	{
    		for (i=0;i<100000+10;i++)
    		{
    			vis1[i] = 0;
    			vis2[i] = 0;
    		}
    		
    		for (i=0;i<n;i++)
    		{
    			scanf("%d",&a[i]);
    			if (a[i]>=0)
    			vis1[a[i]]=1;
    			else
    			vis2[-a[i]]=1;	
    		}
    		
    		if (n==0)
    		{
    			printf("EMPTY\n");
    			continue;
    		}	
    		for (i=0;i<n;i++)
    		{
    			if (a[i]>=0)
    			{
    				if (vis1[a[i]]==1)
    				{
    					printf("%d ",a[i]);
    					vis1[a[i]] = 0;
    				}
    			}
    			else
    			{
    				if (vis2[-a[i]]==1)
    				{
    					printf("%d ",a[i]);
    					vis2[-a[i]] = 0;
    				}
    			}
    		}
    		printf("\n");
    	}
    	return 0;
    }

     

    转载于:https://www.cnblogs.com/Romantic-Chopin/p/10253007.html

    展开全文
  • 有序顺序表中删除相同元素

    千次阅读 2020-07-21 20:51:58
    要求:有序顺序表中删除相同元素 算法思想:类似于直接插入排序的思想,将第一个元素视为不重复的有序表,向后面依次比较, 若与前面的不重复有序表最后一个元素不同则插入到之前的表的表尾,若相同,则继续向后...

    要求:有序顺序表中删除值相同的元素
    算法思想:类似于直接插入排序的思想,将第一个元素视为不重复的有序表,向后面依次比较,
    若与前面的不重复有序表最后一个元素不同则插入到之前的表的表尾,若相同,则继续向后比较,找到不同的再插入

    void delete(SqList &L)
    {
    	int i,j;
    	i = 0,j = 1;
    	while(j < L.length)
    	{
    		if(L.data[i] != L.data[j])
    			L.data[++i] = L.data[j++];//不相同则插入表尾,同时ii指向不重复有序表的表尾,j向后移 
    		j++;//相同则j向后移,i指向不重复有序表的表尾 
    	}
    	L.length = i+1;//表长为不重复有序表表尾的下标加一 
    } 
    
    展开全文
  • (1)使用将顺序表L中值为x的数据元素替换为y; (2)此处假设线性表元素用于表示集合,不考虑线性表中元素的位置,移除线性表的所有重复元素;不要使用额外的数组空间,必须在原地修改输入数组 并在使用 O(1...

    大家好,初来乍到请多关照~

    最近老师给留的编程作业里有一道题让我相当困惑:题目是这个样子的:

    任务描述

    本关任务:

    (1)使用将顺序表L中值为x的数据元素替换为y;

    (2)此处假设线性表中的元素用于表示集合,不考虑线性表中元素的位置,移除线性表中的所有重复元素;不要使用额外的数组空间,必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

    第一个替换元素的代码很简单,直接遍历顺序表里的元素,如果相同将其赋值为目标元素。

    以下为replace_seq函数的代码:

    
    void replace_seq(PseqList L, int x, int y)
    {//将顺序表L中值为x的数据元素替换为y
        for (int i = 0; i < L->curNum; i++)
        {
            if (L->element[i] == x)
            {
                L->element[i] = y;
            }
        }
    }

    PseqList L是一个顺序表,以下为顺序表的相关定义:

    typedef int DataType;
    struct seqList
    {//有3个数据成员
        int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
        int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
        DataType* element;//用于存放顺序线性表数据元素的连续空间的起始地址  
    };
    
    typedef struct seqList* PseqList;
    typedef struct seqList* PNode;

    当我看到第二问,刚开始,我以为他是这个意思:

    所以我jio的:

    如果要删除重复出现的元素话,那就用两个循环外循环从头 i=0 开始遍历,内循环从 i+1 开始遍历,一旦发现重复,则用删除元素的代码直接删除掉这个元素就好啦 (好轻松啊~♂)

    以下为两个删除函数,按照下标位置删除和输入目标值删除重复元素

    int delete_seq(PseqList L, int x)
    {//在顺序表L中删除与参数x值相同的数据元素,返回删除数据元素的个数
      //可以使用之前已完成的操作
        int m = 0;
        for (int n = 0; n < L->curNum; n++)
        {
            if (L->element[n] == x)
            {
                deletePos_seq(L, n);
                m++;           
            }
        }
        return m;
    }
    
    int deletePos_seq(PseqList L, int pos)
    {//在顺序表L中删除与下标pos处的数据元素,若pos非法,则返回-1;否则返回1
        
        if (pos<0 || pos>(L->curNum))
        {
            return -1;
        }
        else
        {
            for (int q = pos; q < L->curNum-1; q++)
            {
                L->element[q] = L->element[q+1];
            }
               L->curNum = L->curNum - 1;
            return 1;
        }
    }

    所以那么我的第一个错误的想法实践应该为:

    void delDuplicate_seq(PseqList L)
    {//移除线性表中的所有重复元素;不要使用额外的数组空间,必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成
      //使用常规删除即可,已修改测试用例
        for (int i = 0; i < L->curNum; i++)
            for (int k = i + 1; k < L->curNum; k++)
                if (L->element[i] == L->element[k])
                    deletePos_seq(L, int k);           
    }

    但是它的输出结果并不是我想的那样,当重复值为两个的时候它的运行结果总是正确的:

    输入:1 2 3 3 2 1 4 4 5 5

    输出:1 2 3 4 5 

    但是当重复值为三个以上的时候,它的运行结果出乎意料:

    输入:2 2 2 3 3 3

    输出:2 2 3 3

    原来它只可以删除一次!

    但是为什么呢?我不禁陷入了沉思......

     

     因此我们要修改k的值,保证它在删除掉一个重复值之后退回到原来的元素位置,这样我们才可以保证它会遍历比较所有的元素。

    void delDuplicate_seq(PseqList L)
    {//移除线性表中的所有重复元素;不要使用额外的数组空间,必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成
      //使用常规删除即可,已修改测试用例
        for (int i = 0; i < L->curNum; i++)
            for (int k = i + 1; k < L->curNum; k++)
                if (L->element[i] == L->element[k])
                    {
                        deletePos_seq(L, int k); 
                        k--;
                    }
                              
    }

    输入:1 2 2 8 1 5 5 5 9 2

    输出:1 2 8 5 9

     这样我们就可以删除掉所有的重复值啦~

    当时我兴高采烈的的点击提交时,我发现的的测试案例并没有通过,仔细一剖析案例,人傻了都....

    原来是要删除掉所有的重复出现的元素!

    悲伤,失望,懊悔瞬间涌上心头......(((φ(◎ロ◎;)φ)))

    我被卡这里了!

    但是我是不会服输哒!于是我便急匆匆的打开CSDN看看大佬们是怎么解决的,浏览过后我发现大多的删除案例都是删除重复的数字,可是要怎么删除第一次被重复的那个值呢?我思索了好久,题目规定是不可以用额外的数组空间的,(但是因为时间快要截止了,所以我当时就抱着试一试的想法去修改了一下)我打算要循环两个大循环,首先定义一个数组,在第一次循环时将被重复的值记录到一个数组中,同时利用temp值以便删除时的计数。不会进行删除操作。第二次循环会删掉重复的元素,运行到这里我们的结果仅仅是删除掉重复值,被重复值是仍然存在的,所以我们还要删除掉那个数组里保存的所有被重复元素,这样就会得到我们想要的结果。

    void delDuplicate_seq2(PseqList L)
    {//移除线性表中的所有重复元素;不要使用额外的数组空间,必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成
      //使用常规删除即可,已修改测试用例
        int num = L->curNum;
        int a[20] = {  };
        int temp = 0;
        for (int i = 0; i < L->curNum; i++)
        {
            for (int k = i + 1; k < L->curNum; k++)
            {
                if (L->element[i] == L->element[k])
                {                      
                    a[temp] = L->element[i];
                    temp++;
                    break;
                }
            }
        }
    
        for (int i = 0; i < L->curNum; i++)
        {
            for (int k = i + 1; k < L->curNum; k++)
            {
                if (L->element[i] == L->element[k])
                {
                    deletePos_seq(L, k);
                    k--;
                }
            }
        }
      
        for (int k = 0; k <num ; k++)
        {
            for (int m = 0; m < temp; m++)
            delete_seq(L, a[m]);
         } 
    }

    输入:1 1 1 1 1 

    输出:

    输入:5 5 5 6 7 1 2 7 6 10

    输出:1 2 10

    测试是过了,但是我感觉我的方法很笨,(本来人就不是很聪明😭) ,所以我想把这次的针扎之旅和大家分享一下,但是我还是没有想出来这个不用额外的数组要怎么操作呢?希望大佬告知萌新一下~(比心♥)

    记录日常,记录生活~

    2021/9/20

    展开全文
  • 数据结构——从顺序表中删除重复的元素

    万次阅读 多人点赞 2018-11-10 17:18:57
    问题描述:设计一个算法从顺序表中删除重复的元素,并使剩余元素间的相对次序保持不变。 例如:原顺序表为{4 2 8 4 2 1 2 1 3 5 2},执行该算法后,顺序表为:{4 2 8 1 3 5}。 另外,顺序表的初始值通过调用算法...
  • 算法设计思路:因为是顺序表,所以相同元素一定在连续的位置上。基于此,初始时,将第一个元素看做是非重复的有序表,之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同,若相同则继续向后判断,不...
  • 顺序表删除重复元素

    千次阅读 2021-05-30 00:52:32
    设一顺序表有若干元素,编写程序实现删除表中值重复的元素,即重复元素只保留一个。 【输入形式】 第一行输入一个N(N不大于100),表示顺序表的长度; 第二行输入N个整数,表示顺序表元素; 【输出形式】 输...
  • 一个顺序表元素值无序,编写算法,删除顺序表中值相同的多余元素。 2-5delete_sameSqlist-2.c //一个顺序表元素值无序,编写算法,删除顺序表中值相同的多余元素。 #include"seqlist_def.h" #include"stdio.h" void...
  • 删除顺序表相同的多余元素

    千次阅读 2020-04-30 18:49:36
    6-15 删除顺序表相同的多余元素 (15分) 编写算法,在顺序表L,删除所有值相等的多余元素。 函数接口定义: void delSame(seqLIST *L); L 指向顺序表。 裁判测试程序样例: #include <stdio.h> #define ...
  • 王道数据结构上有道题,删除无序的顺序表中重复元素,提示是用散列表,自己试着实现了一下 算法设计思想 关键之处在于利用散列表的冲突来判断元素是否存在重复。于是解决散列表冲突的方式只能用拉链法,不能用开放...
  • 算法:删除顺序表中重复的元素

    千次阅读 2019-04-14 19:19:47
    //删除数组重复的元素 //思路:通过起始位置的元素,逐个和后面的元素进行比较,找到相同元素后执行删除操作。没有发现执行第二次循环 void purge(int a[], int len) { int i = 0, j; while (i<len) //...
  • 问题描述:从顺序表中删除重复的元素,并使得剩余元素间的相对次序保持不变。 解决思路: PS:将结果表归为一个新表,理解较为容易(接下来以旧表和新表相称) ①先定义新表的长度和迭代器(初始长度为1,迭代器置0...
  • 一个顺序表元素值有序递增,编写算法,删除顺序表中值相同的多余元素。 2-4delete_sortSqlist-2.c #include"seqlist_def.h" #include"stdio.h" void delete_sort_same(SEQUENLIST *a) { int i=0,j; while(i<a-...
  • 顺序表删除相同元素

    千次阅读 2016-07-22 10:43:09
    /*顺序表删除相同元素 算法一:拿一个元素,依次与余下的元素进行比较,相同移动元素删除,缺点要进行大量的元素移动 算法二:一个元素与前j个不相同元素进行比较,不相同元素加入不同元素的区间,相同不...
  • 已知顺序表元素元素值非递减有序排列,编写一个算法,删除顺序表中多余的值相同元素。 运行截图: 代码: #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define ...
  • #include <stdio.h> #include <stdlib.h> #define DATATYPE int ...void INITATE(SEQUENLIST *L)//初始化线性表,参数L是的名字 { L->len=0; } void CREAT(SEQUENLIST *L,int n)
  • 删除顺序表中所有大于k1且小于k2的元素(k1<=k2) 算法思想: 先寻找值大于等于k1的第一个元素(第一个删除的数据元素),然后寻找值大于k2的第一个数据元素(最后一个删除的下一个元素),将后面所有结点前移即可...
  • 顺序表 | 删除顺序表中的某个元素

    千次阅读 2017-12-24 16:24:00
    删除顺序表中的某个元素 实现1:(查找到与value相同元素,将指针不断右移知道与value不同) C++代码: void del_elem(int *sqList,int value,int & length){ int i,d=0; for(i=0;i<length-d;i++)...
  • 已知顺序表中元素依值递增有序排列,要求删除所有值相同的多余元素(使得操作后的顺序表中所有元素的值均不相同) # include <stdio.h> # include <stdlib.h> # define initsize 20//初始分配量 ...
  • 编写算法清除顺序表L所有重复的数据元素
  • 顺序表之有序顺序表重复元素删除

    千次阅读 2020-06-16 21:12:37
    (2.2.4-6)从有序顺序表中删除所有其值重复的元素,使表所有元素的值均不同。 不考虑时间复杂度,空间复杂度为o(1) 思路:例SqList L = { 1, 2, 2, 3, 4, 4 },将每一个元素与之后面的元素进行比较,1与2比较...
  • 1000)的顺序表中可能存在着一些值相同的“多余”数据元素(类型为整型),编写一个程序将“多余”的数据元素顺序表中删除,使该表由一个“非纯表”(值相同元素在表可能有多个)变成一个“纯表”(值相同的...
  • //算法思想:相同元素在有序表位置连续,遍历顺序表,从第一个值开始向后判断。 //若相等则继续往后判断,若不相等则前移,删除掉前面相等的元素。 #include"head.h" bool del_same(SeqList& L) { if (L....
  • 代码示例 #include #include #include #define ListSize 10 typedef struct SqList { int* data; int length; };... printf("删除相同元素后\n\n"); Delete_same(&L); print(&L); printf("\n\n"); }
  • 顺序表中的三种删除重复元素的思想

    千次阅读 多人点赞 2018-10-01 21:39:41
    删除顺序表中相同元素的三种思想,下面归纳为三个名称,以方便记忆: 定位赋值法、判断回退法、双端判别交换法 图解如下:   完整de代码如下: #include&lt;iostream&gt; using namespace ...
  • 从有序顺序表中删除其值在给定值s与t之间(要求s小于t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 202,125
精华内容 80,850
关键字:

删除顺序表中相同元素

友情链接: trex_hob.rar