算法---链表

已于 2023-03-28 11:12:04 修改
阅读量155 收藏
点赞数
分类专栏： 算法 文章标签： 链表 算法 数据结构
于 2022-10-21 10:40:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baijaiyu/article/details/127440800
版权

一：总述

面试时链表解题的方法论：

  1. 对于笔试，不用太在乎空间复杂度，一切为了时间复杂度；
  2. 对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法。

对于笔试，追求以最快的速度解决问题；对于面试，则追求问题的最优解。

重要技巧：

  1. 额外数据结构记录（哈希表，链表，集合等）；
  2. 快慢指针。

二：删除链表中重复的节点

1.题目

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表 1->2->3->3->4->4->5 处理后为 1->2->5

2.题解

2.1 思路分析

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.2 具体代码

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        if (pHead == null) {
            return pHead;
        }
        ListNode head = new ListNode(-1);
        head.next = pHead;

        ListNode prev = head;
        ListNode last = prev.next;
        while (last != null) {
            //1.找重复节点的开始
            while (last.next != null && last.val != last.next.val) {
                prev = prev.next;
                last = last.next;
            }
            //2.找到了重复的开始
            while (last.next != null && last.val == last.next.val) {
                last = last.next;
            }
            //3.走到这里，一共三种情况
                //1. last.next != null 并且 (prev, last] 限定了一段重复范围，此时进行去重，prev.next = last.next
                //2. last.next == null 并且 (prev, last] 限定了一段重复范围，此时进行去重，prev.next = last.next
                //3. last.next == null 并且 prev.next == last,这说明，从本次循环开始，都不相同，就不需要进行去重，这个是特殊情况
            if (prev.next != last) { //找到了一段范围，可以去重
                prev.next = last.next;
            }
            last = last.next;//走这一步，就是为了保证恢复的和最开始一致
        }
        return head.next;
    }
}

三：判断一个链表是否为回文结构

1.题目

给定一个链表，请判断该链表是否为回文结构。

2.题解

第一种方法，也就是最简单方法，可以借助栈或者顺序表。遍历单链表，将单链表的每一个节点存储到栈或者顺序表中。如果存储到栈，就再次遍历单链表，并将节点依次出栈，判断是否相同；如果存储到顺序表，就分别从首尾两端遍历顺序表，判断每两个节点是否相同。具体代码如下：

import java.util.*;
public class Solution {
    public boolean isPail (ListNode head) {
        ArrayList<Integer> nums = new ArrayList();
        //将链表元素取出一次放入数组
        while (head != null) {
            nums.add(head.val);
            head = head.next;
        }
        //双指针指向首尾
        int left = 0;
        int right = nums.size() - 1;
        //分别从首尾遍历，代表正序和逆序
        while (left <= right) {
            int x = nums.get(left);
            int y = nums.get(right);
            //如果不一致就是不为回文
            if (x != y)
                return false;
            left++;
            right--;
        }
        return true;
    }
}

第二种方法，快慢指针法。当快指针走到单链表末尾时，慢指针走到了单链表的中间位置。此时，将慢指针后面的节点依次入栈。然后，从单链表表头开始，依次与栈中弹出的元素进行比对，直到栈为空。相比于方法一，这种方法可以节省一半的空间。代码如下：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    public boolean isPail (ListNode head) {
        // write code here
        if (head == null || head.next == null) {
            return true;
        }
        ListNode right = head.next;
        ListNode cur = head;
        while (cur.next != null && cur.next.next != null) {
            right = right.next;
            cur = cur.next.next;
        }
        Stack<ListNode> stack = new Stack<ListNode>();
        while (right != null) {
            stack.push(right);
            right = right.next;
        }
        while (!stack.isEmpty()) {
            if (head.val != stack.pop().val) {
                return false;
            }
            head = head.next;
        }
        return true;
    }
}

第三种方法：

在这里插入图片描述

思路不算难，当然代码量就比较大了，但这种方法确实没有开始额外的空间，只用几个变量就完成了题目。代码如下：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    public boolean isPail (ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        ListNode n1 = head;
        ListNode n2 = head;
        while (n2.next != null && n2.next.next != null) { // find mid node
            n1 = n1.next; // n1 -> mid
            n2 = n2.next.next; // n2 -> end
        }
        n2 = n1.next; // n2 -> right part first node
        n1.next = null; // mid.next -> null
        ListNode n3 = null;
        while (n2 != null) { // right part convert
            n3 = n2.next; // n3 -> save next node
            n2.next = n1; // next of right node convert
            n1 = n2; // n1 move
            n2 = n3; // n2 move
        }
        n3 = n1; // n3 -> save last node
        n2 = head;// n2 -> left first node
        boolean res = true;
        while (n1 != null && n2 != null) { // check palindrome
            if (n1.val != n2.val) {
                res = false;
                break;
            }
            n1 = n1.next; // left to mid
            n2 = n2.next; // right to mid
        }
        n1 = n3.next;
        n3.next = null;
        while (n1 != null) { // recover list
            n2 = n1.next;
            n1.next = n3;
            n3 = n1;
            n1 = n2;
        }
        return res;
    }
}

要想比较容易滴看懂这部分代码，要求对于单链表的基本操作烂熟于心，比如反转一个单链表。

四：划分单链表

1. 题目

给定一个单链表的头节点head，节点的值类型是整型，再给定一个整数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的
节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点.
【进阶】在实现原问题功能的基础上增加如下的要求
【要求】调整后所有小于pivot的节点之间的相对顺序和调整前一样
【要求】调整后所有等于pivot的节点之间的相对顺序和调整前一样
【要求】调整后所有大于pivot的节点之间的相对顺序和调整前一样
【要求】时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。

2. 题解

最简单的一种方法，把每一个链表放到数组里，在数组里排好序，然后再串起来就行了。

package LinkedList_Basic_Class04;

public class Code05_SmallerEqualBigger {

	public static class Node {
		public int value;
		public Node next;

		public Node(int data) {
			this.value = data;
		}
	}

	public static Node listPartition1(Node head, int pivot) {
		if (head == null) {
			return head;
		}
		Node cur = head;
		int i = 0;
		while (cur != null) {
			i++;
			cur = cur.next;
		}
		Node[] nodeArr = new Node[i];
		i = 0;
		cur = head;
		for (i = 0; i != nodeArr.length; i++) {
			nodeArr[i] = cur;
			cur = cur.next;
		}
		arrPartition(nodeArr, pivot);
		for (i = 1; i != nodeArr.length; i++) {
			nodeArr[i - 1].next = nodeArr[i];
		}
		nodeArr[i - 1].next = null;
		return nodeArr[0];
	}

	public static void arrPartition(Node[] nodeArr, int pivot) {
		int small = -1;
		int big = nodeArr.length;
		int index = 0;
		while (index != big) {
			if (nodeArr[index].value < pivot) {
				swap(nodeArr, ++small, index++);
			} else if (nodeArr[index].value == pivot) {
				index++;
			} else {
				swap(nodeArr, --big, index);
			}
		}
	}

	public static void swap(Node[] nodeArr, int a, int b) {
		Node tmp = nodeArr[a];
		nodeArr[a] = nodeArr[b];
		nodeArr[b] = tmp;
	}

	public static void printLinkedList(Node node) {
		System.out.print("Linked List: ");
		while (node != null) {
			System.out.print(node.value + " ");
			node = node.next;
		}
		System.out.println();
	}

	public static void main(String[] args) {
		Node head1 = new Node(7);
		head1.next = new Node(9);
		head1.next.next = new Node(1);
		head1.next.next.next = new Node(8);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(2);
		head1.next.next.next.next.next.next = new Node(5);
		printLinkedList(head1);
		head1 = listPartition1(head1, 5);
		printLinkedList(head1);

	}

}

在这里插入图片描述

方法二：使用六个变量，从头开始遍历整个链表。需要六个变量，小于部分的头和尾，等于部分的头和尾，大于部分的头和尾，一开始所有变量都为空，然后依次将不同区间的节点串起来，最后再整体串起来。以pivot=5为例。

在这里插入图片描述

在进行最后连接时，需要进行充分的考虑。也许整个链表都没有小于5的节点，或者整个链表全是大于5的节点，所以一定要注意考虑全面连接点的情况。

package LinkedList_Basic_Class04;

public class Code05_SmallerEqualBigger {

	public static class Node {
		public int value;
		public Node next;

		public Node(int data) {
			this.value = data;
		}
	}

	public static Node listPartition2(Node head, int pivot) {
		Node sH = null; // small head
		Node sT = null; // small tail
		Node eH = null; // equal head
		Node eT = null; // equal tail
		Node bH = null; // big head
		Node bT = null; // big tail
		Node next = null; // save next node
		// every node distributed to three lists
		while (head != null) {
			next = head.next;
			head.next = null;
			if (head.value < pivot) {
				if (sH == null) {
					sH = head;
					sT = head;
				} else {
					sT.next = head;
					sT = head;
				}
			} else if (head.value == pivot) {
				if (eH == null) {
					eH = head;
					eT = head;
				} else {
					eT.next = head;
					eT = head;
				}
			} else {
				if (bH == null) {
					bH = head;
					bT = head;
				} else {
					bT.next = head;
					bT = head;
				}
			}
			head = next;
		}
		// small and equal reconnect
		if (sT != null) {
			sT.next = eH;
			eT = eT == null ? sT : eT;
		}
		// all reconnect
		if (eT != null) {
			eT.next = bH;
		}
		return sH != null ? sH : eH != null ? eH : bH;
	}

	public static void printLinkedList(Node node) {
		System.out.print("Linked List: ");
		while (node != null) {
			System.out.print(node.value + " ");
			node = node.next;
		}
		System.out.println();
	}

	public static void main(String[] args) {
		Node head1 = new Node(7);
		head1.next = new Node(9);
		head1.next.next = new Node(1);
		head1.next.next.next = new Node(8);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(2);
		head1.next.next.next.next.next.next = new Node(5);
		printLinkedList(head1);
	    head1 = listPartition2(head1, 5);
		printLinkedList(head1);

	}

}

最后的连接点处的判断，浓缩为了两个if语句：

在这里插入图片描述

五 : 链表指定区间内反转

5.1 题目

在这里插入图片描述

5.2 题解

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    public ListNode reverseBetween (ListNode head, int m, int n) {
        // write code here
        ListNode pHead = new ListNode(-1);
        pHead.next = head;
        ListNode pre = pHead;
        for(int i=0; i< m-1;i++) {
            pre = pre.next;
        }
        ListNode cur = pre.next;
        ListNode curNext = new ListNode(-1);
        for(int i=0; i< n-m; i++) {
            curNext = cur.next;
            cur.next = curNext.next;
            curNext.next = pre.next;
            pre.next = curNext;
        }
        return pHead.next;
    }
}

这道题目使用了两种思想 , 一种是普遍使用于链表类题目的 , 即设置虚拟头结点 ; 另外一种则是抽书法 .

在这里插入图片描述

按照这种"抽书法"的思想 , 我们试着对下面链表的指定区间进行反转 .

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

本文到此结束 !

请添加图片描述

知行&
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode_4_输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）
weixin_38862073的博客
05-17 525
/* * 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 限制：0 <= 链表长度 <= 10000 * 方法1：利用递归的思想实现 * 由题意知：逆序返回每个节点值，那么将末尾节点依次添加到list中，然后将list转换为数组即可 * 递归：每次传入head节点，如果节点值为null，直接返回，终止递归 * 如果非null，递归查找下一
面试题06 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）
qq_34823218的博客
10-26 972
package SwordOffer; import java.util.ArrayList; import java.util.Stack; /** * @Description: 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 限制： 0 <= 链表长度 <= 10000 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/...
输入一个链表的头节点，从尾到头反过来返回每个节点的值
wang15735298728的博客
03-21 775
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 方法一：递归方法,每次都是head.next+head.val class Solution: def reversePrint(self, head: ListNode) -> List[int]: if head: return self.reversePrint(head.next)+[head.val] else: return []
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
weixin_44062784的博客
12-19 516
示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 限制： 0 <= 链表长度 <= 10000 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public int[
Objective-C 链表
11-27
在编程领域，链表是一种非常基础且重要的数据结构，它在内存中不连续存放元素，而是通过节点间的指针连接。...理解并熟练掌握链表的操作对于提升编程能力至关重要，特别是在处理动态数据结构和优化算法时。
算法设计-实验五-链表.docx
09-06
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和程序设计中。与数组不同，链表的元素不需要连续的内存空间，每个元素（称为节点）包含数据和指向下一个节点的引用。本资源专注于Python中链表的实现...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
【链表】 链表是一种线性数据结构，其中元素以节点的形式存储，每个节点包含数据和指向下一个节点的引用。在单链表中，每个节点只有一个指向后继节点的指针，而链表的末尾节点指向null。在C#中，可以使用类`Link`来...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
[牛客网刷题 Day1] JZ6 从尾到头打印链表
strawberry47的博客
04-15 299
题目描述 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1]，0 <= 链表长度 <= 10000 思考过程： 之前在LeetCode做过这道题，可是现在看到又做不来了，难受。。。 想不起来怎么构造链表了，上次也是 o(╥﹏╥)o 第一反应是，先用list列表存储ListNode的所有值，再reverse返回。需要注意一下终止条件~ 注意一下，res.reverse()可以让res反转，返回值是none哦
力扣刷题笔记丨算法数据结构--链表--从尾到头打印链表
juehuan1999的博客
02-14 334
1 题目分析 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 链表结构 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ ...
从尾到头打印链表
小东的博客
10-18 227
从尾到头打印链表（点击链接进入题目） 描述 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 如输入{1,2,3}的链表如下图:   返回一个数组为[3,2,1] 示例1   输入：{1,2,3}   返回值：[3,2,1] 示例2   输入：{67,0,24,58}   返回值：[58,24,0,67] 法一：我们发现数组元素的遍历和链表元素的遍历是相反的，这让我们想到了栈的特性，所以我们可以利用栈来实现。 class Solution { public: vect
每日写题分享--牛客--从尾到头打印链表--递归/栈/头插反转
Wangling_blog的博客
11-23 662
题目描述： 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 题目链接 思路： 方法一：递归。 走到最后的节点开始打印链表。 代码实现如下： import java.util.ArrayList; public class Solution { ArrayList<Integer> arrayList=new ArrayList<Integer>(); public ArrayList<Integer> print
python数据结构剑指offer-从尾到头打印链表
漫漫行程路
02-05 763
例题 描述 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1] 0 <= 链表长度 <= 10000 示例1 输入： {1,2,3} 复制 返回值： [3,2,1] 复制 示例2 输入： {67,0,24,58} 复制 返回值： [58,24,0,67] 复制 解决方案 方案一：用单链表解决 def printListFromTailToHead(self , listNode: ListNode)
返回链表内的元素
qq_63102689的博客
05-08 545
输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 /**注意链表的结点的定义方式，数据域和指针域，构造函数 * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { * } * }; */ class Solution { public: vect
【算法】解题总结：剑指Offer 3 从尾到头打印链表（2 种方法）、剑指Offer 36 两个链表的第一个公共结点
Zhou_LC的博客
07-23 121
JZ3 从尾到头打印链表 （简单） 题目 描述 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1] 0 <= 链表长度 <= 1000 示例1 输入： {1,2,3} 返回值： [3,2,1] 示例2 输入： {67,0,24,58} 返回值： [58,24,0,67] 思路 在做这道题时，我想到了两种方法。 (先吐槽一点，题目中说了输入的是链表的头结点，但是我在刷题平台上测试，发现其实输入的是
从尾到头打印链表【刷题记录】
qq_49641239的博客
08-18 109
一、描述 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1] 0 <= 链表长度 <= 10000 二、示例： 示例1 输入： {1,2,3} 返回值： [3,2,1] 示例2 输入： {67,0,24,58} 返回值：[58,24,0,67] 三、代码（python） class Solution: # 返回从尾部到头部的列表值序列，例如[1,2,3] def printListFro
双向链表-算法2.13-2.14
最新发布
10-07
在算法2.13中，我们介绍了向一个已有的双向链表中插入一个新节点的操作。具体来说，算法2.13首先创建一个新节点，然后将新节点的前驱指针设置为当前节点的前驱指针，将新节点的后继指针设置为当前节点，然后将当前...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值