精华内容
下载资源
问答
  • 偶数表为两个素数之和时表法数的计算法则,庄严,庄宏飞,本文由素数模根数型理论把全体素数表示为代数条件通式,在全体偶数和全体素数间建立了各自对应的两个素数相加式;本文利用中心对
  • 拆分成一个奇数链表和一个偶数链表,并分别输出 */ # 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;
    }
    
    展开全文
  • //将一个分成奇数,偶数两个,排序不变 int main() { char choice; a=&ha; b=&hb; c=&hc;//之前就是被大佬提醒没有把这三个指针指向头指针,以至于 这三个指针成为野指针 DLList=&...
  • 要求用C语言来做!!
  • //暂时没有什么事情,这段时间准备把数据结构上东西都实现以下 #include #include #include typedef struct ListNode { int data; struct ListNode *next; } ListNode,*pListNode; ...

    //暂时没有什么事情,这段时间准备把数据结构上东西都实现以下

    #include<stdio.h>

    #include<stdlib.h>
    #include<malloc.h>
    typedef struct ListNode
    {
    int data;
    struct ListNode *next;
    } ListNode,*pListNode;




    pListNode  createFromHead(int len) ; //头插法
    pListNode  createFromTail(int len) ; //尾插法
    int listLen(pListNode head) ;


    void insert(pListNode * head,int i,int data);
    void delete(pListNode * head,int i, int * x);
    void search(pListNode head,int x,int * location);
    pListNode FindKthFromTail(pListNode p, int k) ;
    void divisionList(pListNode head);
    void print(pListNode head) ;
    void destroy(pListNode head) ;
    void deleteCommon(pListNode head) ;
    void reverse(pListNode *head);  //不重新申请新结点,进行链表逆置



    /*


       在链表中查找符合要求的第一个元素,并返回它在链表的位置
     */
    void  search(pListNode head,int x,int * location)
    {
    if( !head)
    printf("list is null");
    //debug("parameter is null\n");
    pListNode p=head;
    int i=1;
    while(p)
    {
    if( p->data ==x)
    {
    *location=i;
    printf("search %d in the %dth location .Success\n",x,i); 
    return ;
    }
    else
    {
    p=p->next;
    i++;
    }   



    if(p==NULL)
    printf("don't have the num: %d. Fail.\n",x);


    }


    pListNode insert_1(pListNode head,int i,int data)  //此函数带返回头指针的插入,调用需要head=insert_1(head,i,data);因为当插入第一个结点时,头指针被修改了
    {
    pListNode p=head;
    int j=0;
    if(!head)
    printf("list is null\n");
    if(i<=0)
    {
    printf("the input i is not true\n");
    return head; 
    }


    if( i>listLen(head) )
    {
    printf("the location you insert is longer than the list's length\n");
    return head;
    }
    else 
    {
    pListNode p1=NULL;
    if(i==1)
    {
    p1=(pListNode ) malloc( sizeof(ListNode));
    p1->data=data;
    p1->next=p;
    head=p1;  // 这里尤其要注意,因为是修改形参,它的值时是无法改变实参,即如果函数用void指针是带不出去的,
    //因为形参只是实参的一份拷贝,所以指针指向的内容是一致的,即修改的值可以带出去,但是地址带不出去,所以
    //可以采用两种方案,第一函数返回值用pListNode(推荐使用), 第二种采用二级指针
    printf("insert the %d in the %dth location. Success\n",p1->data,i);
    return head;


    }  
    else
    {
    for(j=1;j<i-1;j++)  //i节点的前驱,由于头结点和第一个节点的位置一样所以是后移i-2,如果头结点是不是第一个节点,则后移i-1
    p=p->next;
    p1=(pListNode ) malloc( sizeof(ListNode));
    p1->data=data;
    p1->next=p->next;
    p->next=p1;
    printf("insert the %d in the %dth location. Success\n",p1->data,i);
    return head;
    }  
    }  


    }












    /*
       注:上面的插入方案也可以,不过需要返回值,在main中每次都head=insert(head,i,data)太麻烦所以采用二级指针
     */
    void insert(pListNode * head,int i,int data)
    {
    pListNode p=*head;
    int j=0;
    if(! *head)
    printf("list is null\n");
    if(i<=0)
    {
    printf("the input i is not true\n");


    }


    if( i>listLen(*head) )
    {
    printf("the location you insert is longer than the list's length\n");


    }
    else 
    {


    pListNode p1=(pListNode ) malloc( sizeof(ListNode));
    p1->data=data;
    if(i==1)
    {
    p1->next=p;
    *head=p1;  
    printf("insert the %d in the %dth location. Success\n",p1->data,i);


    }  
    else
    {
    for(j=1;j<i-1;j++) 
    p=p->next;
    p1->next=p->next;
    p->next=p1;
    printf("insert the %d in the %dth location. Success\n",p1->data,i);


    }  
    }  


    }


    void delete(pListNode * head,int i, int * x)
    {
    if( i<=0 || i>listLen(*head) )
    fprintf(stderr,"the input is error\n");
    else
    {
    pListNode p=*head;
    if(!p)
    {
    printf("the list is null\n");
    return ;
    }
    if(i==1)
    {
    *x=p->data;
    *head=p->next;
    free(p);
    }
    else
    {
    int j=1;
    for( ;j<i-1;j++)  //走i-2,由于头指针指向第一个节点
    {
    p=p->next; 


    }
    pListNode p1=p->next;
    *x=p1->data;
    p->next=p->next->next; 
    free( p1);  
    }
    printf("delete the %dth location. Success\n",i);       


    }
    }
    int listLen(pListNode head)

    int len=0;
    pListNode p=head;
    while(p)
    {
    len++;
    p=p->next;
    }


    printf("listLen is %d \n",len);
    return len;


    }


    pListNode  createFromHead(int len) //头插法
    {
    pListNode head=NULL;
    if(len<0)
    fprintf(stderr,"len is error\n");
    else if(len==0)
    return (pListNode )NULL;
    else
    {
    pListNode p1=NULL;
    pListNode p=NULL;
    while(len)
    {
    p=(pListNode) malloc(sizeof( ListNode) );
    scanf("%d", & (p->data) );
    p->next=p1;
    p1=p;
    len--;
    }
    head=p;
    }
    return head;  


    }


    pListNode  createFromTail(int len)
    {
    pListNode head=NULL;
    if(len<0)
    fprintf(stderr,"len is error\n");
    else if(len==0)
    return (pListNode) NULL;
    else
    {






    pListNode p1=NULL;
    pListNode p2=NULL;
    p2=(pListNode) malloc( sizeof(ListNode) );
    scanf("%d",& (p2->data));
    p2->next=NULL;
    p1=p2;
    head=p1;
    len--;
    while(len)
    {
    p2=(pListNode) malloc( sizeof(ListNode) );
    scanf("%d",& (p2->data) );
    p2->next=NULL;
    p1->next=p2;
    p1=p2;
    len--;
    }
    }   


    return head;
    }
    void destroy(pListNode head)
    {
    pListNode pre=head;
    pListNode cur=pre;
    while(cur)
    {
    cur=cur->next;
    free(pre);
    pre=cur;


    }
    }


    void print(pListNode head)
    {
    pListNode p=head ;
    if(head==NULL)
    {
    printf("list is null\n");
    exit(-1);
    }
    while(p)
    {
    printf("%d ",p->data);
    p=p->next;
    }
    printf("\n\n");
    }




    pListNode FindKthFromTail(pListNode head, int k)
    {
    pListNode p= head;
    if(!p)
    {
    printf("parameter is null\n");
    exit(-1);
    }
    if(k<=0)
    {
    printf("the input k is not illgeal\n");
    exit(-1);
    }
    if( k>listLen(p) )
    {
    printf("%d is longer than the  list\n",k);
    exit(-1);
    }


    int i;
    for(i=0  ;i <k ;i++)
    p=p->next;
    pListNode q=head;
    while(p!=NULL)
    {
    p=p->next;
    q=q->next; 


    }


    return q; 


    }


    void reverse(pListNode *head)
    {
    pListNode p=*head;
    if(p==NULL)
    {
    printf("list is null \n");
    exit(-1);
    return ;
    }
    pListNode p1=p->next;
    if( p1==NULL)
    return ;


    pListNode p2=p1->next;
    if(p2==NULL)
    {
    p->next=NULL;
    p1->next=p ;
    *head=p1;
    return ;
    }


    p->next=NULL;
    while(p2)
    {
    p1->next=p;
    p=p1;
    p1=p2;
    p2=p2->next;
    }
    p1->next=p;
    *head=p1;


    }


    /*
       void divisionList( pListNode head, pListNode *podd,pListNode *peven)
       {
       if(!head)
       {
       fprintf(stderr,"list is null\n");
       exit(-1);
       }
       int count1=0;
       int count2=0;
       pListNode p=head;
       pListNode p1=( pListNode ) malloc(sizeof(ListNode));
     *podd=p1;
     (*podd)->next=NULL;
     pListNode p2=(pListNode ) malloc(sizeof ( ListNode)) ;
     *peven=p2;
     (*peven)->next=NULL;


     while( p)
     {
     if(p->data %2)
     {
     p1->next=p;   
     count1++;        
     }
     else
     {
     p2->next=p;
     count2++;
     }
     }
     p1->next=NULL;
     p2->next=NULL;
     (*podd)->data=count1;
     (*peven)->data=count2;
     }
     */






    void divisionList(pListNode head)
    {
    if(!head)
    {
    fprintf(stderr,"list is null\n");
    exit(-1);
    }
    int count1=0;
    int count2=0;
    pListNode p=head;
    pListNode p1=( pListNode ) malloc(sizeof(ListNode));
    pListNode podd=p1 ;
    p1->next=NULL;
    pListNode p2=(pListNode ) malloc(sizeof ( ListNode)) ;
    pListNode peven=p2;
    p2->next=NULL;


    while( p)
    {
    if(p->data %2)
    {
    p1->next=p;   
    p1=p;
    count1++;        
    }
    else
    {
    p2->next=p;
    p2=p;
    count2++;
    }
    p=p->next;
    }
    p1->next=NULL;
    p2->next=NULL;
    podd->data=count1;
    peven->data=count2;
    printf("odd is  %d个 ",podd->data);
    print(podd->next);  //由于此时带头结点
    printf("even is %d个 ",peven->data);
    print(peven->next);
    destroy(podd);
    destroy(peven);
    }


    void deleteCommon(pListNode head)  
    {
    pListNode p=head;
    if(!p)
    {
    printf("the list is null\n");
    return ;
    }
    pListNode pre=p;
    pListNode cur=pre->next;
    if( !cur)
    return ;//只有一个结点,一定不会出现相同元素
    if(!cur->next )  //只有两个结点时要特殊处理,出现这种问题的本质原因在于链表结构设计的不合理,应该采用带有头指针的单链表
    {
    if(pre->data==cur->data)
    free(cur);
    return ;
    }
    pListNode runner=p;
    while( cur)
    {
    runner=p;
    while(runner!=cur)
    {
    if(runner->data ==cur->data )
    {
    cur=cur->next;
    free(pre->next);
    pre->next=cur;
    break;
    }
    else
    {
    runner=runner->next;
    }
    }


    if(runner==cur)
    {
    pre=cur;
    cur=cur->next;
    }
    }


    }


    int main()
    {
    int len,k;
    scanf("%d %d ", &len ,&k);
    /*
      pListNode head= createFromHead(len);
      print(head);
      print(head);


      insert(& head,3,11);
      print(head);


      insert(& head,12,100);
      print(head);
      pListNode p= FindKthFromTail(head,k);
      printf("find kth is %d\n",p->data);
      destroy(head);
    */


    pListNode headT= createFromTail(len);
    print(headT);
    insert(& headT,1,9);//insert(head,1,9)指针带不出来,也可以使用二级指针
    print(headT);


    insert(& headT,3,11);
    print(headT);
    int a;
    delete(& headT,2, &a);
    printf("the delete is %d \n",a);
    insert(& headT,12,100);
    int i;
    search(headT,4,&i);
    print(headT);
    pListNode p= FindKthFromTail(headT,k);
    printf("find kth is %d\n",p->data);
    reverse(&headT);
    print(headT);


    deleteCommon(headT);
    print(headT);
    // pListNode podd,peven;
    // divisionList(headT,&podd,&peven);
    divisionList(headT);
    // podd=podd->next;
    //peven=peven->next;
    // print(podd);
    // print(peven);
    //destroy(headT);
    return 1;
    }
    展开全文
  • 题目描述:一个链表,奇数位升序偶数位降序,让链表变成升序的。 比如:1 8 3 6 5 4 7 2 9,最后输出1 2 3 4 5 6 7 8 9。 分析: 这道题可以分成三步: 首先根据奇数位和偶数位拆分成两个链表。 然后对偶数链表...

    题目描述:一个链表,奇数位升序偶数位降序,让链表变成升序的。

    比如:1 8 3 6 5 4 7 2 9,最后输出1 2 3 4 5 6 7 8 9。

    分析:

    这道题可以分成三步:

    首先根据奇数位和偶数位拆分成两个链表。

    然后对偶数链表进行反转。

    最后将两个有序链表进行合并。

     

    package com.xxx;
    
    
    
    /*/
    一个链表,奇数位升序偶数位降序,让链表变成升序的。
    
    比如:1 8 3 6 5 4 7 2 9,最后输出1 2 3 4 5 6 7 8 9
     */
    /**
     * create by ziqiiii
     */
    public class Test {
    
        public static  class Node {
            int val;
            Node next;
            Node(int x) { val = x; }
        }
    
        public static void  main(String[] args){
            Node head = init();
            System.out.println("original:");
            printNode(head);
            
            Node[] nodes = getList(head);
            Node node1 = nodes[0];
            Node node2 = nodes[1];
            System.out.println("node1:");
            printNode(node1);
            System.out.println("node2:");
            printNode(node2);
    
            node2 = reverse(node2);
            System.out.println("reverse node2:");
            printNode(node2);
    
            Node result = mergeNode(node1,node2);
            System.out.println("result:");
            printNode(result);
        }
    
        public static void printNode(Node head){
            System.out.print(head.val);
            head=head.next;
            while(head!=null){
                System.out.print("->"+head.val);
                head=head.next;
            }
            System.out.println();
        }
    
        public static Node init(){
            Node node1 = new Node(1);
            Node node2 = new Node(8);
            Node node3 = new Node(3);
            Node node4 = new Node(6);
            Node node5 = new Node(5);
            Node node6 = new Node(4);
            Node node7 = new Node(7);
            Node node8 = new Node(2);
            Node node9 = new Node(9);
    
            node1.next = node2;
            node2.next = node3;
            node3.next = node4;
            node4.next = node5;
            node5.next = node6;
            node6.next = node7;
            node7.next = node8;
            node8.next = node9;
            return node1;
        }
    
        public static Node[] getList(Node head){
            Node head1=null;
            Node head2=null;
    
            Node cur1 = null;
            Node cur2 = null;
            int count=1;
            while(head != null){
                if(count % 2 ==1){ //奇数位, 升序
                    if(cur1==null){
                        head1=head;
                        cur1=head1;
    
                    }else{
                        cur1.next=head;
                        cur1=head;
                    }
    
                }else{ //偶数位, 降序
                    if(cur2==null){
                        head2=head;
                        cur2=head2;
                    }else{
                        cur2.next=head;
                        cur2=head;
                    }
                }
                head=head.next;
                count++;
            }
    
            cur1.next=null;//一定要给两个新的链表结尾null
            cur2.next=null;
    
            Node[] nodes = new Node[]{head1,head2};
    
            return nodes;
        }
    
        public static Node reverse(Node head){
            Node pre = null;
            Node next = null;
    
            while(head != null){
                next = head.next;
                head.next=pre;
                pre=head;
                head=next;
    
            }
            return pre;
        }
    
        public static Node mergeNode(Node node1,Node node2){
            if(node1==null){
                return node2;
            }
            if(node2==null){
                return node1;
            }
    
            Node head = null;
            Node cur = null;
            if(node1.val<=node2.val){
                head=node1;
                node1=node1.next;
                head.next=null;
                cur = head;
            }else{
                head=node2;
                node2=node2.next;
                head.next=null;
                cur = head;
            }
    
            while(node1!=null && node2!=null){
                if(node1.val<=node2.val){
                    cur.next=node1;
                    node1=node1.next;
                    cur=cur.next;
                    cur.next=null;
                }else{
                    cur.next=node2;
                    node2=node2.next;
                    cur=cur.next;
                    cur.next=null;
                }
            }
    
            if(node1 !=null){
                cur.next=node1;
            }
    
            if(node2 !=null){
                cur.next=node2;
            }
    
            return head;
        }
    }
    

     

     

     

     

    参考自:[算法]头条面试—奇数位升序偶数位降序链表排序

    展开全文
  • 题目描述:一个链表,特点是奇数位升序偶数位降序,使得链表变成升序的。分析代码节点类:main方法:初始化方法:按照奇偶位拆分成两个链表:反转链表:合并两个有序链表(非递归):合并两个有序链表(递归): 分析 这道题...

    分析

    这道题可以分成三步:
    首先根据奇数位和偶数位拆分成两个链表。
    然后对偶数链表进行反转。
    最后将两个有序链表进行合并(合并两种实现方式一种是递归另外一种是非递归)。

    代码

    节点类:

    class Node {
    	      int value;
    	     Node next;
    	     Node(int x) {
    	          value = x;
    	          next = null;
    	      }
    }
    

    main方法:

    public static void main(String[] args) {
            Node head = init();
            Node[] lists = getLists(head);
            
            Node head1 = lists[0];
            Node head2 = lists[1];
            head2 = reverseList(head2);
            
    //        head = CombineList(head1, head2);
            head = mergeTwoLists(head1, head2);
            while(head != null){
                System.out.println(head.value);
                head = head.next;
            }
        }
    

    初始化方法:

     public static Node init(){
            Node node1 = new Node(1);
            Node node2 = new Node(8);
            Node node3 = new Node(3);
            Node node4 = new Node(6);
            Node node5 = new Node(5);
            Node node6 = new Node(4);
            Node node7 = new Node(7);
            Node node8 = new Node(2);
            Node node9 = new Node(9);
            
            node1.next = node2;
            node2.next = node3;
            node3.next = node4;
            node4.next = node5;
            node5.next = node6;
            node6.next = node7;
            node7.next = node8;
            node8.next = node9;
            return node1;
        }
    

    按照奇偶位拆分成两个链表:

    public static Node[] getLists(Node head){
        	
        	Node head1 = null;
        	Node head2 = null;
        	Node cur1 = null;
        	Node cur2 = null;
        	
        	int count = 1;
        	while(head != null){
        		if(count%2 == 1){
        			if(head1 == null){
        				cur1 = head;
        				head1 = cur1;
        			}else{
        				cur1.next = head;
        				cur1 = cur1.next;
        			}
        		}else{
        			if(head2 == null){
        				cur2 = head;
        				head2 = cur2;
        			}else{
        				cur2.next = head;
        				cur2 = cur2.next;
        			}
        		}
        		count++;
        		head = head.next;
        	}
        	cur1.next = null;
        	cur2.next = null;
        	
        	Node[] list = new Node[]{head1,head2};
        	return list;
        }
    

    反转链表:

     public static Node reverseList(Node head){
        	
        	Node pre = null;
        	Node next = null;
        	while(head !=null){
        		next = head.next;
        		head.next = pre;
        		pre = head;
        		head = next;
        	}
        	return pre;
        }
    

    合并两个有序链表(非递归):

    public static Node CombineList(Node head1, Node head2){
        	
        	if(head1 == null || head2 == null){
        		return head1 != null ? head1:head2;
        	}
        	Node head = head1.value < head2.value ? head1:head2;
        	Node cur1 = head == head1 ? head1:head2;
        	Node cur2 = head == head1 ? head2:head1;
        	Node pre = null;
        	Node next = null;
        	
        	while(cur1 != null && cur2 != null){
        		if(cur1.value < cur2.value){
        			pre = cur1;
        			cur1 = cur1.next;
        		}else{
        			next = cur2.next;
        			pre.next = cur2;
        			cur2.next = cur1;
        			pre = cur2;
        			cur2 = next;
        		}
        	}
        	pre.next = cur1 == null ? cur2 : cur1;
            return head;
        }
    

    合并两个有序链表(递归):

    public static Node mergeTwoLists(Node l1, Node l2) {
        	if(l1 == null || l2 == null){
                return l1 != null ? l1 : l2;
            }
        	Node head = null;
        	if(l1.value>l2.value){
        		head = l2;
        		head.next = mergeTwoLists(l1,l2.next);
        	}else{
        		head = l1;
        		head.next = mergeTwoLists(l1.next,l2);
        	}
        	return head;
        }
    
    展开全文
  • 题目描述:一个链表,奇数位升序偶数位降序,让链表变成升序的。比如:1 8 3 6 5 4 7 2 9,最后输出1 2 3 4 5 6 7 8 9。分析:这道题可以分成三步:首先根据奇数位和偶数位拆分成两个链表。然后对偶数链表进行反转。...
  • 给定一个长度不小于2的数组arr,实现一个函数调整arr,要么让所有的偶数下标都是偶数,要么让所有的奇数下标都是奇数 注意:1、数组下标从0开始! 2、本题有special judge,你可以输出任意一组合法解!同时可以...
  • 题目描述:一个链表,奇数位升序偶数位降序,让链表变成升序的。 比如:1 8 3 6 5 4 7 2 9,最后输出1 2 3 4 5 6 7 8 9。 分析: 这道题可以分成三步: 首先根据奇数位和偶数位拆分成两个链表。 然后对偶数链表...
  • 题目描述:一个链表,奇数位升序偶数位降序,让链表变成升序的。 比如:1 8 3 6 5 4 7 2 9,最后输出1 2 3 4 5 6 7 8 9。 分析: 这道题可以分成三步: 首先根据奇数位和偶数位拆分成两个链表。 然后对偶数链表进行...
  • 一个链表奇数位上升序,偶数位上降序,不用额外空间让这个链表整体升序 1-&gt;8-&gt;3-&gt;6-&gt;5-&gt;4-&gt;7-&gt;2-&gt;9 题解: 这道题可以分成三步: 首先根据奇数位和偶数位...
  • 链表删除偶数

    千次阅读 2016-04-09 17:03:33
    #include #include #include using namespace std; struct node { int date; node *next; }; node* delou(node * head) { node *pre,*l; pre=head; l=head->next; while(l!=NULL) {
  • //检查链表长度是奇数还是偶数 public class Node{ public int value; public Node next; public Node(int data){ this.value=data; } } public void isLinkedListLengthEven(Node head){ while(hea...
  • 删除ArrayList中的偶数

    千次阅读 2017-07-20 18:55:29
    今天在学习链表的时候,有一个小例题:删除中的偶数,使用的是ArrayList。我所学习的《数据结构与算法分析》这本书中只给出了使用remove删除偶数的算法,其他的创建一个数组对象,从键盘接收数组元素等等,是我...
  • 将链表A中的偶数保存到链表B中,奇数留在链表A中; #include<malloc.h> #include<iostream> #include <stdio.h> using namespace std; typedef struct LNode{ int data; struct LNode *next; ...
  • 表偶数为二个奇素数之和,罗贵文,许作铭,本文利用改进的埃塔筛法,研究了很多取整算法与歌德巴赫素数表示法个数及其平均值之间的关系,找到了一种计算歌德巴赫素数表示法
  • 删除链表的偶数节点

    2019-09-26 12:30:52
    if((r->next->data)%2==0)//判断下一个是不是偶数 { r->next=r->next->next;//覆盖掉下一个节点,不移动当前节点 } else r=r->next;//往后移动一个节点 } } void Output(LinkList L) { LNode *p,*r; r=L-...
  • //将所有奇数移到偶数之前 //算法思想:访问依次访问数组中的每一个元素 //若当前元素是奇数,则继续访问 //若当前元素是偶数,则找到离其最近的元素进行交换,直至所有奇数都在偶数之前
  • 表偶数(≥6)为两个奇素数之和,许作铭,罗贵文,本文通过利用一种新的筛法与台阶理论,得到了任意偶数(≥6)为“两个奇素数之和”法个数的显示公式或称Goldbach定理。应用本定
  • 【问题描述】输人若干个正整数(输入-1 为结束标志),并建立个单向链表,将其中的偶数值结点删除后输出。试编写相应程序。 【样例输入】 1 2 3 4 5 6 7 -1 【样例输出】 1 3 5 7 #include <stdio.h> #include &...
  • 奇数偶数序列

    千次阅读 2016-04-19 14:49:14
    给定一串奇数偶数链表,将奇数排在前面,偶数排在后面。 Given 1->2->3->4->5->NULL, return 1->3->5->2->4->NULL. 注:不是leetcode的那道Odd Even Linked List ListNode* oddEvenList(ListNode* head) {...
  • 题目:将链表的奇数位和偶数位调换组成新的链表 troy11112017-05-08 01:19:33浏览31评论0 编程语言javascript函数HTTPS排序list 摘要:题目:将链表的奇数位和偶数位调换组成新的链表 原题链接: http://oj....
  • c++数据结构顺序奇数在左偶数在右源码例子c++数据结构顺序奇数在左偶数在右源码例子
  • #include <iostream> #include<bits/stdc++.h> using namespace std; typedef struct node{ int data; struct node *next; }no; no *cre(){ no *head,*p,*tail; int n; head=new no;...n...
  • 偶数放前面——从前面开始找奇数,记下标 奇数放后面——从后面开始找偶数,记下标 交换两者,直到 i >= j void Move(SqList &a) { int i=0,j=a.lenth-1; while(i<j) { while(a.elem[i]%2==1) i++; ...
  • 给定一个整数的链表,写一个函数来修改链表,使得所有偶数出现在修改链表的所有奇数之前。 此外,保持偶数和奇数的顺序相同。示例: 输入:17-> 15-> 8-> 12-> 10-> 5-> 4-> 1-> 7-> 6-> NULL 输出:8-> 12-> 10->...

空空如也

空空如也

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

偶数表