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

    2021-04-16 20:54:52
    编程实现将两个有序单链表LA(含有m个节点)和LB(含有n个节点)合并成一个新的有序单链表LA,原有单链表LA和LB中的结点都按数据域值以非递减排列。


    前言:
    链表是一种常见的数据结构,他是线性表的一种,他的典型特征就是数据结点之间通过指针相连,链表主要适合存储插入、删除操作比较频繁的数据。这篇文章总结如何合并两个有序链表。

    题目原文

    编程实现将两个有序的单链表LA(含有m个节点)和LB(含有n个节点)合并成一个新的有序单链表LA,原有单链表LA和LB中的结点都按数据域值以非递减排列。

    题目解析

    题目说的太绕,直白的说就是将链表LA、LB合并,合并后的链表依然使用LA来存储,且需要保证合并后的链表依然是有序的(m、n两个链表长度其实没啥用)。

    思路分析

    标识链表的唯一性的是链表的头结点(注意不是首结点),所以我们只需要将所有数据结点都合并到链表LA的头结点上即可,合并所有结点,就需要对两个链表的所有结点进行比较,将比较小的值进行从新排列组成一个新的有序链表。这里的核心要义是只将获取到的更小值所在的链表继续递归,比较结果较大的值应该继续参与下一次的比较。

    代码实现

    //合并两个单链表,且原先两个个链表的节点都是按照非递减排列(递增)
        /**
         * 思路:
         * 核心思路:遍历两个链表,每次只将更小的值继续递归
         *
         * 为什么不使用返回:
         * 不使用返回,是因为操作的都是同一个堆中对象,在调用的地方,原对象就改变了
         * 无需返回再获取,原对象直接使用即可,写返回的话,仅仅是为了更好的理解而已
         * @param LA
         * @param LB
         */
        public static void merge(NewLinkedTable LA, NewLinkedTable LB){
            Node oneNode = LA.head.next;//获取LA的首结点
            Node twoNode = LB.head.next;//获取LB的首结点
            Node threeNode = LA.head;//准备用于拼接新的链表节点的头结点
            int valueOne,valueTwo;//定义两个边量,用于接收两个链表中数据元素的数据域
            while(oneNode!=null && twoNode!=null){//两个链表有一个遍历完成,立即退出循环,因为剩下的元素也是有序
                valueOne = Integer.valueOf(oneNode.object.toString());
                valueTwo = Integer.valueOf(twoNode.object.toString());
                if(valueOne<=valueTwo){//若是LA元素更小
                    threeNode.next = oneNode;//将头结点指向当前元素
                    threeNode = threeNode.next;//更新待拼接元素的节点位置,将其指向最新的节点,等待下一次拼接
                    oneNode = oneNode.next;//当前元素已入新链表,将LA节点往下递归一位
                }else{
                    threeNode.next = twoNode;
                    threeNode = threeNode.next;
                    twoNode = twoNode.next;
                }
            }
            threeNode.next = (oneNode.next!=null?oneNode:twoNode);//当退出循环是LA、LB必定有一个是非null的,拼接非null的数据元素及其以后的结点元素
        }
    

    总结

    这个题目解决的核心思路应该是:循环比较两个链表的元素,每次只递归获取到目标元素所在的链表,另一个链表不用递归,应继续参与下一轮的比较,其他具体细节的思路,在代码中都有注释。记录问题,记录成长,也希望可以帮到路过的你。

    展开全文
  • //合并两个有序单链表 public class Node{ public int value; public Node next; public Node(int data){ this.value=data; } } public Node mergeLinkedList(Node head1,Node head2){ if(head1...
    //合并两个有序单链表
    public class Node{
        public int value;
        public Node next;
        public Node(int data){
            this.value=data;
        }
    }
    public Node mergeLinkedList(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?head1:head2;
        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;
    }

     

    展开全文
  • 合并两个有序单链表的排序算法

    千次阅读 2019-08-30 10:37:05
    合并两个有序单链表的排序算法 分析 有序的单边表,首先以第一个链表list1 为基准,循环与链表list2 作比较。 假如,第一个链表先结束,直接将第二个链表的后面部分连接在list1之后。 假如第二个先结束...

    合并两个有序单链表的排序算法

    分析

    有序的单边表,首先以第一个链表list1 为基准,循环与链表list2 作比较。

    • 假如,第一个链表先结束,直接将第二个链表的后面部分连接在list1之后。

    • 假如第二个先结束,那就不用遍历了。直接结束。
      这样做的话,时间复杂度为list1的长度,即为O(n),
      当然,以断的链表为准基的话,时间复杂度最快。

    代码

    // 合并两个 有序的单链表,让其有序
    LinkList MARGELIST(LinkList l1,LinkList l2){   
    	 LinkList list ,p,q,r,s;    
    	 q=l2;    
    	 list =l1;    
    	 p=list;    
    	 r=p;    
    	 while (p!=NULL&&q!=NULL) {   	 		
    	 	 if (p->data<q->data){              
    	 		 	r=p;              
    	 		 	p=p->link;          
    	 		 }else{              
    	 		 	s=q;              
    	 		 	q=q->link;              
    	 		 	s->link=p;    
    	 		 	// 这里为什么这么写,主要是为了解决list1的第一个结点
                                    // 就比list2的第一个结点大的时候              
    	 		 	if (r==p) {     
    	 		 		r=s;                  
    	 		 		list=r;              
    	 		 	}else{                 
    	 		 		r->link=s;                   
    	 		 		r=s;                
    	 		 	}          
    	 		 }        
    	 }    
    	 if (q!=NULL){        
    	 	r->link=q;    
    	 }        
    	 return list;
    }
    
    展开全文
  • 合并两个有序单链表使之依然有序 代码实现 public static SingleLinkList mergeLinkedList(HeroNode head1, HeroNode head2) { if (head1 == null && head2 == null) { throw new RuntimeException(...

    合并两个有序单链表使之依然有序

    代码实现

     public static SingleLinkList mergeLinkedList(HeroNode head1, HeroNode head2) {
    
        if (head1 == null && head2 == null) {
          throw new RuntimeException("linkedList can't null ");
        }
        // 指向前一个元素
        HeroNode temp1 = head1;
        HeroNode temp2 = head2;
        // 指向操作结点的指针
        HeroNode node = null;
        //
    
        /** 以head1 结点 为合并链表的头结点 */
        while (temp1.next != null) {
          // 链表二不为空
          if (temp2.next != null) {
            // 结点相同
            if (temp1.next.getNo() == temp2.next.getNo()) {
              // 指针往下移动
              temp1 = temp1.next;
              temp2 = temp2.next;
              continue;
            }
            // 2 的结点插入到 1 的前面
            if (temp1.next.getNo() > temp2.next.getNo()) {
    
              node = temp2.next;
              // 将操作的结点从链表中剔除
              temp2.next = temp2.next.next;
              // 操作的结点 加入到1 链表中
              node.next = temp1.next;
              temp1.next = node;
              // 指针往下移动
              temp1 = temp1.next;
              continue;
            }
    
            if (temp1.next.getNo() < temp2.next.getNo()) {
              temp1 = temp1.next;
              continue;
            }
          } else {
            break;
          }
        }
        // 2 链表有剩余
        if (temp2.next != null) {
          // 加入到1最后
          temp1.next = temp2.next;
        }
        SingleLinkList linkList = new SingleLinkList();
    
        linkList.setHead(head1);
    
        return linkList;
      }
    

    测试

    public static void main(String[] args) {
        // 创建结点
        HeroNode heroNode1 = new HeroNode(1, "松江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode heroNode4x = new HeroNode(4, "林冲", "豹子头");
    
        HeroNode heroNode5 = new HeroNode(5, "5", "5");
        HeroNode heroNode6 = new HeroNode(6, "6", "6");
        HeroNode heroNode7 = new HeroNode(7, "7", "7");
        // 创建链表
        SingleLinkList singleLinkList = new SingleLinkList();
    
        SingleLinkList singleLinkList1 = new SingleLinkList();
    
        singleLinkList1.addByOrder(heroNode4x);
        singleLinkList1.addByOrder(heroNode5);
        singleLinkList1.addByOrder(heroNode6);
        singleLinkList1.addByOrder(heroNode7);
    
        singleLinkList.addByOrder(heroNode1);
        singleLinkList.addByOrder(heroNode4);
        singleLinkList.addByOrder(heroNode2);
        singleLinkList.addByOrder(heroNode3);
    
        System.out.println("合并之前:");
        singleLinkList.list();
        System.out.println("================");
        singleLinkList1.list();
        System.out.println("合并之后");
        SingleLinkList linkList = mergeLinkedList(singleLinkList1.getHead(), singleLinkList.getHead());
        linkList.list();
      }
    

    结果显示:
    在这里插入图片描述

    展开全文
  • C递归实现合并两个有序单链表 发现力扣上有简洁的解法 https://leetcode-cn.com/problems/merge-two-sorted-lists/comments/ /** * Definition for singly-linked list. * struct ListNode { * int val; * ...
  • 思路:类似于摘结点法,利用尾指针(tail)把结点摘下来然后链在一起,然后返回头指针 ...//合并两个有序单链表,合并后依旧有序 #include using namespace std; typedef int DataType; typedef struct SListNode {
  • 2.合并两个有序单链表 步骤:首先通过比较确定新链表的头节点,然后移动链表1或者链表2的头指针,然后通过递归来得到新的链表头节点的next指针。 public static Node mergeList(Node list1 , Node list2){ if(list...
  • 基于递归法和循环法实现“合并两个有序单链表,使得合并后的链表仍然有序”,给出了完整程序,经测试通过。
  • 17.合并两个有序单链表 输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的。 样例 输入:1->3->5 , 2->4->5 输出:1->2->3->4->5->5 思路 遇到将两个...
  • 1、合并两个有序单链表,要求合并后依旧有序。 OJ链接:https://leetcode-cn.com/problems/merge-two-sorted-lists/description/ 高频考察的大厂云图: 题目:将两个升序链表合并为一个新的 升序 链表并返回。...
  • 两个有序的链表合并为一个新链表,要求新的链表是通过拼接两个链表的节点来生成的,且合并后新链表依然有序。 输入 {2},{1} 返回值 {1,2} 思路: 使用2个指针分别指向两个有序单链表,用两层while 分别用两个指针...
  • package datastruct.uselikedlist... * 合并两个单链表 * */ class ListNode{ int val ; ListNode next; public ListNode(int x) { this.val=x; } } public class MergeTwoOfLikedList { ListNode head=
  • 1、合并两个有序链表 解法:因为两个链表都是有序的,可以定义一个虚拟节点,让两个链表的每个节点的数据域循环比较,不断将小的节点挂接在虚拟节点上串起一个新的链表。 eg:有如下两个单链表 串上第一个节点 串...
  • 合并两个有序单链表 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode...
  • 题目:合并两个有序单链表 递归: /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode Merge(ListNode...
  • 一个面试题目,将两个递增的有序单链表合并成一个递增单链表。有两种理解: 1、new一个单链表,返回新的头节点 2、在原链表上操作,返回新的头节点 第一种实现较为简单,只需要从头比较链表的节点,将较小的插入新...
  • 合并两个有序单链表,使得最终的链表也是递增的。 节点的结构 typedef struct ListNode { ListNode* _next; int _data; }Node; 递归: Node* MergeListR(Node* Head1,Node* Head2) { if(NULL == Head1...
  • 合并两个有序单链表,并返回一个合并后的链表。 例子: Input: 1->2->4, 1->3->4 Output: 1->1->2->3->4->4 我这种傻瓜的思路就只是合并链表的基本算法,挨个节点进行比较,较小的一方接入结果链表并向next移动...
  • java实现合并两个有序单链表

    千次阅读 2019-03-12 17:01:51
    * 将两个有序单链表合并 * @param node1 * @param node2 * @return */ public static NodeList mergeLink(NodeList node1,NodeList node2){ if(node1 ==null){ return node2; } if(node2 ==...
  • 已知两个链表head1和head2各自有序,请把它们合并成一个链表依然有序。结果链表要包含head1和head2的所有节点,即使节点值相同。注意:不能开辟新空间来存储合并后的链表。如果第一次做该题,很容易会想到使用新链表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,691
精华内容 7,076
关键字:

合并两个有序的单链表