精华内容
下载资源
问答
  • /复制后直接能运行/ 用指针简单的做了一下 #include"stdio.h" typedef struct { int data[100]; int last; }qwe; void shuchu(qwe * head) { int i; qwe *p; p=head; for(i=1;i<p->... in

    /复制后直接能运行/

    用指针简单的做了一下

    #include"stdio.h"
    typedef struct
    {
    	int data[100];
    	int last;
    }qwe;
    void shuchu(qwe * head)
    {
    	int i;
    	qwe *p;
    	p=head;
    	for(i=1;i<p->last;i++)
    	{
    		printf("%5d",p->data[i]);
    	}
    	printf("\n");
    }
    void yunxing(qwe * head)
    {
    	int i=1,j,k;
    	for(i=1;i<head->last;i++)
    		for(j=i+1;j<head->last;j++)
    		if(head->data[i]==head->data[j])
    		{
    			for(k=j;k<=head->last;k++)
    				head->data[k]=head->data [k+1];
    			head->last--;
    		}
    		shuchu(head);
    }
    void shuru(qwe *head)
    {
    	int i,h;
    	printf("请输入数字\n");
    	for(i=1;h!=0;i++)
    	{
    		scanf("%d",&h);
    		head->data[i]=h;
    		head->last++;
    	}
    	yunxing(head);
    }
    int main()
    {
      qwe head;
      head.last=0;
      shuru(&head);
      return 0;
    }
    
    
    展开全文
  • PAGE PAGE #/ 4 C数据结构删除顺序表中值相同的多余的元素 0 题目如下 : 按下面两种情况分别编写算法删除顺序表中值相同的多余元素 顺序表元素值递增有序 . 顺序表元素值无序 . 由于时间原因 ,两个给合成一个来...
  • 删除顺序表中值相同的多余元素

    万次阅读 多人点赞 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 
    */ 


    运行结果:


    展开全文
  • 已知顺序表中的元素元素值非递减有序排列,编写一个算法,删除顺序表中多余的值相同元素。 运行截图: 代码: #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define ...

    已知顺序表中的元素按元素值非递减有序排列,编写一个算法,删除顺序表中多余的值相同的元素。
    运行截图:
    在这里插入图片描述
    代码:

    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define ERROR -1
    #define OVERFLOW -2
    #define MAXSIZE 10;
    typedef int Status;
    typedef int ElemType;
    typedef struct 
    {
    	ElemType *elem;
    	int length;
    	int listsize;
    }SqList;
    Status InitList(SqList &L)
    {
    	
    	L.elem=new ElemType[100];
    	L.length =10;
    	return OK;
    		
    }
    Status DeleteList(SqList &L)
    {
    	int j=0,k,i,m;
    	i=L.elem[j];
    	while(j<L.length)
    	{
    		for(k=0;k<L.length;k++)
    			if(i==L.elem[k]&&k!=0)
    			{
    		for(m=k;m<L.length;m++)
    			L.elem[m]=L.elem[m+1];
    		L.length=L.length-1;
    			}
    		j=j+1;
    		i=L.elem[j];
    	}
    
    	return OK;
    
    
    }
    
    
    
    int main()
    {
    	SqList L;
    	InitList(L);
    
    	int i,j;
    	printf("请输入10个数(中间用空格):");
    	for(i=0;i<10;i++)
    	{
    		scanf("%d",&L.elem[i]);
    		printf(" ");
    	}
    	printf("\n");
    		DeleteList(L);
    		printf("删除成功!");
    		printf("\n");
    		for(i=0;i<L.length;i++)
    			printf("%5d",L.elem[i]);
    		printf("\n");
    
    }
    
    展开全文
  • 数据结构实验 有两个非递增有序的线性表A和B,采取顺序存储将两个合并成C,然后删除C中相同元素的多余元素
  • 删除顺序表相同的多余元素 编写算法,在顺序表L,删除所有值相等的多余元素。 函数接口定义: void delSame(seqLIST *L); L 指向顺序表。 裁判测试程序样例: #include <stdio.h> #define MAXSIZE 20 ...

    删除顺序表值相同的多余元素

    编写算法,在顺序表L中,删除所有值相等的多余元素。

    函数接口定义:
    void delSame(seqLIST *L);

    L 指向顺序表。

    裁判测试程序样例:
    #include <stdio.h>
    #define MAXSIZE 20
    struct seqlist
    {
    int elem[MAXSIZE]; //存放元素的数组
    int last; //最后一个元素的下标
    };
    typedef struct seqlist seqLIST; //类型定义

    void initLIST(seqLIST *L);//函数声明
    void outList(seqLIST *L);
    void inputList(seqLIST *L,int n);
    void delSame(seqLIST *L);

    int main()
    {
    seqLIST list;
    int n,k;
    int pos;

    initLIST(&list);  //置空 
    
    scanf("%d",&n);
    inputList(&list,n);   
    
    delSame(&list);
    outList(&list);
    return 0;
    

    }

    void outList(seqLIST *L)
    {
    int i;
    if(L->last==-1)//空表
    {
    printf(“Empty list.”);
    return ;
    }
    for(i=0;i<=L->last;i++)
    {
    printf("%d ",L->elem[i]);
    }
    }

    void initLIST(seqLIST *L)//置空表
    {
    L->last=-1;
    }

    void inputList(seqLIST *L,int n)//表中元素的输入
    {
    int i,x;
    for(i=0;i<n;i++)
    {
    scanf("%d",&x);
    if(L->last < MAXSIZE-1)
    {
    L->elem[i]=x;
    L->last++;
    }
    }
    }

    /* 请在这里填写答案 */

    输入样例:
    7
    1 2 1 1 2 1 1

    输出样例:
    1 2

    void delSame(seqLIST *L){//容易出错的地方已注释
      int i,j,k;
    for(i=0;i<L->last;i++){          //没加“{” 
      for(j=i+1;j<=L->last;j++)         //加了“{” and ''j<L->last''了
        if(L->elem[j]==L->elem[i]){  //(elem[j]==elem[i])
          if(j==L->last) {           //(elem[j]==L->last)
            L->elem[j]==NULL;      //elem[j]==NULL
            L->last--;
           }
        
        else{
         for(k=j;k<L->last;k++)    //j=k  不加括号 
           L->elem[k]=L->elem[k+1]; // elem[k]=elem[k+1]
           L->last--;
         } 
         j--;                       //在 else 的括号外,整体if的括号里 
        }
         
     }
    }
    
    展开全文
  • 已知顺序表中元素依值递增有序排列,要求删除表中所有值相同的多余元素(使得操作后的顺序表中所有元素的值均不相同) # include <stdio.h> # include <stdlib.h> # define initsize 20//初始分配量 ...
  • 问题描述:从有序表中删除所有值重复的元素,使表中元素均不同。 算法设计思路:因为是顺序表,所以相同元素一定在连续的位置上。基于此,初始时,将第一个元素看做是非重复的有序表,之后依次判断后面的元素...
  • 要求:有序顺序表中删除相同元素 算法思想:类似于直接插入排序的思想,将第一个元素视为不重复的有序表,向后面依次比较, 若与前面的不重复有序表最后一个元素不同则插入到之前的表的表尾,若相同,则继续向后...
  • 删除顺序表中的某个元素 实现1:(查找到与value相同元素,将指针不断右移知道与value不同) C++代码: void del_elem(int *sqList,int value,int & length){ int i,d=0; for(i=0;i<length-d;i++)...
  • 2 顺序表ADT模板简单应用算法设计:删除顺序表中的冗余元素 问题描述: 目的:使用自行设计的顺序表ADT或STL中的vector模板,设计并实现顺序表应用场合的一些简单算法设计。 应用3:试设计一个算法,删除非空顺序表...
  • 应用3:试设计一个算法,删除非空顺序表L中的冗余元素,即使得操作之后的顺序表中只保留操作之前表中所有值都不相同元素(提纯)。 参考函数原型: (1)顺序表ADT版本 template<class ElemType> void ...
  • 顺序表ADT模板简单应用算法设计:删除顺序表中的冗余元素 问题描述 目的:使用STL中的vector模板,设计并实现顺序表应用场合的一些简单算法设计。 应用3:试设计一个算法,删除顺序表L中的冗余元素,即使得操作之后...
  • 题目:从有序的顺序表中删除所有其值相同元素,使表中的所有元素的值均不相同。算法思想:因为是顺序表,用类似于直接插入排序的思想,将第一个元素看作非重复的有序表,之后依序判断后面的元素是否和前面非重复...
  • 由于是有序顺序表,值相同元素一定在连续的位置上,用类似于直接插入排序的思想,初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否是与前面非重复有序表的最后一个元素相同,若相同则继续向后...
  • 算法:删除顺序表中重复的元素

    千次阅读 2019-04-14 19:19:47
    //删除数组重复的元素 //思路:通过起始位置的元素,逐个和后面的元素进行比较,找到相同元素后执行删除操作。没有发现执行第二次循环 void purge(int a[], int len) { int i = 0, j; while (i<len) //...
  • //从有序顺序表中删除所有其值重复的元素,使表中所有元素的值均不相同 typedef struct{ int data[MaxSize]; int Length; }SqList; //扫描L,记录重复元素的个数,同时将当前元素前移k个位置 bool delete_all...
  • /* 参数Data数组为要处理的数据 *length存储数组长度 返回值失败返回0,成功返回1 */ int Delete_Same(int Data[], int* length) { if (*length == 0) return 0; int i,j;... for (i = 0, j = 1;...
  • 删除顺序表中值重复的元素

    千次阅读 2019-01-12 16:08:53
    设计一个算法,删除顺序表中值重复的元素(值相同元素仅保留第一个),使得表中所有元素的值均不相同。其中顺序表的动态分配用C语言描述如下:   #define InitSize 100 //表长度的初始定义 typedef int ...
  • 试对顺序表编写实现上述操作的算法,并分析你的算法的时间复杂度(注意:题中没有特别指明同一表中元素值各不相同)。 算法思想:先比较B表和C表,找到同样的元素并存入数组中,再遍历A表,比较是否有元素和数组中...
  • 从有序顺序表中删除所有其值重复的元素,使表中所有元素的值均不同。 //删除有序顺序表中所有值重复的元素 //算法思想:相同元素在有序表中位置连续,遍历顺序表,从第一个值开始向后判断。 //若相等则继续往后判断...
  • 题目:从有序顺序表中删除所有其值重复的元素,使表中所有元素的值均不同。 关键字:有序顺序表 删除重复元素 思路 关注:因为是有序表,所以值相同元素一定在连续的位置上, 用类似于直接插入排序的思想 1.初始时...
  • 顺序表之有序顺序表重复元素删除

    千次阅读 2020-06-16 21:12:37
    (2.2.4-6)从有序顺序表中删除所有其值重复的元素,使表中所有元素的值均不同。 不考虑时间复杂度,空间复杂度为o(1) 思路:例SqList L = { 1, 2, 2, 3, 4, 4 },将每一个元素与之后面的元素进行比较,1与2比较...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,145
精华内容 458
关键字:

删除顺序表中相同元素