精华内容
下载资源
问答
  • 偶数表
    2022-06-16 20:14:46

    题如下:

    在一个带头结点的单链表A中,头指针为a,设计算法将A分解为两个具有相同结构的链表B、C,其中B表的结点为A表中值为奇数的结点,而C表的结点为A表中值为偶数的结点(链表A的元素类型为整型,要求B、C表除了头结点可以新开辟空间外,其余结点均利用A表的结点,不得申请新的结点空间)最后要求遍历B,C链表。

    这是一个比较常见的数据结构里面的基础题。

    解该题的关键在于要弄清楚单链表里面的指针的指向关系。

    这里是其的数据存储结构

    typedef struct Node
    {
        int data;      // data域用于存储数据元素
        struct Node* next;  // next域用于存放指向其后继的指针
    }LNode, * PNode, * LinkList;  // LinkList为头指针

    这里是其的算法实现(注意看题中所给的要求)

    void SplitList(LinkList a, LinkList* b, LinkList* c)
    {
        LinkList A, B, C;
        A = a->next;
        C = *c;
        B = *b;
        while (A) //通过A链表是否为空作为是否结束循环的标志
        {
            if ((A->data) % 2 == 0)//判断数据是奇数还是偶数
            {
                a->next = A->next;
                C->next = A;
                C = A;     // 重点
                C->next = NULL;
                A = a->next;
            }
            else
            {
                a->next = A->next;
                B->next = A;
                B = A; // 重点
                B->next = NULL;
                A = a->next;
            }
        }
    }


     

    更多相关内容
  • 偶数表为两个素数之和时表法数的计算法则,庄严,庄宏飞,本文由素数模根数型理论把全体素数表示为代数条件通式,在全体偶数和全体素数间建立了各自对应的两个素数相加式;本文利用中心对
  • 设计一个算法,将一个结点值为自然数的单链表拆分为两个单链表,原中保留值为偶数的结点,而值为奇数的结点按他们在原中的相对次数组成一个新的单链表 代码实现 #include <stdio.h> #include <stdlib.h...

    拆分一个链表为偶数链表和奇数链表

    问题简述

    设计一个算法,将一个结点值为自然数的单链表拆分为两个单链表,原表中保留值为偶数的结点,而值为奇数的结点按他们在原表中的相对次数组成一个新的单链表
    代码实现
    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #define FLAG -1    //停止输入的标志
    typedef struct Node
    {
        int data;
        struct Node * next;
    }LNode,*LinkList;
    
    void CreateLinkList(LinkList L);
    void show_List(LinkList L);
    LNode *Breakupthelist(LinkList La,int *A,int *B);
    
    void main()
    {
        LinkList La,Lb;
        int A = 0,B = 0;
        La = (LinkList)malloc(sizeof(LNode));//创建头结点
        printf("创建单链表:\n");
        CreateLinkList(La);
        printf("遍历单链表:\n");
        show_List(La);
        printf("拆分链表:\n");
        Lb = Breakupthelist(La,&A,&B);//A,B用来判断全是奇数或全是偶数的情况
        if(A == 0)//全是偶数
        {
            printf("偶数链:\n");
            show_List(La);
            printf("奇数链为空!\n");
        }
        else if(B == 0)//全是奇数
        {
            printf("奇数链:\n");
            show_List(Lb);
            printf("偶数链为空!\n");
        }
        else
        {
            printf("偶数链:\n");
            show_List(La);
            printf("奇数链:\n");
            show_List(Lb);
        }
    
    
    }
    
    void CreateLinkList(LinkList L)  //尾插法  输出是输入的正序
    {
        LinkList s,r;
        int x;
        scanf("%d",&x);
        r = L;
        while(x != FLAG)
        {
            s = (LNode *)malloc(sizeof(LNode));
            s->data = x;
            r->next = s;
            r = s;
            scanf("%d",&x);
        }
        r->next = NULL;
    }
    
    void show_List(LinkList L)
    {
        LinkList p = L->next;
        printf("%d",p->data);
        p = p ->next;
        while(p != NULL)
        {
            printf("->%d",p->data);
            p = p->next;
        }
        printf("\n");
    }
    
    LNode *Breakupthelist(LinkList La,int *A,int *B) //返回奇数链表的头结点
    {
        LinkList p,q,r;//r始终指向偶数链的尾部
        LinkList Lb = (LinkList)malloc(sizeof(LNode));
        p = La;
        q = Lb;
        r = La;
        p = p->next;
        while(p)
        {
            if(p->data % 2 != 0) //奇数
            {
                q->next = p;
                p = p->next;
                r->next = p;
                q = q->next;
                *A = 1;
            }
            else
            {
                p = p->next;
                r = r->next;
                *B = 1;
            }
        }
        q->next = NULL;
        return Lb;
    }
    
    展开全文
  • 将一个整数表拆分成一个奇数表和一个偶数表请举例三种基本操作(数据结构)各位道友帮帮忙秋梨膏
  • 拆分成一个奇数链表和一个偶数链表,并分别输出 */ # include <iostream> # include <stdlib.h> # include <stdio.h> using namespace std; typedef struct Node { int elem; struct Node* ...

    /*
    编写一个算法,将带头结点的单向链表
    拆分成一个奇数链表和一个偶数链表,并分别输出
    */

    # include <iostream>
    # include <stdlib.h>
    # include <stdio.h>
    using namespace std;
    
    typedef struct Node
    {
    	int elem;
    	struct Node* next;
    }*linklist;
    
    void inlinklist(linklist &l, int n )
    {
    	l = (linklist) malloc (sizeof(Node));
    	l->next = NULL;
    	linklist p, end;
    	end = l;
    
    	printf("请输入链表中的元素:\n");
    	for(int i = 0 ;i < n; i++)
    	{
    		p = (linklist) malloc (sizeof(Node));
    		scanf("%d", &p->elem);
    		end->next = p;
    		p->next = NULL;
    		end = p;
    	}
    }
    
    void outlinklist(linklist l)
    {
    	printf("链表中的元素为:\n");
    	linklist p;
    	p = l->next;
    
    	while(p)
    	{
    		printf("%d ", p->elem);
    		p = p->next;
    	}
    	printf("\n");
    }
    
    void splitlinklist (linklist &l1, linklist &l2, linklist &l3)
    {
    	l2 = (linklist) malloc (sizeof(Node));
    	l3 = (linklist) malloc (sizeof(Node));
    	linklist p, q, s;
    	//p = l1;
    	q = l2;
    	s = l3;
    	p = l1->next;
    	q->next = s->next = NULL;
    
    	while(p)
    	{
    		if(p->elem % 2 == 1)//奇数
    		{
    			q->next = p;
    			p = p->next;
    			q = q->next;
    			
    		}
    		else if(p->elem%2 == 0)//偶数
    		{
    			s->next = p;
    			s = s->next;
    			p = p->next;
    			
    		}
    	}
    	q->next = NULL;
    	s->next = NULL;
    }
    
    int main()
    {
    	linklist l1, l2, l3;
    	int n;
    
    	printf("请输入链表的元素值:\n");
    	scanf("%d", &n);
    
    	inlinklist(l1, n);
    	splitlinklist(l1, l2, l3);
    	outlinklist(l2);
    	outlinklist(l3);
    
    	return 0;
    }
    
    展开全文
  • 要求用C语言来做!!
  • 第二步:遍历原链表,将遍历的数 判断是奇数还是偶数 第三步:若是奇数,用尾插法 插入到链表L1。 若是偶数,用尾插法 插入到链表L2 #include<stdio.h> #include<stdlib.h> #include<string.h>...

    第一步:建立两个新链表

    第二步:遍历原链表,将遍历的数 判断是奇数还是偶数

    第三步:若是奇数,用尾插法 插入到链表L1。 若是偶数,用尾插法 插入到链表L2

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    typedef struct NUM {//定义一个结构体
    
    	int num;
    	struct  NUM* pNext;
    } num, * pnum;
    
    //该子函数 是尾插法
    void insert(pnum* phead, pnum* ptail, int Input) {
    
    	pnum pnew = (pnum)calloc(sizeof(num), 1);
    
    	memset(pnew, 0, sizeof(num));
    
    	pnew->num = Input;
    
    	if (NULL == *phead) {   //判断链表是否为空
    
    		//如果链表为空
    		*phead = pnew;
    		*ptail = pnew;
    	}
    	else {
    
    		(*ptail)->pNext = pnew;
    		*ptail = pnew;
    	}
    }
    
    //打印链表
    void printList(pnum phead) {
    
    	pnum pcur = phead;
    	while (pcur) {
    
    		printf("%d ",pcur->num);
    		pcur=pcur->pNext;
    	}
    	printf("\n");
    }
    
    //链表的拆分
    void Listdivi(pnum phead, pnum* phead1, pnum* ptail1, pnum* phead2,pnum* ptail2) {
    
    	int n = 1;
    
    	while (phead !=NULL) {
    
    		if (n % 2 !=0) {
    
    			insert(phead1,ptail1,phead->num);
    		}
    		else {
    
    			insert(phead2,ptail2,phead->num);
    		}
    		n++;
    		phead = phead->pNext;
    	}
    }
    
    
    int main() {
    
    
    	pnum phead = NULL;//原链表
    	pnum ptail = NULL;
    
    	pnum phead1 = NULL;//链表1
    	pnum ptail1 = NULL;
    
    	pnum phead2 = NULL;//链表2
    	pnum ptail2 = NULL;
    
    	int InPut;//定义要输入的数
    
    	while (scanf_s("%d", &InPut) != EOF) {//读取要输入的数字
    
    		insert(&phead, &ptail, InPut);//调用子函数 在子函数中具体实现功能
    	}
    
    	Listdivi(phead, &phead1,&ptail1,&phead2,&ptail2);
    
    	printf("原链表是:");
    	printList(phead);
    
    	printf("链表1是:");
    	printList(phead1);
    
    	printf("链表2是:");
    	printList(phead2);
    	
    }
    
    	
    

           运行结果:

     

    展开全文
  • 这道题怎么用python实现 而且可以把一个偶数的所有质数和的所有情况都输出出来
  • 编程实现:输入若干个正整数(输入-1为结束标志),建立一个单向链表,将其中的偶数值结点删除后输出。链表节点定义为: struct Node{ int data; struct Node *next; } 输入输出示例:括号内为说明 输入样例: 1 2 ...
  • 将这个线性表拆分成一个奇数线性表和一个偶数线性表线,性的最大长度为20.
  • 设计算法判断单循环链表是否每个结点的值都是偶数,建立链表,判断,显示。 对任意输入的一组数据,建立一个递增有序的单链表。 将单链表L中的奇数项和偶数项结点分解开,并分别连成一个单链表。 用递增有序的链表A...
  • 将一个整数线性表拆分成奇数和偶数线性表,课后习题,完整好用
  • Java奇偶链表

    2021-12-20 12:44:32
    请注意,这里的奇数节点和偶数节点指的是节点编号的奇偶性,而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1),时间复杂度应为 O(nodes),nodes 为节点总数。 奇偶链表 2.思路 分离...
  • c代码-奇数节点和偶数节点分别排在一起_链表
  • 6-7 删除单链表偶数节点 分数 20 作者 C课程组 单位 浙江大学 本题要求实现两个函数,分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下: struct ListNode { int data; struct ...
  • 给定单链表的头节点 head ,将所有索引为奇数的节点和索引为偶数的节点分别组合在一起,然后返回重新排序的列表。 第一个节点的索引被认为是 奇数 , 第二个节点的索引为 偶数 ,以此类推。 请注意,偶数组和奇数组...
  • word文档,里面是一次编译原理作业,为偶数个a和偶数个b构成的a、b串的集合L的正则表达式、右线性表达、及DFA
  • 题目 设计一个算法,将一个头结点为A的单链表(其数据域为整数)分解成两个单链表A和B.使得A链表只含有原来链表中data域.../* 将A链表中的奇数和偶数分离出来,奇数继续保留在A链表中,偶数保留在B链表中 */ /* *A指的.
  • 2.九九偶数乘法 3.九九奇数乘法 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name...
  • 链表奇偶重排

    2021-09-09 11:12:09
    给定一个单链表,请设定一个函数,将链表的奇数位节点和偶数位节点分别放在一起,重排后输出。 注意是节点的编号而非节点的数值。 示例1 输入: {1,2,3,4,5,6} 复制返回值: {1,3,5,2,4,6} 复制说明: ...
  • 在python编译器中,新建一个空白的PYTHON文档;输入:n = float(input("Please input a number:...= 0:print("This is an odd")如果输入的数字是偶数,输出的文字为“This is an even”。如果输入的数字是奇数,输出的...
  • 表偶数(≥6)为两个奇素数之和,许作铭,罗贵文,本文通过利用一种新的筛法与台阶理论,得到了任意偶数(≥6)为“两个奇素数之和”法个数的显示公式或称Goldbach定理。应用本定
  • 一:采用传统方式: 二:采用新的方式(采用列表生成式):
  • c++数据结构顺序奇数在左偶数在右源码例子c++数据结构顺序奇数在左偶数在右源码例子
  • 链表拆分为奇偶

    千次阅读 2021-03-17 16:56:54
    题目:将一个带头结点单链表A分解成两个带头结点的单链表A和B,使得A中含有原中序号为奇数的元素,B中为偶数,且保持其相对位置不变 分析: 首先我们需要分配一个节点空间为B作为头节点,然后设置一个flag,为0时...
  • 一百以内所有奇数和偶数有哪些

    千次阅读 2021-02-27 07:54:44
    展开全部100以内所有奇数:1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,47,49,51,53,55,57,...100以内所有偶数有:0,2,4,6,8,10,12,14,16,18,20,22...
  • 给定一个单链表,把所有的奇数节点和偶数节点分别排在一起。请注意,这里的奇数节点和偶数节点指的是节点编号的奇偶性,而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1),时间...
  • 给定一个单链表,把所有的奇数节点和偶数节点分别排在一起。请注意,这里的奇数节点和偶数节点指的是节点编号的奇偶性,而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1),时间...
  • 表偶数为二个奇素数之和,罗贵文,许作铭,本文利用改进的埃塔筛法,研究了很多取整算法与歌德巴赫素数表示法个数及其平均值之间的关系,找到了一种计算歌德巴赫素数表示法
  • 题目描述:一个链表,特点是奇数位升序偶数位降序,使得链表变成升序的。分析代码节点类:main方法:初始化方法:按照奇偶位拆分成两个链表:反转链表:合并两个有序链表(非递归):合并两个有序链表(递归): 分析 这道题...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,778
精华内容 44,711
关键字:

偶数表