精华内容
下载资源
问答
  • 输入N个整数顺序建立一个单链表,将该单链表拆分成两个子链表,第一个子链表存放了所有的偶数,第二个子链表存放了所有的奇数。两个子链表数据的相对次序与原链表一致。 Input 第一行输入整数N;; 第二行依次...

    Problem Description
    按照数据输入的相反顺序(逆位序)建立一个单链表,并将单链表中重复的元素删除(值相同的元素只保留最后输入的一个)。
    Input
    第一行输入元素个数 n (1 <= n <= 15);
    第二行输入 n 个整数,保证在 int 范围内。
    Output
    第一行输出初始链表元素个数;
    第二行输出按照逆位序所建立的初始链表;
    第三行输出删除重复元素后的单链表元素个数;
    第四行输出删除重复元素后的单链表。
    Example Input
    10
    21 30 14 55 32 63 11 30 55 30
    Example Output
    10
    30 55 30 11 63 32 55 14 30 21
    7
    30 55 11 63 32 14 21

    runtime error :数组越界,指针指向

    #include <stdio.h>
    #include <stdlib.h>
    typedef int elemtype;
    typedef struct lnode
    {
        elemtype data;
        struct lnode *next;
    }lnode,*linklist;
    linklist creat(int n)//逆序建表
    {
        lnode *head,*p;
        head=new lnode;
        head->next=NULL;
        for(int i=0;i<n;i++)
        {
            p=new lnode;
            scanf("%d",&p->data);
            p->next=NULL;
            p->next=head->next;
            head->next=p;
        }
        return head;
    }
    linklist del(linklist head, int &n)//&n是为了对n做出改变
    {
        lnode *p,*q,*t;
        p=head->next;
        while(p)
        {
            t=p;
            q=t->next;
            while(q)
            {
                if(q->data==p->data)
                {
                    t->next=q->next;
                    free(q);
                    q=t->next;
                    n--;
                }
                else
                {
                    t=q;
                    q=q->next;
                }
            }
            p=p->next;
        }
        return head;
    }
    void output(linklist head)
    {
        lnode *p;
        p=head->next;
        printf("%d",p->data);
        p=p->next;
        while(p)
        {
            printf(" %d",p->data);
            p=p->next;
        }
        printf("\n");
    }
    int main()
    {
        linklist head;
        int n;
        scanf("%d",&n);
        head=creat(n);
        printf("%d\n",n);//输出要求看好
        output(head);
        head=del(head,n);
        printf("%d\n",n);//因为del函数中&n,所以n已经改变
        output(head);
        return 0;
    }
    
    展开全文
  • 将带头结点的单链表A分解成两个带头结点的单链表A和B,使得A表含有原表序号为奇数的元素,B表含有原表序号为偶数元素,且保持相对顺序不变LinkList 将C={a1,b1,a2,b2…an,bn}线性表采用带头结点的单链表...

    将带头结点的单链表A分解成两个带头结点的单链表A和B,使得A表中含有原表中序号为奇数的元素,B表中含有原表中序号为偶数的元素,且保持相对顺序不变

    LinkList 

    将C={a1,b1,a2,b2…an,bn}线性表采用带头结点的单链表存放,设计一个算法,将其拆分为两个线性表,使得A={a1,a2,…an},B={bn,…b2,b1}

    //A采用尾插法,B采用头插法。在插入过程中,先插入一次A,再插入一次B
    

    在一个递增有序的线性表中,单链表存储,设计算法删除表中数值相同的元素

    LinkList 

    有两个按元素值递增次序排列的单链表。编写算法实现将这两个单链表归并为一个按元素值递减次序排列的单链表

    void 

    A、B是两个单链表,其中元素递增有序,设计一个算法从A和B中的公共元素中产生单链表C,要求不破坏A,B的结点

    LinkList 

    A、B表示两个链表,其元素递增排列,求A与B 的并集,并存放于A链表中

    LinkList 

    判断带头结点的循环双链表是否对称

    bool 

    尾插法建立双链表

    void 
    展开全文
  • 1、输入一组整型元素序列,建立带头结点的单链表。  2、要求:  (1)实现链表的遍历...  (2)将链表元素分解成两个带头结点的单链表,其中一个全部存放奇数,另一个全部存放偶数。用C语言实现,急,谢谢 ...

    1、输入一组整型元素序列,建立带头结点的单链表。  2、要求:  (1)实现链表的遍历、查找、插入、删除;  (2)将链表中的元素分解成两个带头结点的单链表,其中一个全部存放奇数,另一个全部存放偶数。用C语言实现,急,谢谢

    展开全文
  • 【数据结构】2,单链表的基本操作 实验内容: 编写一个完整的程序,实现单链表的生成、插入、删除、...在单链表中删除所有值为偶数元素结点。 (5) 编写在非递减有序单链表中插入一个元素使链表元素仍有序的函...

    【数据结构】2,单链表的基本操作

    实验内容: 编写一个完整的程序,实现单链表的生成、插入、删除、输出等基本操作。

    (1) 随机产生或键盘输入一组元素,建立一个带头结点的单向链表(无序)。

    (2) 计算单链表的长度,遍历单链表。

    (3) 把单链表中的元素逆置(不允许申请新的结点空间)。

    (4) 在单链表中删除所有值为偶数的元素结点。

    (5) 编写在非递减有序单链表中插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单链表。

    (6) *利用算法5建立两个非递减有序单链表,然后合并成一个非递增有序链表。

    (7) *利用算法5建立两个非递减有序单链表,然后合并成一个非递减有序链表。

    (8) *利用算法1建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。

    (9) *采用单链表实现一元多项式的存储并实现两个多项式相加并输出结果。

    (10) 在主函数中设计一个简单的菜单,分别调试上述算法。

    1,一些定义

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
    
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    
    typedef int Status;
    typedef int Elemtype;
    
    

    2.定义结构体

    typedef struct Node
    {
        Elemtype  data;
        struct Node *next;
    } Lnode,*LinkList;
    

    3.菜单

    void menu();                            /*菜单*/
    Status Init_Linklist(LinkList &L);           /*初始化空表*/
    Status Creat_Linklist(LinkList &L);         /*尾插法建立单链表*/
    void Disp_Linklist(LinkList L);             /*单链表遍历*/
    int length_Linklist(LinkList L);             /*计算单链表长度*/
    void Reverse_Linklist(LinkList L);         /*单链表逆置*/
    void DelEven_Linklist(LinkList L);         /*删除值为偶数的结点*/
    Status Insert_Linklist(LinkList L, int x);     /*在有序单链表L中插入元素x,链表仍然有序*/
    Status CreatOrder_Linklist(LinkList &L);   /*创建非递减有序单链表*/
    void MergeDescend_Linklist(LinkList La, LinkList Lb, LinkList &Lc);  /*两个非递减有序单链表La和Lb合并成一个非递增有序链表Lc*/
    void MergeAscend_Linklist(LinkList La, LinkList Lb, LinkList &Lc); /*两个非递减有序单链表La和Lb合并成一个非递减有序链表Lc*/
    void Split_Linklist(LinkList La, LinkList &Lb);  /*链表La按值分解成两个链表,La全部为奇数,Lb全部为偶数*/
    
    void menu()
    {
        printf("\t\t\t   单链表基本操作\n\n");
        printf("\t\t\t1.建  立  单  链  表\n");
        printf("\t\t\t2.遍  历  单  链  表\n");
        printf("\t\t\t3.计  算  链 表 长 度\n");
        printf("\t\t\t4.链  表  逆  置\n");
        printf("\t\t\t5.删  除  偶 数 节 点\n");
        printf("\t\t\t6.生 成 值 有 序 单 链 表\n");
        printf("\t\t\t7.合  并 生 成 降  序  链 表\n");
        printf("\t\t\t8.合  并 生 成 升  序  链 表\n");
        printf("\t\t\t9.分  解  链  表\n");
        printf("\t\t\t0.退          出\n\n");
    }
    

    4.函数实现

    /*初始化空表*/
    Status Init_Linklist(LinkList &L)
    {
        L=(LinkList)malloc(sizeof(Lnode));
        if(!L)
            return ERROR;
        L->next=NULL;
        return OK;
    }
    
    /*尾插法建立单链表*/
    Status Creat_Linklist(LinkList &L)
    {
        int x;
        LinkList p,rear;
        Init_Linklist(L);
        rear = L;
        printf("输入-1表示输入结束\n");
            while(scanf("%d",&x),x != -1)
        {
            p = (LinkList)malloc(sizeof(Lnode));
            if(!p)
                return ERROR;
            p->data = x;
            rear->next = p;
            rear = p;
        }
        rear->next = NULL;
        return OK;
    }
    
    /*单链表遍历*/
    void Disp_Linklist(LinkList L)
    {
        LinkList p;
        p = L->next;
        while(p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        printf("\n");
    }
    
    /*计算单链表长度*/
    int length_Linklist(LinkList L)
    {
        int count = 0;   /*count表示单链表长度*/
        LinkList p;
        while(L!=NULL)
        {
            count++;
            L=L->next;
        }
        return count-1;
    }
    
    /*单链表逆置*/
    void Reverse_Linklist(LinkList L)
    {
        LinkList p, q ;
        p=L->next;
        L->next=NULL;
        while(p!=NULL)
        {
            q=p;
            p=p->next;
            q->next=L->next;
            L->next=q;
        }
        }
    
    /*删除值为偶数的结点*/
    void DelEven_Linklist(LinkList L)
    {
        LinkList p, q,e;
        p=L;
        q=p->next;
        while(q!=NULL)
        {
            if(q->data%2==0)
            {
                p->next=q->next;
                q=q->next;
            }
            else
            {
                p = p->next;
                q=q->next;
            }
         }
    }
    
    /*在有序单链表中插入元素,链表仍然有序,插入成功返回OK,插入失败返回ERROR*/
    Status Insert_Linklist(LinkList L, int x)
    { int i=0;
    LinkList p,q;
    p=L;
    q=(LinkList) malloc(sizeof(Lnode));
    if(!p)return ERROR;
    q->data=x;
    while(p->next)
    {
        if(x<=p->next->data&&i==0)
        {
            q->next=p->next;
            p->next=q;
            i++;
        }
        p=p->next;
    }
    if(i==0)
    {
        p->next=q;
        q->next=NULL;
    }
    }
    
    /*创建非递减有序单链表,创建成功返回OK,创建失败返回ERROR*/
    Status CreatOrder_Linklist(LinkList &L)
    {
      LinkList p,q;
      Init_Linklist(L);
      int i,j;
      printf("输入-1表示输入结束\n");
      p=L;
      while(scanf("%d",&j),j!= -1)
        {if(i==0)
            {
                q = (LinkList)malloc(sizeof(Lnode));
                if(!q) return ERROR;
                q->data = j;
                q->next=NULL;
                p->next=q;
                i++;
            }
             else
                Insert_Linklist(L,j);
                }
        return OK;
    }
    
    /*两个非递减有序单链表La和Lb合并成一个非递增有序链表Lc*/
    void MergeDescend_Linklist(LinkList La, LinkList Lb, LinkList &Lc)
    {
     LinkList pa, pb, pc,q;
        pa = La->next;
        pb = Lb->next;
        pc = Lc ;
        pc->next = NULL;
         while(pa&&pb)
        {
            if(pa->data<=pb->data)
            {
                q=pa;
                pa=pa->next;
                q->next=pc->next;
                pc->next=q;
            }
             else
            {
                q=pb;
                pb=pb->next;
                q->next=pc->next;
                pc->next=q;
            }
             }
        while(pa)
        {
            q=pa;
            pa=pa->next;
            q->next=pc->next;
            pc->next=q;
        }
        while(pb)
        {
            q=pb;
            pb=pb->next;
            q->next=pc->next;
            pc->next=q;
        }
        free(Lb);
    }
    
    /*两个非递减有序单链表La和Lb合并成一个非递减有序链表Lc*/
    void MergeAscend_Linklist(LinkList La, LinkList Lb, LinkList &Lc)
    {
        LinkList pa, pb, pc;
        pa = La->next;
        pb = Lb->next;
        pc = Lc = 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);
    }
    
    /*链表La按值分解成两个链表,La全部为奇数,Lb全部为偶数*/
    void Split_Linklist(LinkList La, LinkList &Lb)
    {
      LinkList p, q,j;
    Init_Linklist(Lb);
        Lb->next=NULL;
        j=Lb;
        p=La;
        q=La->next;
        while(q){
        if(!(q->data&1)){
                q=q->next;
                j->next=p->next;
                p->next=j->next->next;
                j->next->next=NULL;
    j=j->next;
                }
                else{
                q=q->next;
                 p=p->next;
                  }
        }
    }
    

    5.main函数

    int main()
    {
        int choice, length;
        LinkList L, La, Lb, Lc;
        while(1)
        {
            menu();
            printf("选择你的操作:");
            scanf("%d",&choice);
            switch(choice)
            {
             case 1:
                if(Creat_Linklist(L))
                    printf("单链表创建成功\n");
                else
                    printf("单链表创建失败\n");
                break;
            case 2:
                Disp_Linklist(L);
                break;
            case 3:
                length = length_Linklist(L);
                printf("单链表长度为:%d\n",length);
                break;
            case 4:
                Reverse_Linklist(L);
                printf("逆置后的链表为:\n");
                Disp_Linklist(L);
                break;
            case 5:
                DelEven_Linklist(L);
                printf("新链表为:\n");
                Disp_Linklist(L);
                break;
            case 6:
                if(CreatOrder_Linklist(L))
                {
                    printf("值有序链表为:\n");
                    Disp_Linklist(L);
                }
                else
                    printf("单链表创建失败\n");
                break;
                 case 7:
                CreatOrder_Linklist(La);
                CreatOrder_Linklist(Lb);
                MergeDescend_Linklist(La, Lb, Lc);
                printf("合并后的新链表为:\n");
                Disp_Linklist(Lc);
                break;
            case 8:
                CreatOrder_Linklist(La);
                CreatOrder_Linklist(Lb);
                MergeAscend_Linklist(La, Lb, Lc);
                printf("合并后的新链表为:\n");
                Disp_Linklist(Lc);
                break;
            case 9:
                Creat_Linklist(L);
                Split_Linklist(L, Lb);
                printf("分裂后的新链表为:\n");
                Disp_Linklist(L);
                Disp_Linklist(Lb);
                break;
            case 0:
                return 0;
            default:
                printf("输入错误,请重新输入\n");
            }
        }
        }
    
    展开全文
  • 单链表的基本操作 背景知识:单链表的插入、删除及应用。 目的要求: 1.掌握单链表的存储特点及其实现。...(4) 在单链表中删除所有值为偶数元素结点。 (5) *编写在非递减有序单链表中插入一个元素使链表
  • (2)从键盘输入1个整数,在单链表中查找该结点的位置。若找到,则显示“找到了”;否则,则显示“找不到”。 (3)从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,...
  • 题目:将一个带头结点的单链表A分解为两个带头结点的单链表A和B,使得A表中含有原表中序号为奇数的元素,而B表...设f(L,x)的功能是:删除以L为首结点指针的单链表中所有值等于x的结点,显然有f(L->next,x) 1.通用...
  • 4、在单向链表中删除所有的偶数元素结点。 5、编写在非递减有序链表插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单向链表。 6、利用算法5建立两个非递减有序单向链表,然后合并成一个非...
  • 3.删除单链表中所有的偶数元素结点。 4.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数,利用该函数建立一个 非递减有序单链表。 5.利用算法4建立两个非递减有序单链表,然后合并成一个非递增链表。 ...
  • 3.删除单链表中所有的偶数元素结点。 4.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数,利用该函数建立一个 非递减有序单链表。 5.利用算法 4 建立两个非递减有序单链表,然后合并成一个非递增链表...
  • 3.删除单链表中所有的偶数元素结点。 4.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数,利用该函数建立一个 非递减有序单链表。 5.利用算法 4 建立两个非递减有序单链表,然后合并成一个非递增链表...
  • 3.删除单链表中所有的偶数元素结点。 4.编写在非递减有序链表中插入一个元素使链表元素仍有序的函数,利用该函数建立一个 非递减有序单链表。 5.利用算法4建立两个非递减有序单链表,然后合并成一个非递增链表。 ...
  • 线性表算法总结

    2019-10-31 16:57:46
    目录 定义 ...将偶数元素放到奇数元素之前 反转顺序表的元素 反转顺序表区间[l,h)的元素 顺序表循环左移K位 单链表结点定义 用arr的元素创建一个长度为n的带头结点的单链表 删除单链...
  • 目录 链表的增删(不带头结点) ...删除有序单链表中重复的元素 链表按奇数、偶数值拆分 链表的增删(不带头结点) func.h #include<stdio.h> #include<string.h> typedef struct node...
  • 线性表

    2019-10-22 21:19:59
    1.将顺序表所有元素偶数元素放到奇数元素之前 2.将顺序表循环左移n个元素 四、顺序表的合并 1.合并顺序表 2.求两个线性表集合的并集 五、其他 1.找出顺序表出现次数大于一半的元素 2.找出有公共后缀的...
  • 这是我写的关于动态链表最全面的代码了,包括增删改查逆置合并等等。 由于第九题和第十一题很简单,延伸发展一下就行了,所以我没有深入写下去。 如果有类似的题目建议不要抄我...4.在单向链表中删除所有的偶数元素
  • 在单向链表中删除所有的偶数元素结点。 (5).对链表排序,排序后链表元素按照非递减方式排列(注意:排序时如果要交换两个结点的顺序,不得通过交换结点的内容,而需要使用改变指针的方式交换结点的位置。建议使用...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    10. 在顺序存储结构,有时也存储数据结构中元素之间的关系。( )【华南理工大学 2002 一、2 (1分)】 11. 顺序存储方式的优点是存储密度大,且插入、删除运算效率高。( )【上海海运学院 1999 一、1(1分)】 12....
  • 4、在单向链表中删除所有的偶数元素(值为偶数)结点。 5、编写在非递减有序链表插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单向链表。 6、利用算法5建立两个非递减有序单向链表,然后...
  • 数据结构实验

    2012-04-13 09:55:47
    2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb只含La表奇数结点,Lc含有La表的偶数结点? 实验3:循环队列基本操作 一 、实验目的 1.熟悉并能实现循环队列的定义和基本操作。 2...
  • 数据结构题

    2012-09-10 14:48:39
    7. 在稀疏矩阵的带行指针向量的链接存储中,每个单链表中的结点都具有相同的( )。 A.行号 B.列号 C.元素值 D.非零元素个数 8. 快速排序在最坏情况下的时间复杂度为( )。 A.O(log2n) B.O(nlog2n) C.0(n) D...
  • c语言经典案例

    2014-10-30 08:06:57
    实例111 删除字符串的连续字符 146 实例112 统计各种字符个数 147 实例113 字符串替换 148 实例114 回文字符串 150 实例115 字符串加密和解密 151 实例116 对调最大数与最小数位置 153 第10章 函数编程基础 155 ...
  • ① 主函数完成n的输入,数组元素输入以及删除后数组元素的输出。 ② 删除功能用子函数完成。 (2)编写一个程序实现如下功能:输入10个学生5门课程的成绩,分别用函数求:①每个学生的平均分;②每门课程的平均分;...
  • 实例039 删除字符串连续字符 47 实例040 字符升序排列 49 实例041 在指定的位置后插入字符串 50 1.7 函数 51 实例042 求字符串字符的个数 51 实例043 递归解决年龄问题 53 实例044 求学生的平均...
  • 世界500强面试题.pdf

    2019-11-01 14:33:26
    1.6.3. 输入一个整数数组,调整数组数字的顺序,使得所有奇数位于数组的前半部分,所有偶数 位于数组的后半部分 ...........................................................130 1.6.4. 给定链表的头指针和一个...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

删除单链表中偶数元素