精华内容
下载资源
问答
  • 删除顺序表中所有值为X元素

    千次阅读 2020-01-13 00:00:28
    题目描述:删除顺序表中所有值为X元素,要求时间复杂度O(n),空间复杂度O(1)。 #include<stdio.h> #include"sqlist.cpp" /*已知长度n的线性表A采用顺序存储结构, 编写一个时间复杂度O(n)、空间...

    题目描述:删除顺序表中所有值为X的元素,要求时间复杂度为O(n),空间复杂度为O(1)。

    #include<stdio.h>
    #include"sqlist.cpp"
    /*已知长度为n的线性表A采用顺序存储结构,
    编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法,
    该算法删除线性表中所有值为x的数据元素。
    */
    void DeleteNode1(SqList *&L,ElemType x)
    {
    	int k=0;//k记录元素值不等于x的个数
    	for(int i=0;i<L->length ;i++)
    	{
    		if(L->data [i]!=x)//若当前元素不为x,则将其插入到L中 
    		{
    			L->data[k]=L->data[i];
    			k++;
    		}
    	} 
    	L->length = k;
    }
    //算法1类似于建顺序表
    
    void DeleteNode2(SqList *&L,ElemType x)
    {
    	int k=0;
    	for(int i=0;i<L->length ;i++)
    	{
    		if(L->data [i]==x)//当前元素为x时k增1 
    		{
    			k++;
    		}
    		else
    		{
    			L->data [i-k]=L->data [i];//当前元素不为x时将其前移k个位置 
    		}
    	}
    	L->length -= k;//顺序表L的长度减K 
    }
    int main(int argc,char *argv[])
    {
    	ElemType x;
    	ElemType a[]={1,2,2,1,0,2,4,2,3,1};
    	SqList *L;
    	InitList(L);//初始化线性表
    	CreateList(L,a,10);//数组名代表数组元素的首地址 
    	printf("L:");
    	DisplayList(L);
    	printf("请输入要删除元素的值:");
    	scanf("%d",&x);
    	printf("删除值为%d的元素 \n",x);
    //	DeleteNode1(L,x); 
    	DeleteNode2(L,x);
    	printf("L:");
    	DisplayList(L);
    	DestroyList(L);
    	return 0;
    }

    顺序表的实现代码

    #include<stdio.h>
    #include<malloc.h>
    #define MaxSize 100
    typedef int ElemType;
    //顺序表的类型定义 
    typedef struct{
    	ElemType data[MaxSize];
    	int length;
    }SqList;
    //建立顺序表 
    void CreateList(SqList *& L, ElemType a[], int  n)
    {
    	L = (SqList *)malloc(sizeof(SqList));
    	for (int i = 0; i < n; i++)
    		L->data[i] = a[i];
    	L->length = n;
    }
    //初始化线性表 本算法的时间复杂度为O(1) 
    void InitList(SqList  * & L)
    {
    	//初始化线性表,只需要将其长度设置为0即可
    	L = (SqList *)malloc(sizeof(SqList));
    	L->length = 0;
    }
    //销毁线性表 本算法的时间复杂度为O(1) 
    void DestroyList(SqList *&L)
    {
    	//释放线性表L的内存空间
    	free(L);
    }
    //判断线性表是否为空 本算法的时间复杂度为O(1) 
    bool ListEmpty(SqList *L)
    {
    	return (L->length == 0);
    }
    //求线性表的长度 本算法的时间复杂度为O(1) 
    int ListLength(SqList *L)
    {
    	return (L->length);
    }
    //输出线性表   本算法的时间复杂度为O(L->length) 
    void DisplayList(SqList * L)
    {
    	if (ListEmpty(L))
    		return;
    	for (int i = 0; i < L->length; i++)
    		printf("%2d", L->data[i]);
    	printf("\n");
    }
    //求线性表中某个数据元素的值 本算法的时间复杂度为O(1) 
    bool GetElem(SqList * L, int i, ElemType & e)
    {
    	if (i<1 || i>L->length)
    		return false;
    	e = L->data[i - 1];
    	return true;
    }
    //按元素值查找 本算法的时间复杂度为O(L->length) 
    int LocateElem(SqList * L, ElemType e)
    {
    	int i = 0;
    	while (i < L->length && L->data[i] != e)
    		i++;
    	if (i >= L->length)
    		return 0;
    	else
    		return i + 1;
    }
    //插入顺序表的元素 本算法的时间复杂度为O(n) 
    bool ListInsert(SqList *& L, int i, ElemType e)
    {
    	if (i<1 || i>L->length + 1)
    		return false;
    	i--;//将顺序表的逻辑序号转化为物理序号
    	for (int j = L->length; j > i; j--)
    		L->data[ j ] = L->data[ j- 1];//将元素后移一个位置
    	L->data[i] = e;//插入元素e
    	L->length ++;//顺序表的元素增加1
    	return true;
    }
    //删除顺序表的元素  本算法的时间复杂度为O(n) 
    bool ListDelete(SqList *& L, int i, ElemType &e)
    {
    	if (i<1 || i>L->length)
    		return false;
    	i--;//将顺序表的逻辑序号转化为物理序号
    	e = L->data[i];
    	for (int j = i; j < L->length;j++)
    		L->data[ j ] = L->data[ j + 1];//将元素左移一个位置
    	L->length--;//顺序表的元素增加1
    	return true;
    }

     

    展开全文
  • 顺序表中删除值在X--Y之间的元素

    千次阅读 2019-04-22 15:56:03
    顺序表中删除值在X--Y之间的元素

    首先给大家分享一个巨牛巨牛的人工智能教程,是我无意中发现的。教程不仅零基础,通俗易懂,而且非常风趣幽默,还时不时有内涵段子,像看小说一样,哈哈~我正在学习中,觉得太牛了,所以分享给大家!点这里可以跳转到教程

                   

    /*从给定的顺序表中删除值在X--Y之间的元素*/
    /*已知线性表中的元素以值递增有序排列,并以单链表作存储结构。试写一高效算法,删除表中所有值大于mink且小于maxk的元素*/
    #include <stdio.h>
    #define  ElemType  int;
    #define LIST_SIZE 100
    typedef struct {
           int *elem;
             int length;
             }Sqlist;
        void InitList(Sqlist *L)
        {
          (*L).elem=(int *)malloc(LIST_SIZE*sizeof(int));
             if( !(*L).elem )
             exit(1);
          }  
       void Delete(Sqlist *L,int X,int Y)
         {
              int i=0,n=0;
             while(i<(*L).length) 
                 {
                     if((*L).elem[i]>=X && (*L).elem[i]<=Y)
                      n++;                          
                      else
                      (*L).elem[i-n]=(*L).elem[i];
                      i++;
                 }
                 (*L).length-=n;
                 if((*L).length==0)
                 printf("the sqlist ie empty/n");   
         }      
                                
             
    int main()
    {
              int X,Y,i;
              Sqlist A;          
                InitList(&A);   

              printf("please input the length :/n");
              scanf("%d",&A.length);
              printf("please input the elem :/n");
              for(i=0;i<A.length;i++)
              scanf("%d",&A.elem[i]);
              printf("please input X ,Y :/n");
              scanf("%d%d",&X,&Y);
             Delete(&A,  X,  Y);    
              printf("the result list :/n");
               for(i=0;i<A.length;i++)
               printf("%3d",A.elem[i]);
               return 0; 
    }
              
     

               

    浏览人工智能教程

    展开全文
  • C语言顺序表中删除值为x元素

    千次阅读 2016-12-28 15:50:22
    要求时间复杂度O(n)、空间复杂度O(1) 实现代码如下//删除线性表中为x元素 void deleteX(SqList L,int x){ int k=0; for(i=0;i;i++){ if(L.elem[i]!=x){ L.elem[k]=L.elem[i]; k++;

    要求时间复杂度为O(n)、空间复杂度为O(1)
    实现代码如下

    //删除线性表中为x的元素
    void deleteX(SqList L,int x){
        int k=0;
        for(i=0;i<L.lenght;i++){
            if(L.elem[i]!=x){
                L.elem[k]=L.elem[i];
                k++;
            }
        }
        L.lenght=k;
    
    }
    展开全文
  • 问题描述:删除顺序表中所有值为x元素(保持删除元素相对位置不变) 说明:遇到这个题,我首先想到的就是最普通的方法,也是效率最低的方法 (当然,后来凭我一己之力也没想到其他方法)。不过,我看了王道...

    /*
    问题描述:删除顺序表中所有值为x的元素(保持删除后元素相对位置不变)
    说明:遇到这个题,我首先想到的就是最普通的方法,也是效率最低的方法
    (当然,后来凭我一己之力也没想到其他方法)。不过,我看了王道考研复习
    资料上又有两种好方法,确实比我的要好,思维方式就和我的不一样。(我的
    应该算是最普通、大众的吧,嘿嘿)。
    简要解释如下:

    test_delete_1:最普通的方法,就是按顺序遍历表L,如果发现x则将后面所有的
    元素前移。这样的做法,时间复杂度为O(N2)。
    
    test_delete_2:这种方法的思路是,记录L中x的个数,那么每个x后面的元素只要
    向前移动它前面总共的x的数量即可。时间复杂度为O(N)
    
    test_delete_3:这种方式用的是反向的思路,即研究最终的结果,对于最终的结果
    来看(即删除所有x后),某个元素应该处于哪个位置。比如说1,2,5,3,4 ,x
    为5,那么就最终结果看,1在第一个位置,2在第二个位置,3在第三个 位置,4在第
    四个位置,把它们放在数组中对应的位置即可 这种方式的时间复杂度也是O(N)。
    
    总结:上面的第三中思路,是一种逆向思维。这在以后的算法学习中,经常能遇得到。
    

    */

    
    //删除重复元素1
    void test_delete_1(int x,Sqlist &L)
    {
        for(int i = 0;i<L.length;++i)
        {
            if(x == L.data[i])  //查找待删除元素
            {
                for(int j = i;j<L.length;++j)    //向前移动元素
                {
                    L.data[j] = L.data[j+1];
                }
                --L.length;
                --i;
            }
        }
    }
    
    //删除重复元素2
    void test_delete_2(int x,Sqlist &L)
    {
        int num_x = 0;      //用来记录待删除元素的个数
        for(int i = 0;i<L.length;++i)
        {
            if(L.data[i] == x)
                ++num_x;
            else
                L.data[i-num_x] = L.data[i];    //每个元素向前移动num_x个位置
        }
    
        L.length = L.length-num_x;      //改变元素个数
    
    }
    //删除重复元素3
    void test_delete_3(int x,Sqlist &L)
    {
        int not_x_num = 0;  //用来记录不等于x的数量
    
        for(int i = 0;i<L.length;++i)
        {
            if(x != L.data[i])  //当x不等于待测元素时
            {
                 L.data[not_x_num] = L.data[i]; //将当前不是x的元素移到第not_x_num个位置上
                 ++not_x_num;
            }
    
        }
         L.length = not_x_num;      //改变元素个数
    }
    展开全文
  • 线性表经典算法题-在顺序表中删除所有值为x元素 1、题目要求: 时间复杂度O(n),空间复杂度O(1) 例如:表(3,5,2,3,8,3,7,3), 删除3后,变为(5,2,8,7) 2、算法思想: 从头开始扫描顺序表,对于值为x元素,...
  • 顺序表中删除元素值为x的操作

    万次阅读 2017-04-12 19:49:38
    1.长度n的顺序表L,编写一个时间复杂度O(n),空间复杂度O(1)的算法,该算法能够删除线性表所有值为x的数据元素
  • 从数组开头往后扫并用K记录不等于X元素个数,且边扫描边统计K,同时将不等于X元素往前移K位,最后修改顺序表的长度,实现删除顺序表L所有值为X元素 二.源代码 //删除值为X的数据元素 void Del_X(List list,...
  • 问题描述:长度n的顺序表L,编写一个时间复杂度O(n),空间复杂度O(1)的算法,该算法删除线性表所有值为x的数据元素。 解决思想: 这个问题一个复杂的解决方法是依次遍历顺序表,遇到值为x元素删除,...
  • 解法一: 首先确定顺序表L的第一个值为x元素位置i,ranhouyici
  • } void denode1(SqList *&L,ElemType x)//删除顺序表中全部x元素 { int k=0,i; for(i=0;i<L->length;i++) if(L->data[i]!=x) { L->data[k]=L->data[i]; k++; } L->length=k; } int main() { SqList *L; ElemType ...
  • 顺序表的存储结构: typedef struct{ int data[Maxsize];...元素值在x和y 之间。 所有这题只需将条件换一下即可。 方法一: C代码实现:****(另外新建表) void delallxy1(SqList & L,int x,int
  • public static void main(String[] args) { // TODO Auto-generated method stub int[] a = {1,2,4,78,0,45,0,0,0,89}; int i = 0; while(i { i++; } for(int j = i+1;j { if(a[j]!=0) ...
  • 顺序表L中删除所有值为x元素

    万次阅读 多人点赞 2017-06-07 15:24:36
    #include #define MAXSIZE 100 typedef struct { int elem[MAXSIZE]; int last; }SeqList; int creat(SeqList &L) ...printf("请输入要创建的元素的个数:\n"); scanf("%d", &a); L.last=0; for (int i = 0;i
  • typedef struct { int len; type data[MAX]; }sqList; int delsameele3...{ //每遍历一个元素时都考虑其向前移动的位数 int k=0; for(int i=0;i&lt;a-&gt;len;i++) if(a-&gt;data[i]!=x) a-...
  • DS-003 顺序表--删除所有值为x元素

    千次阅读 2018-09-29 12:43:38
    题目:长度n的顺序表L,编写一个时间复杂度O(n),空间复杂度O(1)的算法,该算法删除线性表所有值为x的数据元素。 算法思想:用k记录不等于x元素个数,即需要保存的元素个数。边扫描L边统计k,并将不等于x...
  • 问题描述:从顺序表中删除值在给定值s与t之间(包含s和t,要求s&lt;t)的所有元素。情况1:有序顺序表。分析:因为是有序表,所以删除元素必然是相连的整数。于是,我们可以先寻找值大于等于s的第一个元素...
  • 创建一个顺序表, 向顺序表中插入元素,查找顺序表中元素(按查找和按序号查找),删除顺序表中的某个元素,输出顺序表中元素算法: #include <stdio.h> #include <stdlib.h> #define ListSize ...
  • 问题描述:长度n的线性表,删除所有值为x元素,要求时间复杂度O(n),空间复杂度O(1)。 算法设计思想:用k记录顺序表中不等于x元素个数,即需要保存的元素个数,边扫描L边统计k,并将不等于x元素...
  • typedef int type; typedef struct { int len; type data[MAX]; }sqList; int delsure4(sqList *a,type min,type max) ...//删除后的顺序表k上的元素总等于按顺序不等于x的i位置的元素 a->len=k; return 0; }
  • 哈哈,又更新啦,2020王道课后习题P18,综合应用题3:将长度n的顺序表L删除所有值为X元素,时间复杂度:O(n),空间复杂度:O(1)。这个问题是有陷阱的,一开始要是采用正面的思路去想问题,会出现错误,所以...
  • 问题:长度n的顺序表L,编写一个时间复杂度O(n),空间复杂度O(1)的算法,该算法删除线性表所有值为x元素。令x=100,删除顺序表中关键字100的元素。算法思想:用K记录顺序表L,不等于x元素的个数,边...
  • 该算法删除线性表所有值为x的数据元素 /*对长度n的顺序表L,编写一个时间复杂度O(n),空间复杂度O(1)的算法 该算法删除线性表所有值为x的数据元素*/ #include <iostream> #include <...
  •  实现顺序表的就地逆置,即利用原表的存储空间将线性表(a1,a2,…,an),逆置(an,an-1,…,a1)。 1.顺序表的全部逆置 设一个临时变量,将顺序表逆置 //顺序表的全部逆置 void reverse_list(Sqlist &L) { //就地...
  • 主函数定义顺序表L,并定义插入元素和被删除元素;再给顺序表L分配内存空间,通过调用InitList函数,初始化顺序表L,利用冒泡法将键盘输入的进行排序,再调用printList函数进行输出。从键盘输入要插入的数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,117
精华内容 51,646
关键字:

在顺序表中删除值为x的元素