精华内容
下载资源
问答
  • 两个有序链表合并

    2014-08-29 10:15:18
    //两个有序链表合并 ListNode* Merge(ListNode* pHead1,ListNode* pHead2) { if(pHead1==NULL) return pHead2; else if(pHead2==NULL) return pHead1; ListNode* pMergedHead=NULL; if(pHead1->m_nValuem_...
    //两个有序链表合并
    ListNode* Merge(ListNode* pHead1,ListNode* pHead2)
    {
    	if(pHead1==NULL)
    	return pHead2;
    	else if(pHead2==NULL)
    	return pHead1;
    	ListNode* pMergedHead=NULL;
    	if(pHead1->m_nValue<pHead2->m_nValue)
    	{
    		pMergedHead=pHead1;
    		pMergedHead->m_pNext=Merge(pHead1->m_pNext,pHead2);
    	}
    	else
    	{
    		pMergedHead=pHead2;
    		pMergedHead->m_pNext=Merge(pHead1,pHead2->m_pNext);
    	}
    	return pMergedHead;
    }

    展开全文
  • 两个有序链表合并成一个有序链表

    千次阅读 2019-04-17 14:04:04
    算法:两个有序链表合并成一个有序链表(Java实现) 首先我们创建链表的结构类 @Getter @Setter class Node{ private Integer data; //存储数据 private Node next; //后继引用 public Node(Integer data) { ...

    算法:两个有序链表合并成一个有序链表(Java实现)
    首先我们创建链表的结构类

    @Getter
    @Setter
    class Node{
        private Integer data;   //存储数据
        private Node next;   //后继引用
        public Node(Integer data) {
            this.data = data;
        }
    }
    

    准备数据:

    	//准备第一个有序链表
    Node readyNode1(){
        Node node = new Node(1);
        Node node1 = new Node(6);
        Node node2 = new Node(9);
        Node node3 = new Node(10);
        node.next = node1;
        node1.next = node2;
        node2.next = node3;
        return node;
    }
    
    //准备第二个有序链表
    Node readyNode2(){
        Node node = new Node(2);
        Node node1 = new Node(3);
        Node node2 = new Node(8);
        Node node3 = new Node(14);
        Node node4 = new Node(22);
        node.next = node1;
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        return node;
    }
    

    我们想要实现链表的合并排列。
    1.就要新建一个链表;
    2.然后依次比较初始链表的大小;把数值小的放到新链表中,注意:只能放链表的值,不能放后继指针。
    3.每次在新链表中插入数据的时候,都要保证插入的数据是在新链表的最后一个节点上。
    代码如下:

    //合并两个有序链表
    public Node hebing(Node node1, Node node2){
    	 if (node1 == null)   return node2;
         if (node2 == null)   return node1;
        
        Node node3 = null;       //递归合并两个有序链表   
        while(node1 != null || node2 != null) {
            Node n = new Node();    //每次循环使用一个Node去存储数据
            if (node1 == null) {
                getLastNode(node3).next = node2;
                break;
            } else if (node2 == null) {
                getLastNode(node3).next = node1;
                break;
            } else if (node1.data > node2.data) {
                n.data = node2.data;
                node2 = node2.next;
            } else if (node1.data <= node2.data) {
                n.data = node1.data;
                node1 = node1.next;
            }
    
            if (node3 == null) {
                node3 = n;
            } else {
                getLastNode(node3).next = n;
            }
    
        }
        return node3;
    }
    
    /**
     * 获取链表的最后一级
     */
    public Node getLastNode(Node node){
        while (node != null){
            if (node.next == null) {
                return node;
            } else {
                node = node.next;
            }
        }
        return null;
    }
    

    测试

    @Test
    public void run(){
        Node node1 = readyNode1();
        Node node2 = readyNode2();
        Node hebing = hebing(node1, node2);
        System.out.println(JSONObject.toJSONString(hebing));
    }
    

    输出结果:

    		{"data":1,"next":{"data":2,"next":{"data":3,"next":{"data":6,"next":{"data":8,"next":{"data":9,"next":{"data":10,"next":{"data":14,"next":{"data":22}}}}}}}}}
    
    展开全文
  • C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
  • 两个有序链表合并为一个有序链表 思路: 1.必须保证两个链表为有序链表 2.在两个链表都不为空的条件下,设一个 last=null; (1)如果链表1的值小于等于链表2的值,进行循环,先放链表1的值到新链表result,...

    将两个有序链表合并为一个有序链表

     

    思路:

    前提:必须保证两个链表为有序链表

    1、异常判断
    1)两个单链表都没空,则返回null
    2)链表1为空,则返回链表2。反之返回链表1
    3)比较两个链表头结点的大小。如果链表1的头结点比链表2的头结点小,则将新链表的头结点、尾节点指向链表1的头结点,同时将链表1的头结点更新为下一个结点。反之则将新链表的头结点指向链表2的头结点、尾节点,同时更新链表2的头结点为下一个结点。
    2、使用while循环,当两个单链表都不为null的情况下,如果链表1的头结点<链表2的头结点,则将新链表的尾结点指向链表1的头结点,同时将更新后的新链表的最后一个结点更新成head1并将链表1的头结点后移。
    反之,则同样的操作用于链表2。
    3、循环结束后,判断两个链表中是否有空的链表,如果不为空,则将该链表的头结点及后面的结点直接放入新链表的末尾。
    4、最后返回新链表的头结点

    代码:

    1、创建一个Node对象

     class Node{
        public int no;
        public String name;
        public String nickName;
        public Node next;
    
        public Node(int no,String name,String nickName){
            this.no = no;
            this.name = name;
            this.nickName = nickName;
        }
    
        @Override
        public String toString() {
            return "Node{" + "no=" + no + ", name='" + name  + ", nickName='" + nickName+"}";
        }
    }

    2、创建MergeNode.class,包含向链表中顺序添加节点,打印链表的方法

    class MergeNode{
        Node head = new Node(0,"","");
    
      
        //按节点的编号顺序添加
        public void addByOrder(Node node){
            //head节点不能动,所要需要一个临时节点 temp
            Node temp = head;
            boolean flag = false;
            //遍历链表,找到要添加的节点应插入的位置,如果节点的next为null,就代表找到了最后的节点
            while (true) {
                if(temp.next == null){
                    break;
                }
                if(temp.no == node.no){
                    flag = true;
                    break;
                }else if(temp.next.no > node.no){
                    break;
                }
                //当遍历的当前节点next不为Null时,则继续遍历,需要将临时节点后移
                temp = temp.next;
            }
    
            if(flag){
                System.out.printf("链表中已存在该编号%d节点,不能添加\n",node.no);
            }else{
                node.next = temp.next;
                temp.next = node;
            }
        }
    
        
    
        public   void printNodeList(Node head) {
            //判断链表是否为空,如果为空则返回
            if(head.next == null){
                System.out.println("链表为空");
                return;
            }
            //head节点不能动,所要需要一个临时节点 temp
            Node temp = head.next;
            while (temp!=null){
                //判断当前遍历的节点是否为空,为空则代表到了链表的最后
                if(temp == null){
                    break;
                }
                //输出节点信息
                System.out.println(temp);
                //将temp后移,继续遍历
                temp = temp.next;
            }
    
        }
    }
    
    

    3、向上述MergeNode类中添加合并2个有序链表的方法 

      public Node merge(Node head1,Node head2){
    
            if(head1 == null && head2 == null){
                return null;
            }
             // head1与head2任一为null,则无需合并,直接返回另一个即可
            if(head1 == null){
                return  head2;
            }
    
            if(head2 == null){
                return head1;
            }
             Node headNode = null;
             Node last = null;
    
            if(head1.no < head2.no){
                headNode = head1;
                last = head1;
                head1 = head1.next;
            }else{
                headNode = head2;
                last = head2;
                head2 = head2.next;
            }
             // 如果head1的值小于head2的值,则新链表的尾节点的next为head1,并且head1指向其next
             // 否则为head2,并且head2指向其next
            while(head1!=null&&head2!=null){
                if(head1.no<head2.no){
                    last.next = head1;
                    last = head1;
                    head1 = head1.next;
                }else{
                    last.next = head2;
                    last = head2;
                    head2 = head2.next;
                }
             }
    
            if(head1 !=null ){
                last.next = head1;// 如果head1链表不为null,则直接放到合并链表的尾部
            }else {
                last.next = head2;// 如果head2链表不为null,则直接放到合并链表的尾部
            }
            // 因为合并链表的头节点是随意初始化的,所以真正合并后的链表头节点应该是当前头节点的next
            return  headNode.next;
        }

    4、测试类MergeSingleLinkedList.class

            Node h1 = new Node(1,"AAA","A");
            Node h2 = new Node(6,"BBB","B");
            Node h3 = new Node(3,"CCC","C");
            Node h4 = new Node(4,"DDD","D");
    
            MergeNode node1 = new MergeNode();
            node1.addByOrder(h1);
            node1.addByOrder(h3);
            node1.addByOrder(h4);
            node1.addByOrder(h2);
     
            MergeNode node2 = new MergeNode();
            Node h11 = new Node(7,"111","11");
            Node h22 = new Node(2,"222","22");
            Node h33 = new Node(5,"333","33");
            Node h44 = new Node(8,"444","44");
    
            node2.addByOrder(h11);
            node2.addByOrder(h33);
            node2.addByOrder(h44);
            node2.addByOrder(h22);
     
            MergeNode mm = new MergeNode();
            Node newNode = mm.merge(node1.head,node2.head);
            System.out.println("合并后的链表打印————————————————————————");
            mm.printNodeList(newNode);
        }
    }

    5、查看输出结果

    合并后的链表打印————————————————————————
    Node{no=1, name='AAA, nickName='A}
    Node{no=2, name='222, nickName='22}
    Node{no=3, name='CCC, nickName='C}
    Node{no=4, name='DDD, nickName='D}
    Node{no=5, name='333, nickName='33}
    Node{no=6, name='BBB, nickName='B}
    Node{no=7, name='111, nickName='11}
    Node{no=8, name='444, nickName='44}

     

    展开全文
  • 两个有序链表合并成一个有序链表 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef struct _node{ int number; struct _node *next; }Node; typedef struct{ Node *head;...

    将两个有序链表合并成一个有序链表

    #include<stdio.h>
    #include<stdlib.h>
    #include<stdbool.h>
    
    typedef struct _node{
    	int number;
    	struct _node *next;
    }Node;
    typedef struct{
    	Node *head;
    	Node *tail;
    }List;
    
    
    void add(List *plist)
    {
    	int number;
    	bool first=true;
    	printf("input the number untill -1\n");
    	scanf("%d",&number);
    	while(number!=-1)
    	{
    		Node *p=(Node *)malloc(sizeof(Node));
    		p->number=number;
    		p->next=NULL;
    		if(first)
    		{
    			plist->head->next=p;
    			plist->tail=p;
    			first=false;
    		}
    		else{
    			plist->tail->next=p;
    			plist->tail=p;
    		}
    		scanf("%d",&number);
    	}
    	
    }
    
    
    void print(List *plist)
    {
    	Node *p;
    	for(p=plist->head->next;  p;p=p->next)
    		printf("%d--",p->number);
    	printf("\n");	
    }
    
    
    void clean_up(List *plist)
    {
    	Node *p;
    	Node *q;
    	for(p=plist->head,q=NULL ; p;p=q)
    	{
    		q=p->next;
    		free(p);
    	}
    }
    
    
    void inversion(List *plist_and);
    int main()
    {
    	List list_and;
    	list_and.head=(Node *)malloc(sizeof(Node));
    	list_and.tail=NULL;
    	
    	inversion(&list_and);
    	printf("the list_and is:\n");
    	print(&list_and);
    	
    	clean_up(&list_and);
    }
    
    
    void inversion(List *plist_and)
    {
    	List list_1,list_2;
    	
    	list_1.head=(Node *)malloc(sizeof(Node));
    	list_1.tail=NULL;
    	
    	list_2.head=(Node *)malloc(sizeof(Node));
    	list_2.tail=NULL;
    	
    	add(&list_1);
    	add(&list_2);
    	
    	printf("the list_1 is:\n");
    	print(&list_1);
    	
    	printf("the list_2 is:\n");
    	print(&list_2);
    	
    	Node *p=list_1.head->next;
    	Node *q=list_2.head->next;	
    	Node *and_=plist_and->head;
    	
    	while( p && q )
    	{
    		if(p->number<q->number)
    		{
    			and_->next=p;
    			and_=p;
    			p=p->next;
    		}
    		else{
    			and_->next=q;
    			and_=q;
    			q=q->next;
    		}
    	}
    	
    	if(p)
    	{
    		and_->next=p;
    	}
    	if(q)
    	{
    		and_->next=q;
    	}
    	
    	free(list_1.head);
    	free(list_2.head);
    }
    
    展开全文
  • java中将两个有序链表合并为一个有序链表: 1.必须保证两个链表为有序链表 2.在两个链表都不为空的条件下,设一个 last=null; (1)如果链表1的值小于等于链表2的值,进行循环,先放链表1的值到新链表result,...
  • 两个有序链表合并成一个链表

    万次阅读 多人点赞 2018-08-04 17:05:37
    代码实现功能如下:将两个有序链表合并成一个有序链表。 具体思路如下:首先自己调用链表的创建函数,手动创建两个有序链表,链表的创建以输入0作为截止标志。创建好两个有序链表之后,将两个链表的头结点进行比较...
  • 将两个有序链表重新排序,合并为一个新...//将两个有序链表合并为一个新的有序链表并返回 public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if (l1 == null) { //链表是否1为null return l2; } el...
  • 两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 2.解法 /** * Definition for singly-linked list. * public class ListNode { * int val; * ...
  • """将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 """ 链表结构: ...
  • 两个有序链表合并 链表插入 删除 修改等
  • 两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 /** * Definition ...
  • 题目:将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 思路: 递归 终止条件...
  • java两个有序链表合并

    2018-11-13 11:50:14
    java两个有序链表合并  今天做了个算法题,遇到了点问题。和大家分享一下 要求是实现两个链表的合并。这个链表可以自己用类实现,也可以用LinkedList。为了方便访问,我用了后者实现。 看一下代码: package ...
  • 两个有序链表合并,合并后的链表仍为有序链表 思路分析: 1)首先定义一个新的链表,并且将其初始化,再定义一个辅助节点cur,该节点指向新的链表的头节点mergeHead 2)循环遍历两个链表h1,h2,每次遍历时各取出一...
  • 问题:将两个有序链表合并成一个有序链表 代码展示: void Merge(LinkList &P,LinkList &Q,LinkList &L) { LinkList p = P->next; LinkList q = Q->next; LinkList l = L; while(p!=NULL &...
  • 两个有序链表合并为一个链表任然有序,两个链表都是从大到小或者从小到大。 方法: 1.将两个链表连起来,对所有元素进行排序。 2.因为两个链表的长度可能不同,则将两链表相同长度的一部分进行排序,将较长链表的...
  • 代码实现功能如下:将两个有序链表合并成一个有序链表。 具体思路如下:首先自己调用链表的创建函数,手动创建两个有序链表,链表的创建以输入0作为截止标志。创建好两个有序链表之后,将两个链表的头结点进行比较...
  • C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现 /*! * Copyright (c) 2020,ZYF. * All Rights Reserved. * * \file MergerListNode.cpp * \brief C++版本将两个有序链表合并为一个新的有序链表并...
  • 请问如何创建“publicstaticSortedListmergeList(SortedListlist1,SortedListlist2)”方法,该方法可以合并两个有序链表成为一个新的有序链表。程序应该遍历每个链表的元素然后直接把...请问如何创建“public static...
  • 两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 /** * Definition for ...
  • 两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的 /* 解题思路: 此题可以先创建一个空链表,然后依次从两个有序链表中选取最小的进行尾插操作进行合并。 */ typedef ...
  • 两个有序链表合并为一个有序链表,链表的大小是可变的
  • 两个有序链表合并为一个新的有序链表并且返回。新链表是通过拼接给定的两个链表的所有节点组成的 思路:假设有一条线段或者一个虚拟头节点,首先比较两个单链表的第一个节点的data的大小,谁小谁就放在线段里面...
  • 利用递归法将两有序链表合并成链表,且合并后的链表仍然有序。 比较链表1和链表2的第一结点数据,如果head1.data&lt;head2.data,则把结果链表头指向链表1的第一结点。 对剩余的head1.next和链表2再次递归...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,092
精华内容 3,236
关键字:

两个有序链表合并