1、移除未排序的链表中的重复结点

暴力破解

  用两个指针来迭代链表:current 指针迭代访问整个链表,runner 指针用于检查后续的结点是否重复。

 1public static void deleteDups (ListNode<Integer> head) {
 2        if (head == null) {
 3            return;
 4        }
 5        ListNode<Integer> current = head;
 6        // 遍历链表
 7        while (current != null) {
 8            ListNode<Integer> runner = current;
 9            while (runner.next != null) {
10                // 如果有相同的元素,则删除一个元素
11                if (runner.next.data.equals(current.data)) {
12                    runner.next = runner.next.next;
13                } else {
14                    runner = runner.next;
15                }
16            }
17            current = current.next;
18        }
19    }

使用哈希表

  要想移除链表中的重复结点,我们需要设法记录迭代过的结点,这里使用哈希表记录迭代过的结点。
  在下面的解法中,我们会直接迭代访问整个链表,将每个结点加入到哈希表。若发现有重复的元素,将该结点从链表中移除,然后继续迭代。

 1    /**
 2     * 直接迭代访问整个链表,将每个节点加入哈希表。若发现有重复元素,则将该结点从链表中移除,然后继续迭代。
 3     */
 4    public static void deleteDups(ListNode<Integer> head) {
 5        // 创建哈希表
 6        Set<Integer> set = new HashSet<>();
 7        ListNode<Integer> pre = null;
 8        while (head != null) {
 9            if (set.contains(head.data)) {
10                // 如果已存在,则将上一个结点的尾指针指向当前结点的尾指针(删除)
11                pre.next = head.next;
12            } else {
13                set.add(head.data);
14                pre = head;
15            }
16            head = head.next;
17        }
18    }

2、删除链表中倒数第 k 个结点

解法
  使用两个指针 kPointer 和 head 遍历链表,两个指针间隔数为 k,当 head 指针移动到链表尾部时候,kPointer 指针就指向了倒数第 k 个节点。

 1    public static ListNode<Integer> reciprocal(ListNode<Integer> head, int k) {
 2        if (head == null || k <= 0) {
 3            return null;
 4        }
 5        // 两个指针的间隔,倒数第K个和倒数第一个间隔k-1,所以默认值是1
 6        int count = 1;
 7        // K 的指针
 8        ListNode<Integer> kPointer = head;
 9        // 决定 k 的指针是否需要移动
10        boolean flag = false;
11        while (head.next != null) {
12            // 当间隔数等于k时候,k指针开始移动
13            if (count == k) {
14                flag = true;
15            } else {
16                count++;
17            }
18            if (flag) {
19                // 移动k指针
20                kPointer = kPointer.next;
21            }
22            head = head.next;
23        }
24        // 当 count < k 说明 倒数 k 的值不存在
25        if (count < k) {
26            return null;
27        }
28        return kPointer;
29    }

3、删除当前结点

  给定带删除的结点,请执行删除操作,若该结点为尾结点,返回 false,否则返回 true。实现一个算法,删除单链表中间的某个结点,假定你不能访问该结点的前驱。

解法
  既然不能访问该结点的前驱,就拷贝下一个结点的数据,然后删除下一个结点。

 1public boolean removeNode (ListNode<Integer> node){
 2        if(node.next==null){
 3            return false;
 4        }
 5        // 存储下一个结点的数据
 6        node.data=node.next.data;
 7        // 指针指向下下一个结点
 8        node.next=node.next.next;
 9        return true;
10    }

4、分割链表

  编写代码,以给定值 x 为基准将链表分割成两部分,所有小于 x 的结点排在大于或等于 x 节点之前。给定一个链表的头指针 ListNode * head,请返回重新排列后的链表的头指针。注意:分割以后保持原来的数据顺序不变。
例子
链表:5 6 3 2 1,x:3
输出:2 1 5 6 3

解法
  定义左右两个链表和 pointer 指针,指针指向链表头部开始对链表进行迭代。当值小于 x 时,将结点存储到左链表中;当值大于等于 x 时,将结点存储到右链表中,最后合并链表即可。

 1    public static ListNode<Integer> partition(ListNode<Integer> head, int x) {
 2        // 定义左边和右边的头尾
 3        ListNode<Integer> leftFirst = null;
 4        ListNode<Integer> leftTail = null;
 5        ListNode<Integer> rightFirst = null;
 6        ListNode<Integer> rightTail = null;
 7        ListNode<Integer> pointer = head;
 8        // 顺序扫描所有节点
 9        while (pointer != null) {
10            // 当值小于 x时
11            if (pointer.data < x) {
12                if (leftTail == null) {
13                    // 如果是第一次则初始化左边的头和尾
14                    leftFirst = pointer;
15                    leftTail = pointer;
16                } else {
17                    // 将p追加到左边的尾部
18                    leftTail.next = pointer;
19                    // 更新左边尾部的值
20                    leftTail = pointer;
21                }
22            } else {
23                // 当值大于等于 x 时
24                if (rightTail == null) {
25                    // 初始化右边的头和尾
26                    rightFirst = pointer;
27                    rightTail = pointer;
28                } else {
29                    rightTail.next = pointer;
30                    rightTail = pointer;
31                }
32            }
33            pointer = pointer.next;
34        }
35        // 左边链表可能为空
36        if (leftFirst == null) {
37            return rightFirst;
38        }
39        // 将左右两个链表串起来
40        leftTail.next = rightFirst;
41        // 如果右边链表不为空,则将右边链表尾部的下一个赋值空(设置结尾)
42        if (rightTail != null) {
43            rightTail.next = null;
44        }
45        return leftFirst;
46    }

5、链表的加法

  有两个用链表表示的整数,每个节点包含一个数位。这些数位是反向存放的,也就是个位排列在链表的首部。编写函数对这两个整数求和,并用链表形式返回结果。给定两个链表 A,B,请返回 A+B 的结果值。

例子
输入:{1,2,3}{1,2,3,4}
输出:{2,4,6,4}

  当数位是反向存放时,对两个链表从头开始遍历,如果数位和大于 10 则向下一个结点进位即可。

 1    public static ListNode<Integer> plusAB(ListNode<Integer> a, ListNode<Integer> b) {
 2	// 头结点进位为0
 3        return plusAB(a, b, 0);
 4    }
 5
 6    /**
 7     * a和b表示当前位的数,i表示前一位的进的位
 8     */
 9    public static ListNode<Integer> plusAB(ListNode<Integer> a, ListNode<Integer> b, int i) {
10        // 如果都为空,且i为0表示已经遍历完
11        if (a == null & b == null && i == 0) {
12            return null;
13        }
14        int value = i;
15        if (a != null) {
16            value += a.data;
17        }
18        if (b != null) {
19            value += b.data;
20        }
21        ListNode<Integer> result = new ListNode<>(value % 10);
22        result.next = plusAB(a == null ? null : a.next, b == null ? null : b.next, value >= 10 ? 1 : 0);
23        return result;
24    }

进阶:假设是正向存放的

例子
输入:{1,2,3}{1,2,3,4}
输出:{1,3,5,7}

  如果数位是正向存放的,且当两个链表的长度不相等时,用 0 对短链接表进行填充,使其长度和长链表相等。然后从尾结点进行相加向前进位即可。

 1    public static ListNode<Integer> reversePlusAB(ListNode<Integer> a, ListNode<Integer> b) {
 2        int len1 = length(a);
 3        int len2 = length(b);
 4        //用零填充较短的链表
 5        if (len1 < len2) {
 6            a = padList(a, len2 - len1);
 7        } else {
 8            b = padList(b, len1 - len2);
 9        }
10        //对两个链表求和
11        PartialSum sum = addListsHelper(a, b);
12        //如有进位,则插入链表首部,否则,直接返回整个链表
13        if (sum.carry == 0) {
14            return sum.node;
15        } else {
16            return insertBefore(sum.node, sum.carry);
17        }
18    }
19
20    public static PartialSum addListsHelper(ListNode<Integer> a, ListNode<Integer> b) {
21        // 因为 a,b链表长度相同,一个为空另一个也为空
22        if (a == null) {
23            return new PartialSum();
24        }
25        //先递归为较小数字求和
26        PartialSum sum = addListsHelper(a.next, b.next);
27        //将进位和当前数据相加
28        int val = sum.carry + a.data + b.data;
29        //插入当前数字的求和结果
30        sum.node = insertBefore(sum.node, val % 10);
31        //返回求和结果与进位值
32        sum.carry = val / 10;
33        return sum;
34    }
35
36    /**
37     * 将结点插入链表首部
38     */
39    public static ListNode<Integer> insertBefore(ListNode<Integer> list, int data) {
40        ListNode<Integer> node = new ListNode<>(data);
41        if (list != null) {
42            list.pre = node;
43            node.next = list;
44        }
45        return node;
46    }
47
48    /**
49     * 计算链表的长度
50     */
51    public static int length(ListNode<Integer> node) {
52        int size = 0;
53        while (node != null) {
54            size++;
55            node = node.next;
56        }
57        return size;
58    }
59
60    /**
61     * 用零填充链表
62     */
63    public static ListNode<Integer> padList(ListNode<Integer> node, int padding) {
64        ListNode<Integer> head = node;
65        for (int i = 0; i < padding; i++) {
66            ListNode<Integer> n = new ListNode<>(0);
67            head.pre = n;
68            n.next = head;
69            head = n;
70        }
71        return head;
72    }
73
74    public static class PartialSum {
75        /**
76         * 当前结点
77         */
78        public ListNode<Integer> node = null;
79        /**
80         * 向前进位
81         */
82        public int carry = 0;
83    }

6、判断一个链表是不是环链表

  使用两个速度不一样的指针进行移动,如果两个指针相遇,则表示该链表是一个环。

 1  /**
 2     * 判断一个链表是不是环链表
 3     */
 4    public static boolean hasCircle(ListNode<Integer> head) {
 5        ListNode<Integer> s = head;
 6        ListNode<Integer> f = head;
 7        while (true) {
 8            if (f == null || f.next == null) {
 9                return false;
10            }
11            // s 指针每次移动一个节点
12            s = s.next;
13            // f 指针每次移动两个节点
14            f = f.next.next;
15            if (s == f) {
16                return true;
17            }
18        }
19    }

7、求环链表的头结点

  给定一个有环链表,实现一个算法返回环路的开头结点。有环链表的定义:在链表中某个节点的 next 元素指向在它前面出现过的节点,则表明该链表存在环路。

使用哈希表

  如果一个结点出现两次则表明该结点是环链表的头结点。

 1public static ListNode<Integer> check(ListNode<Integer> head) {
 2        ListNode<Integer> p = head;
 3        HashSet<ListNode<Integer>> set = new HashSet<ListNode<Integer>>();
 4        while (true) {
 5            if (set.contains(p)) {
 6                return p;
 7            } else {
 8                set.add(p);
 9                p = p.next;
10            }
11        }
12    }

测试

1public static void main(String[] args) {
2        ListNode<Integer> listNode=new ListNode<Integer>(1);
3        listNode.next=new ListNode<Integer>(2);
4        listNode.next.next=new ListNode<Integer>(3);
5        listNode.next.next.next=new ListNode<Integer>(4);
6        listNode.next.next.next.next=listNode.next;
7        System.out.println(check(listNode).data);
8    }

使用双指针

  使用两个指针 s 和 f,s 指针每次移动一个结点,f 指针每次移动两个结点。如图:

环.png

代码实现

 1public static ListNode<Integer> beginOfCircle(ListNode<Integer> head) {
 2        ListNode<Integer> s = head;
 3        ListNode<Integer> f = head;
 4        do {
 5            // s 指针每次移动一个节点
 6            s = s.next;
 7            // f 指针每次移动两个节点
 8            f = f.next.next;
 9        } while (s != f);
10        // 结束循环时 s 还差 k 个节点就走到了环路的开头节点
11        // 而链表的开头节点和环路的开头节点也相差 k 个节点
12        ListNode<Integer> p = head;
13        // p 指针和 s 指针同时移动,相同点就是环路的开头节点
14        while (p != s) {
15            p = p.next;
16            s = s.next;
17        }
18        return p;
19    }

先判断是否是环链表,再求出头结点

 1public static ListNode<Integer> beginOfCircle1(ListNode<Integer> head) {
 2        ListNode<Integer> s = head;
 3        ListNode<Integer> f = head;
 4        // 判断链表是不是环链表
 5        while (f != null && f.next != null) {
 6            s = s.next;
 7            f = f.next.next;
 8            if (s == f) {
 9                break;
10            }
11        }
12        // 判断循环是以何种方式退出的
13        if (f == null || f.next == null) {
14            return null;
15        }
16        ListNode<Integer> p = head;
17        while (p != s) {
18            p = p.next;
19            s = s.next;
20        }
21        return p;
22    }

8、桶排序

  桶排序的原理是将数分到有限数量的桶子里。每个桶子再个别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序)。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时间,桶排序使用线性时间 O(n),但桶排序并不是比较排序,它不受到 O(nlogn)下限的影响。

  桶排序假设数据会均匀入桶,在这个前提下桶排序速度很快。对于 Java 语言可以不用自己定义链表,直接使用 LinkedList 类。

 1    /**
 2     * 时间复杂度 O(N+C),其中 C=N*(logN-logM)
 3     * 空间复杂度 N+M,M 为桶的个数
 4     * 稳定性:稳定
 5     */
 6    private static void sort(int[] array) {
 7        int length = array.length;
 8        // 桶的个数
 9        LinkedNode[] bucket = new LinkedNode[length];
10        // 获取数组中的最大值
11        int max = array[0];
12        for (int i = 1; i < array.length; i++) {
13            if (max < array[i]) {
14                max = array[i];
15            }
16        }
17        // 入桶
18        for (int value : array) {
19            // 桶的下标
20            int hash = hash(value, max, length);
21            if (bucket[hash] == null) {
22                // 初始化链表表头
23                bucket[hash] = new LinkedNode(value);
24            } else {
25                // 插入链表
26                insertInto(value, bucket[hash], bucket, hash);
27            }
28        }
29        // 记录数组下标
30        int k = 0;
31        for (LinkedNode node : bucket) {
32            if (node != null) {
33                while (node != null) {
34                    array[k++] = node.value;
35                    node = node.next;
36                }
37            }
38        }
39    }
40
41    /**
42     * 根据桶的个数来确定hash函数,这份代码适合桶的个数等于数组长度
43     */
44    private static int hash(int element, int max, int length) {
45        return (element * length) / (max + 1);
46    }
47
48    private static void insertInto(int value, LinkedNode head, LinkedNode[] bucket, int hash) {
49        LinkedNode newNode = new LinkedNode(value);
50        // 小于头节点,放在头上
51        if (value <= head.value) {
52            newNode.next = head;
53            // 替换头节点
54            bucket[hash] = newNode;
55            return;
56        }
57        // 往后找第一个比当前值大的节点,放在这个节点的前面
58        LinkedNode p = head;
59        LinkedNode pre = p;
60        while (p != null && value > p.value) {
61            pre = p;
62            p = p.next;
63        }
64        // 跑到末尾
65        if (p == null) {
66            pre.next = newNode;
67        } else {
68            // 插入pre和p之间
69            pre.next = newNode;
70            newNode.next = p;
71        }
72    }

标题:链表经典练习题
作者:Yi-Xing
地址:http://zyxwmj.top/articles/2020/03/03/1583246683883.html
博客中若有不恰当的地方,请您一定要告诉我。前路崎岖,望我们可以互相帮助,并肩前行!