数据结构之链表面试题汇总（二）-有序单向链表的合并、单向链表反转

最新推荐文章于 2022-10-29 13:38:00 发布
最新推荐文章于 2022-10-29 13:38:00 发布
阅读量702 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andy_px/article/details/78429474
版权

date: 2016-08-18 9:13:00
title: 数据结构之链表面试题汇总（二）-有序单向链表的合并、单向链表反转
categories: 数据结构

版权声明：本站采用开放的[知识共享署名-非商业性使用-相同方式共享 许可协议]进行许可

所有文章出现的代码，将会出现在我的github中，名字可以根据类全名来找，我在github中的文件夹也会加目录备注。

合并两个有序的单向链表，合并之后的链表依然有序【出现频率高】（剑指offer，题17）

思路:

  • 若两个链表本来有序，在合并的时候，可以参照一下归并排序的归并部分，原理一样。

  • 先比较两条链表的节点，先把小的放进新链表，当其中一条链表到达最后一个节点的时候结束循环

  • 在结束循环后判断那条链表为空，然后直接设置下一个节点为另外一个链表的节点即可，这样就可以把剩下的节点都连接上

图解:

public class MergeList {
    public static Node mergeList(Node head1, Node head2) {
        // first judge 2 head is null together
        if (head1 == null && head2 == null) {
            throw new RuntimeException("the 2 of them are null");
        }
        // judge if one of them is null then return another
        if (head1 == null)
            return head2;
        if (head2 == null)
            return head1;

        // declare two variables to record the newHead and current pointers
        Node newHead;
        Node current;

        // get the first in the new node
        if (head1.getRecord() < head2.getRecord()) {
            newHead = head1;
            current = head1;
            head1 = head1.getNext();
        } else {
            newHead = head2;
            current = head2;
            head2 = head2.getNext();
        }

        // loop that put the less one to the list and update the position while
        // one of them is null
        while (head1 != null && head2 != null) {
            if (head1.getRecord() < head2.getRecord()) {
                current.setNext(head1);
                current = current.getNext();
                head1 = head1.getNext();
            } else {
                current.setNext(head2);
                current = current.getNext();
                head2 = head2.getNext();
            }
        }
        // if one of them are null which indicates that the other is not null
        // and put
        if (head1 == null) {
            current.setNext(head2);
        }
        if (head2 == null) {
            current.setNext(head1);
        }
        // is to the list
        // return new list
        return newHead;
    }

}

测试代码： 第二个链表中的元素都比第一个链表的元素大

public class ReverseLinkedListTest {

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);

        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);

        Node list1 = new Node(7);
        Node list2 = new Node(8);
        Node list3 = new Node(9);
        Node list4 = new Node(10);
        list1.setNext(list2);
        list2.setNext(list3);
        list3.setNext(list4);

        RecustionAllElementOfLinkedList.printAllElements(MergeList.mergeList(
                node1, list1));
    }

}

运行结果：

测试代码二：第二个链表中有与第一个链表相同的元素：

public class ReverseLinkedListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);

        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);

        Node list1 = new Node(1);
        Node list2 = new Node(2);
        Node list3 = new Node(6);
        Node list4 = new Node(7);
        list1.setNext(list2);
        list2.setNext(list3);
        list3.setNext(list4);

        RecustionAllElementOfLinkedList.printAllElements(MergeList.mergeList(
                node1, list1));
    }

}

运行结果：

单链表的反转【出现频率最高】（剑指offer，题16）

思路:

  • 可以考虑用栈来存放链表中的元素，然后再通过弹栈来存入新链表中来实现该功能，但是这样做不高效

  • 也可以考虑用数组存放链表中的元素，然后通过倒序获取数组中的元素来实现

  • 在这里主要讨论使用递归实现单向链表的反转

    • 首先判断节点是否为空，为空抛异常
    • 接着得到当前节点的下一个节点
    • 把当前节点的下一个节点设置成null
    • 把下一个节点作为参数递归调用，返回的是最后一个节点
    • 把下一个节点的下一个节点设置成当前节点，下一个节点为5 当前节点为4 结果为5.setNext(4)
    • 还有4 3，3 2 ，2 1 完成之后返回递归返回的节点，即新链表的头节点

图解

代码实现：包含使用栈、双指针、递归的方法

public class ReverseLinkedListUtil {
    /**
     * use stack to reverse single-direction LinkedList
     * 
     * @param head
     *            the head of a LinkedList
     * @return the new head of a LinkedList
     */
    public static Node reverseByStack(Node head) {
        Stack<Node> nodes = new Stack<Node>();
        if (head == null) {
            throw new RuntimeException("the Node is null !");
        }
        // put all the node to the stack
        while (head != null) {
            nodes.push(head);
            head = head.next;
        }
        // get all the node in the stack
        head = nodes.pop();
        Node curNode = head;
        while (!nodes.isEmpty()) {

            // update the next of the node
            Node nextNode = nodes.pop();
            nextNode.setNext(null);
            curNode.setNext(nextNode);
            curNode = nextNode;

        }
        // return the new head
        return head;
    }

    /**
     * use 2 pointers to reverse the single-direction LinkedList
     * 
     * @param head
     *            the head of a single-direction LinkedList
     * @return the new head of a single-directionLinkedList
     */
    public static Node reverseByPointer(Node head) {
        // define the previous node to record the previous node
        Node previous = null;
        // judge that the current node is null
        while (head != null) {
            // if true move the 2 pointers backward
            // get the next node and record it
            Node next = head.getNext();
            // set the next.next to previous
            head.setNext(previous);
            // set the previous to current (head)
            previous = head;
            // set the next to next
            head = next;
        }
        // else break out the loop
        return previous;
    }

    /**
     * use recursion to reverse the single-direction LinkedList
     * 
     * @param head
     *            the head of the LinkedList
     * @return the new-head of the LinkedList that has been reversed
     */
    public static Node reverseByRecur(Node head) {
        // if the tail is reached return it
        if (head == null || head.next == null)
            return head;
        // get the next node
        Node nextNode = head.getNext();
        // set the current node's next node to null
        head.setNext(null);
        // recursion
        Node recursionResult = reverseByRecur(nextNode);
        // set the next node's next node to current
        nextNode.setNext(head);
        // return the value that was returned from the recursion
        return recursionResult;
    }

}

测试代码：

public class ReverseLinkedListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);

        RecustionAllElementOfLinkedList.printAllElements(ReverseLinkedListUtil
                .reverseByRecur(node1));
    }

}

运行结果：

aaa11111232
关注
专栏目录
轻松搞定面试中的链表题目
计算机的艺术
04-21 6万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7393134 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。本文对链
数据结构——有序单链表原地合并（C语言）
Melody_my的博客
10-05 597
将两个有序单链表进行合并，合并结果仍有序。（合并过程不占用其他存储空间） #include<stdio.h> #include<stdlib.h> #define MAXSIZE 10010 #define ElemType int typedef struct LNode{ ElemType data; LNode *next; }LNode,*LinkList; //创建 LinkList initLinkList(int num){ LNode* h.
反转有序链单链表
时光过客
07-06 698
本文总结了2种方法。 1 定义 单链表node的数据结构定义如下： class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } } 2 方法1：就地反转法 2.1 思路 把当前链表的
合并两个有序的单向链表
codeydj的博客
05-20 285
https://blog.csdn.net/fengpojian/article/details/81384130
有序链表的合并和链表的反转
wuxudong12138的博客
09-26 262
有序链表的合并和链表的反转有序链表的合并链表的反转 有序链表的合并 主要采用了递归的思想 package com.dataStructure.LinkedList; public class MyLinkedListTest { public static void main(String[] args) { /* * 合并两个链表： * ...
数据结构与算法（四）：Python实现单链表的反转、环的检测、两个有序链表的合并、判断单向链表是否是回文字符串
01-20
根据链表数据结构的知识，进行初步练习，从单链表的反转、环的检测、两个有序链表的合并、判断单向链表是否是回文字符串四个题目着手，分别进行代码实现。 首先定义单链表类： # 结点类 class Node(object): def _...
Java实现单向链表反转
08-27
单向链表反转的应用非常广泛，例如在数据处理中，我们可以使用单向链表反转来实现数据的反转操作。在数据分析中，我们可以使用单向链表反转来实现数据的排序操作。 下面是Java实现单向链表反转的代码示例： ```...
数据结构--单向链表及其增、删、改、查、排序等操作的实现（C语言）
羟基与苯的博客
04-10 2567
文章目录🎃链表🎃单向链表的实现（C语言）📌结点类型描述📌1.创建初始化一个链表结点📌2.从链表尾部插入数据📌3.链表遍历打印📌4.查找链表：按结点序号查找📌5.查找链表：按数据内容查找📌6.在任意位置插入一个数据📌7.删除链表：按结点序号删除📌8.删除链表：按数据内容删除📌9.free释放内存📌10.求链表数据个数🎃单向链表总结 本章内容：单链表的概念；单链表结点模型；单链表的各运算实现。 本文涉及实现单链表完整代码已提交至码云Gitee中，供读者参考。 🎃链表 我们之前实现了数据结构中第一个结构–顺序
python实现反转部分单向链表
12-24
给定一个单链表的头指针 head， 以及两个整数 a 和 b，在单链表中反转 linked_list[a-b] 的结点，然后返回整个链表的头指针。 例如： 单链表[1000, 5, 12, 100, 45, ‘cecil’, 999]， a = 4， b = 6， 返回的...
数据结构之单向循环链表
yjhqukq的博客
10-29 2347
单向循环链表与单向链表的结点结构相同，每个结点都有一个数据域、一个指针域。数据域用来存储结点的数据，指针域用来存储下一个结点所在的内存空间地址。两者不同的是，单向链表末结点的指针域为NULL，而单向循环链表末结点的指针域存储了头结点所在的内存空间地址。这里实现了单向循环链表的六个基本功能，初始化链表、添加结点(头插法、尾插法)、删除结点、反转链表、遍历链表。
数据结构 顺序链表 两个表合并 代码实现
12-04
1、学习数据结构 用代码实现入门程序。 2、[数据结构(C语言版)].严蔚敏_吴伟民 版代码实现，可直接运行
数据结构与算法C语言实现——单链表有序合并
abcwsp的博客
12-11 339
数据结构与算法——单链表合并 雨中漫步 之前介绍在输入不同的情况下如何有序合并归一单链表 今天介绍如果不能有重复数字应该如何处理 #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *ne...
链表面试题--合并两个有序的链表
f2016913的博客
04-21 1206
问题：合并两个有序的链表，合并后结果任有序 非递归实现：两个指针分别遍历两个链表，然后比较两个指针大小，将小的节点取下放到合并后的新链表中，继续向后移动当前的指针，若两个链表至少有一个表扫描走完，走将对应的另一个表，整体添加合并后的新表中，这样就可以实现链表的合并。 方法一：ListNode* MergeList1(ListNode*l1, ListNode*l2) { if (l1
数据结构与算法——有序链表合并
moyu的博客
03-24 617
要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int ElementType; typedef struct Node *PtrToNode; struct Node { ElementType Data; PtrToNode ...
请编写一段代码，实现两个单向有序链表的合并
qq_40788950的博客
03-06 825
#include &lt;iostream&gt; #include &lt;malloc.h&gt; #include &lt;vector&gt; using namespace std; typedef struct Node { int data; struct Node* next; }LNode,*Linklist; void PrintList(Linkl...
实现单向链表的反转
myflysky的专栏
09-29 508
1.可以用临时变量前移方式逐步实现反转。利用前中后三个临时变量，逐步前移并反转实现 public static &lt;T&gt; ListNode&lt;T&gt; reverseListTest1(ListNode&lt;T&gt; node){ ListNode&lt;T&gt; pre=null; ListNode&lt;T&gt; cur=node; ListNode&lt;...
数据结构单链表之合并两个有序链表笔记。
c++爱好者
03-20 386
1.0题目描述： 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 2.0例子演示： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 3.0思路分析： 1.0 首先新建一个虚拟头结点Assumehead(为了之后链表L1以及链表L2的排好序之后， 方便找到改.
有序单链表合并和单链表反转
wodazhouyi的博客
08-19 138
//递归的方法 LinkList mergeTwoList2(LinkList l1,LinkList l2) { if(l1 == NULL) { return l2; } if(l2 == NULL) { return l1; } else if(l1->data <= l2->data) { l1->next = mergeTwoList2(l1->next, l2); return l1; } else { l2->.
c语言设计单向链表结构,并完成反转链表功能
最新发布
09-14
在C语言中设计单向链表结构通常包括定义链表节点的数据结构和相关操作函数。下面是一个简单的例子： 首先定义链表节点的结构体，包含数据域和指向下一个节点的指针： ```c typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } Node; ``` 接着可以编写函数来创建链表节点、插入节点、删除节点和反转链表等操作。这里重点介绍如何实现反转链表的功能。 反转链表可以通过迭代的方式实现，具体步骤如下： 1. 初始化三个指针，分别命名为 `prev`、`current` 和 `next`。 2. 遍历原始链表，每次迭代中将 `current` 指向的节点的 `next` 指针指向前一个节点 `prev`。 3. 同时移动 `prev` 和 `current` 指针，直到 `current` 指向 `NULL`，这时 `prev` 将指向原链表的最后一个节点，即反转后链表的第一个节点。 4. 最后更新链表的头指针，指向 `prev`。 下面是反转链表的函数实现： ```c Node* reverseList(Node* head) { Node *prev = NULL, *current = head, *next = NULL; while (current != NULL) { next = current->next; // 保存下一个节点 current->next = prev; // 反转当前节点的指针 prev = current; // 移动prev到当前节点 current = next; // 移动current到下一个节点 } head = prev; // 更新头指针 return head; } ``` 这段代码将会反转给定的单向链表，并返回新的头指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值