精华内容
下载资源
问答
  • 这应该是数据结构的题目吧。这题是上课时我同学和我讨论的,当时没用线性表,只是用数组(栈)解决了。现在改用线性表试试,还不是很熟悉。 code: #include #include //或者是 #include 的头文件 ...i

    这应该是数据结构的题目吧。这题是上课时我同学和我讨论的,当时没用线性表,只是用数组(栈)解决了。现在改用线性表试试,还不是很熟悉。

    code:

    #include<stdio.h>
    #include<stdlib.h>  //或者是 #include<malloc.h> 的头文件
    #define N 10
    
    struct Sqlist
    {
        int *elem;
        int length;
        int listsize;
    }L;
    
    int DeleteK(struct Sqlist *L, int j, int k)
    {
        int i;
        for(i = 0; i <= L->length-j-k; i++)     //i=0,而不是i=1,因为第i个是起始元素
            L->elem[i+j-1] = L->elem[j+k+i-1];
        L->length -= k;
        return 0;
    }
    
    int main()
    {
        int i, j, k;
        L.listsize = N;
        L.elem = (int *)malloc(sizeof(int) * L.listsize); //申请listsize个大小为整型(int)字节的空间
    
        printf("输入原始线性表:\n");
    
        for(i = 0; i < N ;i++)
            scanf("%d", &L.elem[i]);
    
        L.length = L.listsize;
    
        printf("\n输入起始位置:");
        scanf("%d", &j);
        printf("\n输入要删除元素的个数:");
        scanf("%d", &k);
    
        DeleteK(&L, j, k);
    
        for(i = 0; i < N-k; i++)
            printf("%d ", L.elem[i]);
    
        return 0;
    }

    展开全文
  • //删除第i个元素起的k个元素 void delete_seqlist(struct SeqList *,int,int); //显示结果 void show_seqlist(struct SeqList *); void main() { struct SeqList list,*fp; int len,i,k; fp=&list; init_...
    #include<stdio.h>
    #include<stdlib.h>
    #define N 50
    struct SeqList
    {
    	int data[N];
    	int length;
    };
    
    //初始化
    void init_seqlist(struct SeqList *);
    
    //插入
    void insert_seqlist(struct SeqList *,int,int); 
    
    //表长度
    int length_seqlist(struct SeqList *); 
    
    //删除第i个元素起的k个元素
    void delete_seqlist(struct SeqList *,int,int); 
     
    //显示结果
    void show_seqlist(struct SeqList *); 
    
    void main()
    {
    	struct SeqList list,*fp;
    	int len,i,k;
    	fp=&list;
    	init_seqlist(fp);
    	insert_seqlist(fp,1,10);
    	insert_seqlist(fp,2,20);
    	insert_seqlist(fp,3,30);
    	insert_seqlist(fp,4,40);
    	len=length_seqlist(fp); 
    	printf("请输入正整数i:");
    	scanf("%d",&i);
    	printf("请输入正整数k:");
    	scanf("%d",&k);
    	if(!(i>0 && i<=k && (i+k)<=len+1))
    	{
    		printf("输入格式错误!\n");
    	}else
    	{
    		delete_seqlist(fp,i,k);
    		show_seqlist(fp);
    	}
    }
    
    void init_seqlist(struct SeqList *fp)
    {
    	fp->length=0;
    }
    
    void insert_seqlist(struct SeqList *fp,int i,int e)
    {
    	int k;
    	for(k=i;k<fp->length+1;k++)
    	{
    		fp->data[k]=fp->data[k-1];
    	}
    	fp->data[i-1]=e;
    	fp->length++;
    }
    
    int length_seqlist(struct SeqList *fp)
    {
    	return fp->length;
    }
    
    void show_seqlist(struct SeqList *fp)
    {
    	int i;
    	if(fp->length==0)
    	{
    		printf("该表为空表!\n");
    	}else
    	{
    		printf("该表为:");
    		for(i=0;i<fp->length-1;i++)
    		{
    			printf("(%d)->",fp->data[i]);
    		}
    		printf("(%d)",fp->data[i]);
    	}
    }
    
    void delete_seqlist(struct SeqList *fp,int i,int k)
    {
    	int g;
    	if(fp->length==0)
    	{
    		printf("该表为空表,删除失败!\n");
    	}else
    	{
    		for(g=i+k;g<=fp->length;g++)
    		{
    			fp->data[g-k-1]=fp->data[g-1];
    		}
    		fp->length-=k;
    	}
    }
    
    展开全文
  • 3.对长度为n的顺序表L,编写一时间复杂度为O(n),空间复杂度为O(1)的算法,该算法删除线性表中所有值为x的数据元素。 /** * 删除线性表中所有值为x的数据元素 * */ void deleteXElem(SqList *List, ElemType x) {...

    3.对长度为n的顺序表L,编写一个时间复杂度为O(n),空间复杂度为O(1)的算法,该算法删除线性表中所有值为x的数据元素。

    方法一:
    用k记录顺序表中不等于x的元素个数,边扫描边List边统计k,并将不等于x的元素向前移动k个位置,最后修改List的长度。

    /**
     * 删除线性表中所有值为x的数据元素
     * */
    void deleteXElem(SqList *List, ElemType x)
    {
        int k = 0; //用于记录值不等于x的元素的个数
    
        for(int i = 0; i < List->length; i++)
        {
            if(List->data[i] != x)
            {
                List->data[k] = List->data[i];
                k ++;
            }
        }
        List->length = k;
    }
    

    方法二:
    用k记录顺序表中等于x的元素个数,边扫描边List边统计k,并将不等于x的元素向前移动k个位置,最后修改List的长度。

    /**
     * 删除线性表中所有值为x的数据元素
     * */
    void deleteXElem2(SqList *List , ElemType x)
    {
        int k = 0; //记录值为x的元素的个数
        for(int i = 0; i < List->length; i++)
        {
            if(List->data[i] == x)
            {
                k++;
            }
            else
            {
                List->data[i-k] = List->data[i];
            }
        }
    
        List->length = List->length - k;
    }
    
    展开全文
  • 删除该单链表第i个元素,其值通过参数将其返回。 ⑤ 建立两个按值递增有序的单链表,将他们合并成一个按值递减有序的单链表。要求利用原来的存储空间 #include #include typedef struct LNode

    (2)单链表的操作

    ① 输入一组整型元素序列,使用尾插法建立一个带有头结点的单链表。

    ② 实现该线性表的遍历。

    ③ 在该单链表的第i个元素前插入一个整数。

    ④ 删除该单链表中的第i个元素,其值通过参数将其返回。

    ⑤ 建立两个按值递增有序的单链表,将他们合并成一个按值递减有序的单链表。要求利用原来的存储空间

    #include<stdio.h>

    #include<stdlib.h>

    typedef struct LNode{

    int data;

    struct LNode *next;

    }LNode,*LinkList;

    void InitList(LinkList &L){

    //建链表 

    LinkList p,pre;

    int x;

    L=pre=(LinkList)malloc(sizeof(LNode));

    scanf("%d",&x);

    while(x>0){

    p=(LinkList)malloc(sizeof(LNode));

    p->data=x;

    pre->next=p;

    pre=p;

    scanf("%d",&x);

    }

    pre->next=NULL;

    }

    void Output(LinkList L){

    //遍历 

    LinkList p;

            p=L->next;//临时指针指向首结点的地址

            while(p!=NULL)

            {

                printf("%5d",p->data);

                p=p->next;

            }

            printf("\n");

    }

    void GetElem(LinkList L,int i,int &e){

    //查找   i为链表长度 

    LinkList p;

    int j;

    p=L->next; j=1;

    while(p&&j<i){

    p=p->next; j++;

    }

    if(!p||j>i)

    return;

    e=p->data;

    void ListInsert(LinkList &L,int i,int e){

    //插入    i为插入位置 

    LNode *p,*s;

    int j;

    p=L; j=0;

    while(p&&j<i-1){

    p=p->next; j++; 

    }

    if(!p||j>i-1){

    return;

    }

    s=(LinkList)malloc(sizeof(LNode));

    s->data=e;

    s->next=p->next;

    p->next=s;

    }

    void ListDelete(LinkList &L,int i,int &e){

    //删除

    LinkList p,q;

    int j=0;

    p=L;

    while(p->next&&j<i-1){

    p=p->next; j++;

    }

    if(!p->next||j>i-1){

    return;

    }

    q=p->next;

    e=q->data;

    p->next=q->next;

    free(q);  

    }

    void Merge(LinkList La,LinkList Lb,LinkList &Lc){

    //按值递增合并 

    LinkList pa,pb,pc;

    pa = La->next; pb = Lb->next;

    Lc = pc = La;

    while(pa&&pb)

    if(pa->data <= pb->data){

    pc->next = pa;pc = pa;pa = pa->next;

    }

    else { 

    pc->next = pb;pc = pb;pb = pb->next; 

    }

    pc->next = pa?pa:pb;

    free(Lb);

    }

    void Reverse(LinkList &L){

    //就地逆置 

    LinkList p,q;

        p = L->next;             

        L->next = NULL;          

        while(p != NULL){     

            q = p->next;         

            p->next = L->next;   

            L->next = p;

            p = q;               

        }

    }

    int main(){

    LinkList La,Lb,Lc;

    int i,e,j,k;

    InitList(La);

    printf("输入要插入的位置和数:");

    scanf("%d%d",&i,&e);

    ListInsert(La,i,e);

    Output(La);

    printf("要删除第几个数:");

    scanf("%d",&j); 

    ListDelete(La,j,k);

    printf("删除的数为:%d\n",k);

    Output(La);

    printf("再建立一个;\n");

    InitList(Lb);

    Merge(La,Lb,Lc);

    Reverse(Lc);

    Output(Lc);

    }

    展开全文
  • printf("请输入你要删除第个元素:\n"); scanf("%d",&i); while(p->next&&j<i-1){ p=p->next; j++; } if(p->next==NULL||j>i-1){ exit(0); } q=p->next; e=q->data; p->next=q->...
  • 对长度为n的顺序表L,编写一时间复杂度O(n),空间复杂度为O(1)的算法,该算法删除线性表中所有值为x的数据元素。 算法思想: 一步:从前往后扫描顺序表,用k纪录当前值为x的数据元素的个数 二步:如果扫描...
  • 思路:统计不等于x的个数,边统计边把当前元素放在k位置上,最后修改表的长度 public static void del(List list,int p){ int k=0; for(int i=0;i();i++){ if(list.get(i)!=p){ list.set(k, list....
  • 写一算法,从顺序表中删除第i个元素开始的k个元素。 方法:循环控制删除即可 代码实现: #include #include #include #define OVERFLOW -2 #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define...
  • 线性表删除

    2016-12-03 23:13:55
    删除操作 删除算法的思路: 1. 如果删除位置不合理,抛出异常; ...2. 取出删除元素;...3. 从删除元素位置开始遍历到最后一个元素位置,分别将它们都向前移动一个位置.../*操作结果:删除L中第i个数据元素, 并用
  • 为了方便描述过程,假定一个线性表结构体ArrayList typedef struct ArrayList{ int data[N]; int index;//初始值为-1,代表里面没有元素,使用时代表下标。 }*List; 一种方法:顺序双指针法 指针i控制向...
  • 本题是顺序表删除算法的扩展,可以采用如下方法解决:从j+1个元素开始到最后一个元素为止,用这之间的每个元素去覆盖从这个元素开始往前数j-i+1个元素,即可完成删除i~j的所有元素。 核心代码如下: /* 删除...
  • 第1个元素存储在线性表的起始位置,第i个元素的存储位置后面紧接着存储的是第i+1个元素,称i为元素ai在线性表中的位序。因此,顺序表的特点是表中元素的逻辑顺序与其物理顺序相同。 // 静态顺序表的定义 typedef st
  • 数据结构-线性表

    2017-10-31 17:03:36
    线性表  线性表的基本操作 1、创建一个新的线性表 ...3、检索线性表中第i个数据元素(1 ) ...4、根据数据元素的某数据项(通常称为关键字)的值求该...7、删除线性表中第i个数据元素 8、对线性表中的数据元素
  • 二章、线性表

    2018-04-01 20:13:00
     1、线性表中第i个数据元素ai的存储位置: LOC(ai)=LOC(a1)+(i-1)*l l为每个元素需占用l个单元  2、有上式可知,线性表的顺序结构是一种随机存取的存储结构,但其缺点为插入和删除比较困难。  3、线性表的...
  • 注:本题删除的条件改为了删除重复的元素,同样删除后,还是要向前移动 算法分析: 使用两计数器来进行表示 1)在顺序表遍历,一直找到不等的那个元素为止; 2)将不等的元素前移至i+1的位置上去; 详细...
  • 线性表的第i个元素是要存储在数组下标为i-1的位置。 假设占用的是c个存储单元,那么线性表中的第i+1个数据元素的存储位置和第i个数据元素存储位置满足下列关系式(LOC表示获得存储位置的函数) LOC(ai+1) = LOC(ai...
  •  2.-LISTDelete(*e,i,*e):删除线性表L中第i个位置元素,并用e返回其值 今天通过进一步学 更深入了解 1 2 函数的实现 线性表插入: 插入思路: -如果插入位置不合理,抛出异常; -如果线性表长度大于等于数组...
  • 线性表的建立及运算

    2020-03-06 16:46:13
    3、在线性表的第i个元素前插入一个正整数x; 4、删除线性表中的第j个元素; 5、将线性表中的元素按升序排列; 6、将线性表中的元素就地逆序(只允许用一个暂存单元); #include #include using namespace std; #...
  • 线性表有顺序存储和链式存储,此处为顺序存储造作方法。 (1)建立线性表L (2)判断线性表是否为空 ...(7)删除线性表L中第i个元素 (8)求线性表L的元素个数 (9)求线性表的最大容量 此处为Se...
  • 线性表的插入与删除属于算法系列,学数据结构的宝宝们应该知道这点,首先说一下算法的位置与c语言中数组位置的记作方法一样,都是从0开始,比如说线性表中第i个数据元素,那么它的位置是L.elem[i-1]。这个没什么难度...
  • 数据结构线性表

    2020-09-26 14:23:29
    线性表-顺序表(索引) ... - GetElem(L,i): 按位查找,获取L中第i个元素的值 - ListInsert(&L,i,e): 在线性表L中的第i个位置插入新元素e - ListDelete(&L,i,&e): 删除线性表L中第i个位置元素,并用
  • 顺序线性表的插入,删除操作(完整代码)

    万次阅读 多人点赞 2018-08-18 18:20:56
    1..插入 :在顺序线性表l的第i个位置前插入元素e 。...删除:从顺序线性表l中删除第i个元素,并用e返回其值 。 第一步判断删除位置是否合法,如果不合法则异常退出。 第二步将待删除位置元素的值赋于e...
  • 二章 线性表

    2007-06-13 20:12:00
    2.10 Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素{ if(ia.length) return INFEASIBLE; for(count=1;i+count-1注意循环结束的条件 a.elem[i+count-1]=a.elem[i+count+k-1]; a....
  • 数据结构线性表i

    2014-10-31 22:52:44
    按照数据输入的相反顺序(逆位序)建立一单链表,并将单链表重复的元素删除(值相同的元素只保留最后输入的一)。 输入 一行输入元素个数n; 二行输入n整数。 输出 一行输出初始链表元素个数; ...
  • 2.4 线性表的顺序表示和实现6 1、顺序表基本操作的实现 (1)线性表的基本操作 //线性表的基本操作 InitList(&L)//初始化操作,建立一个空的...e)//删除线性表L中第i个位置元素,用e返回 IsEmpty(L)//若线性
  • 线性表是按顺序存储数据是常用的一种数据结构。大多数线性表的典型操作...7,删除线性表中的第i个数据元素 8,表置空 9,查找第i个元素的前驱或后继 10,按一个或多个数据项递增或递减重新排列数据元素 数组线性表
  • 3)在第i个位置插入值为n的数 4)删除线性表的第i 个元素 5 )输出线性表 1 //在头文件"SeqList.h" 2 const int MaxSize=100; 3 #define T float //此处修改 数组的类型 4 class SeqList 5 { 6 ...
  • Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素 { if(i||k||i+k-1>a.length) return INFEASIBLE; for(count=1;i+count-1;count++) //注意循环结束的条件 a.elem[i+count-1]=a.elem[i...
  • 线性表顺序存储插入和删除操作

    千次阅读 2016-11-20 20:42:16
    线性表的操作:1、InitList(*L):初始化操作,建立一个空的线性表L 2、ListEmpty(L):判断线性表是否为空,如果为空,返回true,否则返回... 4、GetElem(L,I,*e):将线性表中第i个位置元素值返回给e  5、Loca
  • 线性表的基础知识

    2016-11-30 22:25:06
    数据长度与线性表长度区别 数组的长度是存放线性表的存储空间的长度存储分配后这个量是一般是不变的。 ...线性表的长度是线性表中数据元素的个数,...线性表的第i个元素是要存储在数组下标为i-1的位置。 存储器

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 295
精华内容 118
关键字:

删除线性表中第i个元素