第三课：链表

最新推荐文章于 2022-08-14 10:13:49 发布
原创 最新推荐文章于 2022-08-14 10:13:49 发布 · 152 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍多种链表操作方法，包括反转链表、寻找公共部分、判断回文链表、链表分区、复制含随机指针的链表及查找相交链表等。提供多种实现方案并详细解释其原理。

1.反转单向链表

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

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

	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;//注意return的是pre
	}

2.反转双向向链表（自己想的时候一开始逻辑都是错的）

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

3.两个链表公共部分

	public static void printCommonPart(Node head1, Node head2) {
		System.out.print("Common Part: ");
		while(head1!=null&&head2!=null){
			if(head1.value==head2.value){
				System.out.print(head1.value+" ");
				head1=head1.next;
				head2=head2.next;
			}else if(head1.value>head2.value){
				head2=head2.next;
			}else{
				head1=head1.next;
			}
		}
	}

4.判断是否是回文链表

	//最简单的方式，使用栈存储
	public static boolean isPalindrome1(Node head) {
		Stack<Integer> stack=new Stack();
		Node p=head;
		while(p!=null){
			stack.push(p.value);
			p=p.next;
		}
		p=head;
		while(!stack.isEmpty()){
			int pop=stack.pop();
			if(p.value!=pop){
				return false;
			}
			p=p.next;
		}
		return true;
	}

	//升级版1：使用栈存一半的数组
	public static boolean isPalindrome2(Node head) {
		if(head==null||head.next==null){
			return true;
		}
		Node h=head;
		Node slow=h;
		Node fast=h;
		Stack<Integer> stack = new Stack<>();
		int num=0;
		while(h!=null){
			num++;
			h=h.next;
		}
		if(num%2==0){
			while(fast!=null){
				slow=slow.next;
				fast=fast.next.next;
			}
		}
		if(num%2==1){
			while(fast.next!=null) {
				slow = slow.next;
				fast = fast.next.next;
			}
		}
		Node slow1=slow;
		while(slow1!=null){
			stack.push(slow1.value);
			slow1=slow1.next;
		}
		while(!stack.isEmpty()){
			if(head.value!=stack.pop()){
				return false;
			}
			head=head.next;
		}
		return true;
	}

//升级版2：使用O（1）的复杂度
public static boolean isPalindrome3(Node head) {
		if(head==null||head.next==null){
			return true;
		}
		//找到中点
		Node h=head;
		Node slow=h;
		Node fast=h;
		while(fast.next!=null&&fast.next.next!=null){
			slow=slow.next;
			fast=fast.next.next;
		}
		//反转右半部分链表
		Node next=null;
		Node pre=null;
		while(slow!=null){
			next=slow.next;
			slow.next=pre;
			pre=slow;
			slow=next;
		}
		Node h2=pre;
		//判断是否是回文
		while(h!=null&&pre!=null){
			if(h.value!=pre.value){
				return false;
			}
			h=h.next;
			pre=pre.next;
		}
		//在反转回原来的
		h=head;
		while(h.next!=null){
			h=h.next;
		}
		Node per2=null;
		Node next2=null;
		while(pre!=null){
			next2=pre.next;
			pre.next=per2;
			per2=pre;
			pre=next2;
		}
		return true;
	}

5.将单向列表分为左边小，中间相等，右边大的形式

//法一：放进node数组中，然后partition
public static Node listPartition1(Node head, int pivot) {
		if(head==null||head.next==null){
			return head;
		}
		//将节点全部放入node数组中
		List<Node> nodeList=new ArrayList<>();
		Node h=head;
		while(h!=null){
			nodeList.add(h);
			h=h.next;
		}
		//partition划分
        arrPartition(nodeList, pivot);
		//链表的重连
		head=h=nodeList.get(0);
        for (int i=1;i<nodeList.size();i++){
            h.next=nodeList.get(i);
            h=h.next;
        }
        h.next=null;
        return head;
    }
	public static void arrPartition(List<Node> nodeArr, int pivot) {
		int left=-1;
		int right=nodeArr.size();
		for(int i=0;i<right;i++){
		    if(nodeArr.get(i).value< pivot){
		        swap(nodeArr,++left,i);;
            }else if(nodeArr.get(i).value> pivot){
		        swap(nodeArr,--right,i);
            }
        }
	}
	public static void swap(List<Node> nodeArr, int a, int b) {
        Node temp = nodeArr.get(a);
        nodeArr.set(a,nodeArr.get(b));
        nodeArr.set(b,temp);
	}

	//法二：分成三个链表，然后重组
	public static Node listPartition2(Node head, int pivot) {
        Node sH=null;
        Node sT=null;
        Node mH=null;
        Node mT=null;
        Node lH=null;
        Node lT=null;
        Node h=head;
        while(h!=null){
            if(h.value<pivot){
                if(sH==null){
                    sH=h;
                    sT=h;
                }else{
                    sT.next=h;
                    sT=sT.next;
                }
            }
            if(h.value==pivot){
                if(mH==null){
                    mH=h;
                    mT=h;
                }else{
                    mT.next=h;
                    mT=mT.next;
                }
            }
            if(h.value>pivot){
                if(lH==null){
                    lH=h;
                    lT=h;
                }else{
                    lT.next=h;
                    lT=lT.next;
                }
            }
            h=h.next;
        }
        if(sH!=null&&mH!=null&&lH!=null){
            sT.next=mH;
            mT.next=lH;
            lT.next=null;
            return sH;
        }
        if(sH==null&&mH!=null&&lH!=null){
            mT.next=lH;
            lT.next=null;
            return mH;
        }
        if(sH!=null&&mH==null&&lH!=null){
            sT.next=lH;
            lT.next=null;
            return sH;
        }
        if(sH!=null&&mH!=null&&lH==null){
            sT.next=mH;
            mT.next=null;
            return sH;
        }
        if(sH==null&&mH==null&&lH!=null){
            lT.next=null;
            return lH;
        }
        if(sH!=null&&mH==null&&lH==null){
            sT.next=null;
            return sH;
        }
        return null;
	}

6.复制含有随机指针节点的链表

//法一：利用hashmap存储节点
public static class Node {
		public int value;
		public Node next;
		public Node rand;

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

	public static Node copyListWithRand1(Node head) {
		HashMap<Node,Node> hashMap=new HashMap<>();
		Node h=head;
		while(h!=null){
			hashMap.put(h,new Node(h.value));
			h=h.next;
		}
		h=head;
		while (h!=null){
			Node now=hashMap.get(h);
			Node next=hashMap.get(h.next);
			now.next=next;
			Node rand=hashMap.get(h.rand);
			now.rand=rand;
			h=h.next;
		}
		return hashMap.get(head);
	}

//法二：复制节点连接成新链表，再拆开（不能同时连接next和rand,也就是不能把第一步和第二步和起来）
public static Node copyListWithRand2(Node head) {
		if(head==null){
			return null;
		}
		Node h=head;
		//连接成了新链表
		while(h!=null){
			Node next=h.next;
			Node newNode=new Node(h.value);
			newNode.next=next;
			h.next=newNode;
			h=next;
		}
		//复制rand节点
		h=head;
		while(h!=null){
			if(h.rand!=null){
				h.next.rand=h.rand.next;
			}else {
				h.rand=null;
			}
			h=h.next.next;
		}
		//将两个链表分开
		Node h1=head;
		Node head2=head.next;
		Node h2=head2;
		while(h1.next.next!=null&&h2.next!=null){
			h1.next=h1.next.next;
			h1=h1.next;
			h2.next=h2.next.next;
			h2=h2.next;
		}
		h1.next=null;
		h2.next=null;
		return head2;
	}

7.两个可能有环也可能无环的节点，若两个链表相交，则返回相交的第一个节点

public class Code07_FindFirstIntersectNode {

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

        public Node(int data) {
            this.value = data;
        }
    }
    //主要函数
    public static Node getIntersectNode(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        //获取两个链表的入环节点
        Node loop1 = getLoopNode(head1);
        Node loop2 = getLoopNode(head2);
        if (loop1 == null && loop2 == null) {
            return noLoop(head1, head2);
        }
        if (loop1 != null && loop2 != null) {
            return bothLoop(head1, loop1, head2, loop2);
        }
        return null;
    }
    //一个链表，判断是否有环，有：返回节点，无：null
    public static Node getLoopNode(Node head) {
        if (head == null || head.next == null || head.next.next == null) {
            return null;
        }
        Node slow = head.next;
        Node fast = head.next.next;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next.next;
            //若走到头了，说明无环
            if (slow.next == null || fast.next == null || fast.next.next == null) {
                return null;
            }
        }
        fast = head;
        //求入环节点
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
    //如果两个链表都无环
    public static Node noLoop(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Node cur1 = head1;
        Node cur2 = head2;
        int length1 = 0;
        int length2 = 0;
        //分别求出两个节点的长度
        while (cur1.next != null) {
            length1++;
            cur1 = cur1.next;
        }
        while (cur2.next != null) {
            length2++;
            cur2 = cur2.next;
        }
        if (cur1 != cur2) {
            return null;
        } else {
            int go = Math.abs(length2 - length1);
            cur1 = head1;
            cur2 = head2;
            //让长的链表先走
            if (length1 >= length2) {
                for (int i = 0; i < go; i++) {
                    cur1 = cur1.next;
                }
            } else {
                for (int i = 0; i < go; i++) {
                    cur2 = cur2.next;
                }
            }
            //走到第一个相加的节点
            while (cur1 != cur2) {
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
            return cur1;
        }
    }
    //如果两个链表都有环
    public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
        Node cur1 = null;
        Node cur2 = null;
        if (loop1 == loop2) {
            //若入环节点是同一个（和上面两个无环的情况类似）
            cur1 = head1;
            cur2 = head2;
            int length1 = 0;
            int length2 = 0;
            while (cur1 != loop1) {
                length1++;
                cur1 = cur1.next;
            }
            while (cur2 != loop1) {
                length2++;
                cur2 = cur2.next;
            }
            int go = Math.abs(length2 - length1);
            cur1 = head1;
            cur2 = head2;
            if (length1 >= length2) {
                for (int i = 0; i < go; i++) {
                    cur1 = cur1.next;
                }
            } else {
                for (int i = 0; i < go; i++) {
                    cur2 = cur2.next;
                }
            }
            while (cur1 != cur2) {
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
            return cur1;
        } else {
            //若入环节点不是同一个，让loop1节点转一圈，若能遇到loop2，说明有相交
            cur1 = loop1.next;
            while (cur1 != loop1) {//让cur1停的条件是转了一圈
                if (cur1 == loop2) {
                    return cur1;
                }
                cur1 = cur1.next;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        // 1->2->3->4->5->6->7->null
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(6);
        head1.next.next.next.next.next.next = new Node(7);

        // 0->9->8->6->7->null
        Node head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next.next.next.next.next; // 8->6
        System.out.println(getIntersectNode(head1, head2).value);

        // 1->2->3->4->5->6->7->4...
        head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(6);
        head1.next.next.next.next.next.next = new Node(7);
        head1.next.next.next.next.next.next = head1.next.next.next; // 7->4


        // 0->9->8->2...
        head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next; // 8->2

        System.out.println(getIntersectNode(head1, head2).value);

        // 0->9->8->6->4->5->6..
        head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next.next.next.next.next; // 8->6
        System.out.println(getIntersectNode(head1, head2).value);

    }
}
数据结构与算法：链表的区块链技术应用
AI 算法实战派
05-28 737
你可能听过「区块链是未来的信任机器」，但它的底层技术到底用了哪些基础数据结构？为什么说「链表」是区块链的骨架？链表的核心特性（指针、链式结构）区块链的区块连接机制（哈希指针）链表如何支撑区块链的「不可篡改」特性用Python实现一个简化版区块链用生活案例讲透链表的核心概念类比链表，拆解区块链的「区块-链」结构揭示「哈希指针」如何让链表升级为「区块链」用Python代码实现一个简化版区块链分析链表在区块链中的关键作用与未来扩展链表（Linked List）
Leetcode快速入门之第八节课: 掌握链表数据移动的小诀窍
热门推荐
herosunly的博客
10-26 1万+
文章目录 1. 对角线法则 1.1 左对角线法则(第一个) 1.2 右对角线法则 1.3 左对角线法则(第二个) 2. 更多题目 2.1 206题反转链表 2.2 92题反转链表IIII 2.3 25题K 个一组翻转链表 1. 对角线法则   什么是对角线法则呢？以交换两个整型变量为例，代码如下所示： void swap(int &a, int &b) { int t = a; a = b; b = t; }   想必大家对上述代码早已烂熟于心。但如果静下心来观察下，就会发现两个对角线法则。为什么要
链表的学习（一）
Qihonghao_的博客
01-28 212
单链表干货来啦！
算法数据结构体系学习 第十一节
啦啦啦的博客
08-14 164
1）其实就是宽度优先遍历，用队列2）可以通过设置flag变量的方式，来发现某一层的结束（看题目） 实现二叉树的序列化和反序列化 1）先序方式序列化和反序列化2）按层方式序列化和反序列化 Encode N-ary Tree to Binary Tree 如何设计一个打印整棵树的打印函数 求二叉树最宽的层有多少个节点 二叉树结构如下定义： Class Node { V value; Node left; Node right; Node parent; } 给你二叉树中的某个节点，返回该节点的后继节点 限定
二叉树相关基本问题
泡泡历险记
01-17 348
二叉树相关基本问题 实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式 在二叉树中找到一个节点的后继节点 二叉树的序列化和反序列化 二叉树按层序列化 判断一颗二叉树是否是平衡二叉树？ 判断一棵树是否为搜索二叉树？判断一棵树是否是完全二叉树？ 已知一颗完全二叉树，求其节点的个数？ (from 左神算法初级班第五节) 1.实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式 1）递归...
二叉树的递归套路
F的博客
11-12 426
二叉树的递归套路 可以解决面试中绝大多数的二叉树问题尤其是树型dp问题 本质是利用递归遍历二叉树的便利性 1）假设以X节点为头，假设可以向X左树和X右树要任何信息 2）在上一步的假设下，讨论以X为头节点的树，得到答案的可能性（最重要） 3）列出所有可能性后，确定到底需要向左树和右树要什么样的信息 4）把左树信息和右树信息求全集，就是任何一棵子树都需要返回的信息S 5）递归函数都返回S，每一棵子树都这么要求 6）写代码，在代码中考虑如何把左树的信息和右树信息整合出整棵树的信息 第一题 是否平衡二叉树
public static class和public class的区别 和builder模式
usstmiracle的博客
01-18 1万+
链接：https://www.jianshu.com/p/749fbd9879cf https://blog.youkuaiyun.com/gengqiquan/article/details/52764455    （builder模式） 新学的java知识，静态类，使用static关键字修饰的类（public static class） 今天在看别人源码的时候看到了一个新知识。使用static关键字...
【哈希表冲突解决课】：链表、开放寻址与双哈希的策略分析
[【哈希表冲突解决课】：链表、开放寻址与双哈希的策略分析](https://img-blog.csdnimg.cn/20200508115639240.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4...
第一课 链表
05-03
3. **两个排序链表的合并**：将两个已排序的链表合并成一个有序链表，可以通过比较两个链表的头节点并逐个合并来实现。 4. **求两个链表的交点**：找出两个链表的公共节点，可以通过双指针或者哈希表来解决。 5. **...
深入探讨：链表的循环判断与高效操作
"本文主要探讨了链表中的四个关键问题：循环链表的判断、找到链表中倒数第m个节点、设计多层次链表以及链表的平铺与取消平铺。文中通过C语言的结构体定义了单链表、双向链表以及多层次链表的结构，并给出了内存分配...
class7 前缀树与贪心问题（左程云左神算法 初级笔记 2018）
quanquanya的博客
05-02 980
calss 7 DAY8 介绍前缀树 arr2中有哪些字符，是arr1中出现的？请打印 arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印 arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印arr2中出现次数最大的前缀。 package com.zuogod.java; /** * 前缀树 * @author quanquan * @create ...
实现哈夫曼树（最优二叉树）
call_damei的博客
03-05 215
public class HuffmanTree { //节点 public static class Node<E> { E data; //数据 int weight; //权重 Node leftChild; //左子节点 Node rightChild;//右子节点 public ...
算法模块学习之二叉树- 前序排序、中序排序、后序排序
大头虾！！
04-28 1664
目的：分别打印二叉树- 前序排序、中序排序、后序排序结果 public static class Node { Node left; Node right; int value; public Node(int value) { this.value = value; } } 首先了解一下前序排序、中序排序、后序排序是怎样的 前序排序：对于每个节点都要满足，先打印节点，再打印左树，再打印右树
express框架，使用 static 访问 public 内静态文件
yun_hou的博客
01-28 5082
使用 express 生成 node 服务器后，我们需要访问放在public文件夹内的静态文件 我们需要在app.js中添加点配置项： app.use('/public',express.static('public')); //或者 app.use('/public',express.static('./public')); //或者 app.use('/public',expre...
静态内部类(public static class)和普通内部类(public class)的区别
文盲青年的博客
09-08 5593
一、static修饰 java中普通的顶级类是不能使用static关键字修饰的。 只有内部类可以使用static修饰，或者不使用staitc关键字修饰。 // 顶层类A不能用static修饰 public class A{ // 普通内部类B, 可以不用static修饰 public class B{ } // 普通内部类C, 也可以用static修饰 public static class C{ } } 二、引用区别 1、静态内部类（s
7.二叉树基本算法
Harrison的学习博客
11-04 374
二叉树结构描述 public static class Node { public int value; public Node left; public Node right; public Node(int v) { value = v; } } 递归方式实现二叉树的先序、中序、后序遍历： 理解递归序，递归遍历的本质是递归序，二叉树递归序，每个节点都会达到三次。 先序、中序、后序都可以在递归序的基础上加工出来 第一次到达一个节点就打印就是先序、第二次打印即中序、第三次即
数据结构基础知识（一）——链表
xinyu2015的博客
05-20 3363
1.  链表 链表作为最基本的数据结构，存储特点：可以用任意一组存储单元来存储单链表中的数据元素(即存储单元可以是不连续的)，其中一个结点(数据域,地址域)，数据域:数据元素，地址域：链表元素的前驱或后继元素的地址。一个线性链表必须使用一个头指针记住元素a0的节点地址。 时间复杂度：1)O(1):isEmpty;               O(n):toString();size();ge
Lua非空判断方法[源码]
最新发布
11-24
本文详细介绍了在Lua中进行非空判断的几种方法，特别是针对table类型的变量。首先，文章指出了直接对nil值进行索引会导致异常的问题，并给出了一个简单的例子来说明如何避免这种情况。接着，文章讨论了如何判断一个table是否为空，指出不能简单地使用`#table == 0`的方式，而是应该使用`next(t) == nil`的方法。此外，文章还提到了`next`指令在LuaJIT中的优化问题，建议在非必要情况下少用。最后，文章简要介绍了如何判断一个字符串是否全部由空格组成，使用了正则匹配的方法。这些内容对于Lua开发者来说非常实用，能够帮助他们避免常见的错误。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值