【算法】链表及相关问题1（包括哈希表/有序表介绍/回文问题）

链表与回文判断
原创 于 2024-07-03 00:08:29 发布 · 1.9k 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #散列表 #哈希算法 #数据结构

链表概念

单项链表

链表（Linked List）是一系列节点单向连接而成的数据结构，一般的节点有两个属性，分别是数据（data）和下一个节点的引用(next)。一般,链表会给出头部（Head）节点，通过不断的获取下个节点来遍历整个链表。直到下个节点为null时，则对该链表完成了遍历。

其他链表类型

双向链表

双向链表（double-linked list）其实就是在单项链表的基础上，节点存储多一个上一节点对象的引用（prev）。

环形链表

环形链表则是在单项链表的基础上最后一个节点的下一个节点从null改为头部节点（head）,这样形成一个循环。

链表特性（优缺点）

  1. 链表插入删除效率非常高，O(1)级别，简单地改变节点中的对象引用则可。

  2. 链表灵活的数据规模，以node为单位，增删灵活。无需像以数组为基础的数据结构那样维护数组大小，及时扩容防止溢出。

  3. 无法做到像数组一样下标随机读取。

  4. 相对于数组来说，除了存储数据之外，还需要额外空间来存储下一个节点的引用（next）。

常与链表结合解决问题的数据结构

哈希表（HashSet）

哈希过程(Hashing)需要3个重要的组件，分别是：Key、Hash Function、Hash Table

Key可以是任意的String/Integer，它作为Hash Function 的输入生成Hash Table的下标（Hash Index），好的Hash function会尽可能将不同的key计算成（散列）不同hash Index。

Hash Table本质上是一个数组，只是以Hash Function散列出来的Hash Index作为下标来获取到数据。但有的时候当不同的值被Hash Function计算出同样的值的时候，这时，在该Hash Index下就不是直接存储数据，而是存储一个数组或者树来继续存下具有相同Hash Index的数据。

接下来，我们来JDK Hash Set的实现。可以看到，默认情况下，这个HashSet的构造方法会直接新建一个HashMap，所以HashSet本质是一个HashMap!

那它是如何存储数据又保证唯一的呢？直接看add方法是如何处理的。很简单，直接调用map的put方法，把要存的数据作为key放进map的key中，而value则是一个固定常量（static final修饰）的Object PRESENT。它的作用只是和key组成一对放到map中。

以上，HashSet是借用了HashMap的put方法实现了value不重复的功能。

有序表 (TreeSet)

TreeSet的实现思路和HashSet差不多，内部存储数据用了TreeMap。TreeMap的Tree是指key是基于红黑树（Red-Black Tree）排序的。它的key是有序的，而基于TreeMap实现的TreeSet也自然有序了。

有序的定义可以是自然有序，或者是创建TreeSet时往构造方法中加入一个比较器（comparator），而红黑树就会基于比较器的方式来排序。

相关题目

回文问题

链表节点value值为字符，给出一个链表的头部节点，判断该链表所代表的字符串是否回文。

    public static class ListNode {
        int val;
        ListNode next;

        public ListNode(int value) {
            this.val = value;
        }

        public ListNode(int value, ListNode next) {
            this.val = value;
            this.next = next;
        }

        public ListNode next(int value){
            ListNode next = new ListNode(value);
            this.next = next;
            return next;
        }
    }
简单实现

两次遍历，第一次先遍历链表将每个节点放到栈中。第二次遍历时，一边遍历一边从栈中拿数据pop节点进行比对。利用栈的特性，FILO，pop的过程相当于从后往前遍历。

    private static boolean isPalindrome(ListNode node){
        //方法1. 利用栈
        Stack<Integer> stack = new Stack<>();
        ListNode head = node;
        while (node != null){
            stack.push(node.val);
            node = node.next;
        }
        while (!stack.empty()){
            if (stack.pop() != head.val){
                return false;
            }
            head = head.next;
        }
        return true;
    }
不适用额外空间实现

简单画了一个示意图，首先给定一个链表结构为 1 -> 2 -> 3 -> 2 -> 1，单向链表从header节点开始访问：

  • 状态1：快慢指针，利用两个指针。开始时都从头部往下遍历。指针1每次走1步，指针2每次走两步。当然，这里需要判定的临界点情况就是指针2的下个节点为空时（已经走到最后了），指针1还继续走吗（偶数节点的情况）？我这里的做法就是不往前走。

ListNode n1 = head, n2 = head;

while (n2.next != null){
    n1 = n1.next;
    n2 = n2.next;
    if (n2.next == null){
        break;
    }
    n2 = n2.next;
}

  • 状态2：改变后半段的链表方向。快慢指针的中间节点的next指向null，后续节点指向前一个节点。这里比较考验就是节点与节点之间的关系。我这里用了3个变量完成这个过程。

ListNode n3 = n1;
n1 = n1.next;
n3.next = null;
while (n1 != null){
    n2 = n1.next;
    n1.next = n3;
    n3 = n1;
    n1 = n2;
}

  • 状态3：前后同时遍历。判断是否回文同时恢复到原始状态（未必需要）。这里比较难的是边界判断。我这里判断的标准是下个节点为null时跳出。

n1 = n3;//mark n1 as last head
while (n1 != null){
    n3 = n1.next;
    if (n1.val != n2.val){
        result = false;
    }
    n1.next = n4;
    n4 = n1;
    n1 = n3;
    //move n2
    n2 = n2.next;
}
return result;

以上是简单的示意图，以下则是可运行示例。

import java.util.Stack;

/**
 * 链表 回文问题
 */
public class Palindrome {

    public static void main(String[] args) {
        //create linked like
        //1->2->3->3->2->1
        ListNode f = new ListNode(1);
        f.next(2).next(3).next(3).next(2).next(1);
        //1->2->3->3->2->1
        ListNode s = new ListNode(1);
        s.next(2).next(3).next(4).next(2).next(1);

        //1->2->3->3->2->1
        ListNode t = new ListNode(1);
        t.next(2).next(3).next(3).next(3).next(1);
        //1->2->3->4->3->2->1
        ListNode k = new ListNode(1);
        k.next(2).next(3).next(4).next(3).next(2).next(1);
        System.out.println(k);
        print(s);
        System.out.println(isPalindrome(f));
        System.out.println(isPalindrome(s));
        System.out.println(isPalindrome(t));
        System.out.println(isPalindrome(k));

        System.out.println("====== no extra space solution ========");
        System.out.println(isPalindrome2(f));
        System.out.println(isPalindrome2(s));
        System.out.println(isPalindrome2(t));
        System.out.println(isPalindrome2(k));
        print(f);
        print(s);
        print(t);
        print(k);


    }

    private static boolean isPalindrome(ListNode node){
        //方法1. 利用栈
        Stack<Integer> stack = new Stack<>();
        ListNode head = node;
        while (node != null){
            stack.push(node.val);
            node = node.next;
        }
        while (!stack.empty()){
            if (stack.pop() != head.val){
                return false;
            }
            head = head.next;
        }
        return true;
    }

    private static boolean isPalindrome2(ListNode head){
        ListNode n1 = head, n2 = head;

        while (n2.next != null){
            n1 = n1.next;
            n2 = n2.next;
            if (n2.next == null){
                break;
            }
            n2 = n2.next;
        }
        ListNode n3 = n1;
        n1 = n1.next;
        n3.next = null;
        while (n1 != null){
            n2 = n1.next;
            n1.next = n3;
            n3 = n1;
            n1 = n2;
        }
        //n3 is last head and n1 is null

        boolean result = true;

        n2 = head;
        ListNode n4 = null;

        n1 = n3;//mark n1 as last head
        while (n1 != null){
            n3 = n1.next;
            if (n1.val != n2.val){
                result = false;
            }
            n1.next = n4;
            n4 = n1;
            n1 = n3;
            //move n2
            n2 = n2.next;
        }
        return result;
    }


    public static class ListNode {
        int val;
        ListNode next;

        public ListNode(int value) {
            this.val = value;
        }

        public ListNode(int value, ListNode next) {
            this.val = value;
            this.next = next;
        }

        public ListNode next(int value){
            ListNode next = new ListNode(value);
            this.next = next;
            return next;
        }
    }

    public static void print(ListNode node){
        while (node != null){
            System.out.print(node.val + "->");
            node = node.next;
        }
        System.out.println("null");
    }

}

而关于《链表左小右大》，《克隆链表》，《链表成环》等问题会在下篇文章作介绍。

若本文有任何错漏，欢迎各位指出，共勉。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值