大厂必考链表算法-反转链表/合并有序K链表

已于 2022-05-10 17:49:43 修改
阅读量217 收藏 1
点赞数
分类专栏： 数据结构与算法新手班 文章标签： 链表 算法 数据结构
于 2022-05-09 22:33:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dudu0917/article/details/124673408
版权

反转链表

Node节点

public static class Node<T> {
        public T value;
        public Node next;

        public Node(T data) {
            value = data;
        }

        public void print() {
            Node head = this;
            StringBuffer sb = new StringBuffer();
            while (head != null) {
                sb.append(head == this ? head.value : "-->" + head.value);
                head = head.next;
            }
            System.out.println(sb.toString());
        }
    }

双指针法

思路：

  1. 建立两个指针pre next 以及已知的head节点
  2. next指针存储需要反转节点的下一个节点信息 pre指针存储需要反转的节点的上一个节点信息
  3. 反转当前节点 将head.next --> pre
  4. 将pre向后移动 head节点向后移动 继续反转后一个节点
  5. 重复3 4 步骤 直到head == null 表示已经反转完毕
public static Node reserve2(Node<Integer> head) {
        if (head == null || head.next == null) {
            return head;
        }
        Node pre = null;
        Node next = null;
        //只看next = head.next ; head = next 就是在将head向后移动
        //中间进行了head节点的反转操作 head.next = pre
        //最后将pre的位置向后移动
        while (head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return head;
    }

递归法

思路：

  1. 每个节点都需要设置 node.next.next = node, node.next = null
  2. 递归到最后的5节点时，开始反转链表 4.next.next = 4; 4.next = null
  3. 递归方法返回5节点 此时链表为 1 --> 2 --> 3 --> 4 <-- 5
  4. 递归层层返回 则完成了链表反转

在这里插入图片描述

public static Node reserve(Node<Integer> head) {
        if (head == null || head.next == null) {
            return head;
        }
        Node cur = reserve(head.next);
        head.next.next = head;
        head.next = null;
        return cur;
    }

为什么返回的cur节点就是反转后的头结点?
cur节点在最后return head的时候返回了最后的5节点，在后续返回的时候一直都没有修改，修改的是进入递归的head节点指向,
其他递归返回的都是最开始的5节点

反转双向链表

思路：

  1. 建立两个指针pre next 以及已知的head节点
  2. next指针存储需要反转节点的下一个节点信息 pre指针存储需要反转的节点的上一个节点信息
  3. 反转当前节点 将head.next --> pre ; head.last --> next
  4. 将pre向后移动 head节点向后移动 继续反转后一个节点
  5. 重复2 3 步骤 直到head == null 表示已经反转完毕
public static DoubleNode reserveDoubleNode(DoubleNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        DoubleNode pre = null;
        DoubleNode next = null;
        //只看next = head.next ; head = next 就是在将head向后移动
        //中间进行了head节点的反转操作
        //最后将pre的位置向后移动
        while (head != null) {
            next = head.next;
            head.next = pre;
            head.last = next;
            pre = head;
            head = next;
        }
        return pre;
    }

既然这个链表是双向的了，直接把头结点当成尾节点，尾节点当成头结点不就直接反转了吗？

从逻辑上看，这样确实就算是反转了.但是对于节点的last和next指向是不一样的 。
之前的是4.last = 3 ；4.next = 5
反转后是4.last = 5 ; 4.next = 3

测试链表反转

/**
     * 生成随机的单链表
     *
     * @param len   链表长度
     * @param value 链表值范围
     * @return
     */
    public static Node genListNode(int len, int value) {
        int size = (int) (Math.random() * (len + 1));
        if (size == 0) {
            return null;
        }
        size--;
        Node head = new Node((int) (Math.random() * (value + 1)));
        Node pre = head;
        while (size != 0) {
            Node cur = new Node((int) (Math.random() * (value + 1)));
            pre.next = cur;
            pre = cur;
            size--;
        }
        return head;
    }

    /**
     * 生成随机的双向链表
     *
     * @param len   链表长度
     * @param value 链表值范围
     * @return
     */
    public static DoubleNode genDoubleListNode(int len, int value) {
        int size = (int) (Math.random() * (len + 1));
        if (size == 0) {
            return null;
        }
        size--;
        DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
        DoubleNode pre = head;
        while (size != 0) {
            DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
            pre.next = cur;
            cur.last = pre;
            pre = cur;
            size--;
        }
        return head;
    }

    /**
     * 链表转为list集合
     */
    public static List<Integer> node2List(Node<Integer> head) {
        List<Integer> ans = new ArrayList<>();
        while (head != null) {
            ans.add(head.value);
            head = head.next;
        }
        return ans;
    }

    /**
     * 检查反转的链表结果
     *
     * @param origin 反转前的数据
     * @param head   反转后的链表
     * @return
     */
    public static boolean checkNodeReserve(List<Integer> origin, Node head) {
        for (int i = origin.size() - 1; i >= 0; i--) {
            if (!origin.get(i).equals(head.value)) {
                return false;
            }
            head = head.next;
        }
        return true;
    }

    /**
     * 链表转为list集合
     */
    public static List<Integer> doubleNode2List(DoubleNode head) {
        List<Integer> ans = new ArrayList<>();
        while (head != null) {
            ans.add(head.value);
            head = head.next;
        }
        return ans;
    }

    /**
     * 检查反转的双向链表结果
     *
     * @param origin 反转前的数据
     * @param head   反转后的链表
     * @return
     */
    public static boolean checkDoubleNodeReverse(List<Integer> origin, DoubleNode head) {
        DoubleNode end = null;
        for (int i = origin.size() - 1; i >= 0; i--) {
            if (!origin.get(i).equals(head.value)) {
                return false;
            }
            end = head;
            head = head.next;
        }
        for (int i = 0; i < origin.size(); i++) {
            if (!origin.get(i).equals(end.value)) {
                return false;
            }
            end = end.last;
        }
        return true;
    }

	@Test
    public void testReserve() {
        int len = 5;
        int value = 100;
        int testTime = 100000;
        System.out.println("test begin!");
        for (int i = 0; i < testTime; i++) {
            Node node1 = genListNode(len, value);

            List<Integer> list1 = node2List(node1);

            node1.print();
            node1 = reserve(node1);
            node1.print();
            if (!checkNodeReserve(list1, node1)) {
                System.out.println("Oops1!");
            }

            DoubleNode node3 = genDoubleListNode(len, value);
            List<Integer> list3 = doubleNode2List(node3);

            node3 = reserveDoubleNode(node3);
            if (!checkDoubleNodeReverse(list3, node3)) {
                System.out.println("Oops3!");
            }

        }
        System.out.println("test finish!");

    }

单链表构造队列

public static class NodeToQueue {

        //队列大小
        private int size;
        private Node<Integer> head;
        //没有尾节点时添加元素时间复杂度变为O(n)
        private Node<Integer> tail;

        public NodeToQueue() {
            head = null;
            tail = null;
            size = 0;
        }

        public int size(){
            return size;
        }

        public boolean isEmpty(){
            return size == 0;
        }

        public void offer(int value) {
            Node<Integer> node = new Node<>(value);
            if (head == null) {
                head = node;
                tail = node;
            } else {
                tail.next = node;
                tail = node;
            }
            size++;
        }

        public int poll() {
            int value = -1;
            if (head != null) {
                value = head.value;
                head = head.next;
                size--;
            }
            //help gc
            if (head == null) {
                tail = null;
            }
            return value;
        }

        public int peek() {
            if (head != null) {
                return head.value;
            }
            return -1;
        }
    }

测试：

@Test
    public void testQueue() {
        NodeToQueue myQueue = new NodeToQueue();
        Queue<Integer> test = new LinkedList<>();
        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("测试开始！");
        for (int i = 0; i < testTime; i++) {
            if (myQueue.isEmpty() != test.isEmpty()) {
                System.out.println("Oops!");
            }
            if (myQueue.size() != test.size()) {
                System.out.println("Oops!");
            }
            double decide = Math.random();
            if (decide < 0.33) {
                int num = (int) (Math.random() * maxValue);
                myQueue.offer(num);
                test.offer(num);
            } else if (decide < 0.66) {
                if (!myQueue.isEmpty()) {
                    int num1 = myQueue.poll();
                    int num2 = test.poll();
                    if (num1 != num2) {
                        System.out.println("Oops!");
                    }
                }
            } else {
                if (!myQueue.isEmpty()) {
                    int num1 = myQueue.peek();
                    int num2 = test.peek();
                    if (num1 != num2) {
                        System.out.println("Oops!");
                    }
                }
            }
        }
        if (myQueue.size() != test.size()) {
            System.out.println("Oops!");
        }
        while (!myQueue.isEmpty()) {
            int num1 = myQueue.poll();
            int num2 = test.poll();
            if (num1 != num2) {
                System.out.println("Oops!");
            }
        }
        System.out.println("测试结束！");
    }

单链表构造栈

public static class NodeToStack {
        private Node<Integer> head;
        private int size;

        public NodeToStack() {
            head = null;
            size = 0;
        }

        public int size(){
            return size;
        }

        public boolean isEmpty(){
            return size == 0;
        }

        public int peek(){
            int value = -1;
            if (head != null) {
                value = head.value;
            }
            return value;
        }

        public void push(int value) {
            Node node = new Node(value);
            if (head == null) {
                head = node;
            } else {
                //新加入的节点当做头节点 满足后入先出
                node.next = head;
                head = node;
            }
            size++;
        }

        public int pop() {
            int value = -1;
            if (head != null) {
                //弹出头结点元素
                value = head.value;
                head = head.next;
                size--;
            }
            return value;
        }
    }

测试：

 @Test
    public  void testStack() {
        NodeToStack myStack = new NodeToStack();
        Stack<Integer> test = new Stack<>();
        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("测试开始！");
        for (int i = 0; i < testTime; i++) {
            if (myStack.isEmpty() != test.isEmpty()) {
                System.out.println("Oops!");
            }
            if (myStack.size() != test.size()) {
                System.out.println("Oops!");
            }
            double decide = Math.random();
            if (decide < 0.33) {
                int num = (int) (Math.random() * maxValue);
                myStack.push(num);
                test.push(num);
            } else if (decide < 0.66) {
                if (!myStack.isEmpty()) {
                    int num1 = myStack.pop();
                    int num2 = test.pop();
                    if (num1 != num2) {
                        System.out.println("Oops!");
                    }
                }
            } else {
                if (!myStack.isEmpty()) {
                    int num1 = myStack.peek();
                    int num2 = test.peek();
                    if (num1 != num2) {
                        System.out.println("Oops!");
                    }
                }
            }
        }
        if (myStack.size() != test.size()) {
            System.out.println("Oops!");
        }
        while (!myStack.isEmpty()) {
            int num1 = myStack.pop();
            int num2 = test.pop();
            if (num1 != num2) {
                System.out.println("Oops!");
            }
        }
        System.out.println("测试结束！");
    }

链表实现双端队列

public class LinkedDeque<T> {
    private DoubleListNode<T> head;
    private DoubleListNode<T> tail;
    private int size;

    public LinkedDeque() {
        head = null;
        tail = null;
        size = 0;
    }

    public void addHead(T data) {
        DoubleListNode cur = new DoubleListNode(data);
        if (head == null) {
            head = cur;
            tail = cur;
        } else {
            cur.next = head;
            head.last = cur;
            head = cur;
        }
        size++;
    }

    public void addTail(T data) {
        DoubleListNode cur = new DoubleListNode(data);
        if (head == null) {
            head = cur;
            tail = cur;
        } else {
            cur.last = tail;
            tail.next = cur;
            tail = cur;
        }
        size++;
    }

    public T pollHead() {
        if (head == null) {
            return null;
        }
        DoubleListNode<T> cur = head;
        if (head == tail) {
            head = null;
            tail = null;
        } else {
            head = head.next;
            head.last = null;
            cur.next = null;
        }
        size--;
        return cur.data;
    }

    public T pollTail() {
        if (head == null) {
            return null;
        }
        DoubleListNode<T> cur = tail;
        if (head == tail) {
            head = null;
            tail = null;
        } else {
            tail = tail.last;
            tail.next = null;
            cur.last = null;
        }
        size--;
        return cur.data;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty() {
        return head == null;
    }

    public T peekHead(){
        T ans = null;
        if (head != null) {
            ans = head.data;
        }
        return ans;
    }

    public T peekTail(){
        T ans = null;
        if (tail != null) {
            ans = tail.data;
        }
        return ans;
    }
}

测试：

@Test
    public  void testDeque() {
        LinkedDeque<Integer> myDeque = new LinkedDeque<>();
        Deque<Integer> test = new LinkedList<>();
        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("测试开始！");
        for (int i = 0; i < testTime; i++) {
            if (myDeque.isEmpty() != test.isEmpty()) {
                System.out.println("Oops!");
            }
            if (myDeque.size() != test.size()) {
                System.out.println("Oops!");
            }
            double decide = Math.random();
            if (decide < 0.33) {
                int num = (int) (Math.random() * maxValue);
                if (Math.random() < 0.5) {
                    myDeque.addHead(num);
                    test.addFirst(num);
                } else {
                    myDeque.addTail(num);
                    test.addLast(num);
                }
            } else if (decide < 0.66) {
                if (!myDeque.isEmpty()) {
                    int num1 = 0;
                    int num2 = 0;
                    if (Math.random() < 0.5) {
                        num1 = myDeque.pollHead();
                        num2 = test.pollFirst();
                    } else {
                        num1 = myDeque.pollTail();
                        num2 = test.pollLast();
                    }
                    if (num1 != num2) {
                        System.out.println("Oops!");
                    }
                }
            } else {
                if (!myDeque.isEmpty()) {
                    int num1 = 0;
                    int num2 = 0;
                    if (Math.random() < 0.5) {
                        num1 = myDeque.peekHead();
                        num2 = test.peekFirst();
                    } else {
                        num1 = myDeque.peekTail();
                        num2 = test.peekLast();
                    }
                    if (num1 != num2) {
                        System.out.println("Oops!");
                    }
                }
            }
        }
        if (myDeque.size() != test.size()) {
            System.out.println("Oops!");
        }
        while (!myDeque.isEmpty()) {
            int num1 = myDeque.pollHead();
            int num2 = test.pollFirst();
            if (num1 != num2) {
                System.out.println("Oops!");
            }
        }
        System.out.println("测试结束！");
    }

双端队列实现队列

双端队列实现队列 : 头节点插入 尾节点弹出 或者 头节点弹出 尾节点插入即可

public class MyQueue<T> {
    private LinkedDeque<T> queue;

    public MyQueue() {
        queue = new LinkedDeque<>();
    }

    public void push(T data) {
        queue.addHead(data);
    }

    public T poll() {
        return queue.pollTail();
    }

    public boolean isEmpty() {
        return queue.isEmpty();
    }
}

双端队列实现栈

头节点插入、头节点弹出 或者 尾节点插入、尾节点弹出

public class MyStack<T> {
    private LinkedDeque<T> queue;

    public MyStack() {
        queue = new LinkedDeque<>();
    }

    public void push(T data) {
        queue.addHead(data);
    }

    public T pop() {
        return queue.pollHead();
    }

    public boolean isEmpty() {
        return queue.isEmpty();
    }

}

K个一组翻转链表

问题描述：

力扣地址：https://leetcode.cn/problems/reverse-nodes-in-k-group/
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

思路：

  1. 先构造reverse(ListNode start, ListNode end)方法 反转指定范围内的链表
  2. 再构造getKGroupEnd(ListNode start, int k)方法 根据k的到这组链表的尾节点
  3. 将链表按照getKGroupEnd 分割，每组链表单独反转，
  4. 反转后将第一组的尾节点关联到第二组的头节点中
/**
     * 按K个元素分组反转
     * @param head 链表头结点
     * @param k 长度
     * @return
     */
    public static Node reserveKGroup(Node head, int k){
        Node start = head;
        Node end = getKGroupEnd(head, k);
        //长度不满足K 直接返回
        if(end == null) {
            return head;
        }
        //固定新链表的头结点，这个节点不会变动
        head = end;
        //反转第一组的链表
        reserve(start, end);
        //反转完成后 start节点就是下一组的头结点的上一个节点
        Node lastEnd = start;
        //下一组的头结点不为空
        while (lastEnd.next != null) {
            start = lastEnd.next;
            end = getKGroupEnd(start, k);
            //下一组链表长度不足K 直接返回
            if(end == null) {
                return head;
            }
            //反转下一组的链表
            reserve(start, end);
            //设置上一组的尾节点下一个元素是这组的头节点
            lastEnd.next = end;
            //移动lastEnd到下一组的链表的位置
            lastEnd = start;
        }
        return head;
    }

    /**
     *
     * @param start 头节点
     * @param end 尾节点
     */
    private static void reserve(Node start, Node end) {
        end = end.next;
        Node pre = null;
        //定义临时节点存储头节点位置
        Node cur = start;
        Node next = null;
        while (cur != end) {
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        //将头结点的下一个节点指向到end 防止链表断开
        start.next = end;
    }

    /**
     * 返回当前K个元素链表的尾节点
     * @param start 开始节点
     * @param k 链表长度
     * @return 尾节点
     */
    private static Node getKGroupEnd(Node<Integer> start, int k) {
        while (--k !=0 && start != null) {
            start = start.next;
        }
        return start;
    }

两数相加

力扣地址：https://leetcode.cn/problems/add-two-numbers/
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

思路：

1.先找到较长的链表 通过短链表循环遍历
2.使用变量up存储进位信息 带入到下一个链表元素相加
3.使用相加结果的值/10 = 覆盖到长链表对应元素中
4.最后判断长链表是否遍历完 以及是否存在进位信息

public static Node<Integer> addTwoNode(Node<Integer> head1, Node<Integer> head2){
        int len1 = getNodeLen(head1);
        int len2 = getNodeLen(head2);
        Node<Integer> curL = len1 >= len2 ? head1 : head2;
        Node<Integer> curS = curL == head1 ? head2 : head1;
        //记录新的链表头结点
        Node result = curL;
        //记录长链表的最后一个节点位置
        Node last = curL;
        //链表值相加结果
        int curNum = 0;
        //是否存在进位信息
        int up = 0;
        //短链表和长链表相加
        while (curS != null) {
            curNum = curL.value + curS.value + up;
            up = curNum /10;
            int newNum = curNum % 10;
            curL.value = newNum;
            curS = curS.next;
            last = curL;
            curL = curL.next;
        }
        //长链表还有元素
        while(curL != null) {
            curNum = curL.value + up;
            curL.value = (curNum % 10);
            up = curNum / 10;
            last = curL;
            curL = curL.next;
        }
        if(up != 0) {
            Node end = new Node(up);
            //需要一个节点记录curL最后节点的信息 否则这里得到的可能是null
            last.next = end;
        }
        return result;
    }

    private static int getNodeLen(Node head) {
        int len = 0;
        while (head != null) {
            head = head.next;
            len++;
        }
        return len;
    }

合并两个有序链表

力扣地址：https://leetcode.cn/problems/merge-two-sorted-lists/
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

/**
     * 合并两个有序链表
     * @param head1
     * @param head2
     */
    public Node<Integer> mergeTwoNode(Node<Integer> head1, Node<Integer> head2){
        if(head1 == null || head2 == null) {
            return head1 == null ? head2 : head1;
        }
        Node head = new Node(-1);
        Node pre = head;
        while (head1 != null && head2 != null) {
            if(head1.value <= head2.value) {
                pre.next = head1;
                head1 = head1.next;
            } else {
                pre.next = head2;
                head2 = head2.next;
            }
            //pre指向新添加的节点位置
            pre = pre.next;
        }
        //合并最后不为空的链表
        pre.next = head1 == null ? head2 : head1;
        return head.next;
    }

测试：

private Node sortNode(Node<Integer> node) {
        List<Integer> list = node2List(node);
        Collections.sort(list);
        Node<Integer> head = new Node(-1);
        Node<Integer> r = head;
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            head.next = new Node(iterator.next());
            head = head.next;
        }
        return r.next;
    }

    @Test
    public void testMergeTwoNode(){
        for (int i = 0; i < 50; i++) {
            Node head1 = genListNode(10, 9);
            Node head2 = genListNode(6, 9);
            if (Objects.nonNull(head1)) {
                head1 = sortNode(head1);
                head1.print();
            }
            if (Objects.nonNull(head2)) {
                head2 = sortNode(head2);
                head2.print();
            }
            if(head1 == null && head2 == null) {
                continue;
            }
            Node node1 = mergeTwoNode(head1, head2);
            System.out.println("合并结果：");
            node1.print();
            System.out.println();
        }
    }

合并K个有序链表

思路：

  1. 构造大小为K的优先级队列，默认是小根堆。将K个链表第一个元素放入到队列中
  2. 队列弹出第一个元素就是合并的队列的头节点
  3. 弹出队列的元素的下一个元素进入队列比较大小并弹出新的最小元素
  4. 依次压入和弹出元素即可
public static Node mergeKNode(Node<Integer>[] list) {
        if(list == null) {
            return null;
        }
        //构造小根堆
        PriorityQueue<Node<Integer>> queue = new PriorityQueue(list.length,
                (Comparator<Node<Integer>>) (o1, o2) -> o1.value - o2.value);
        //将每个链表第一个元素放入队列中
        for (int i = 0; i < list.length; i++) {
            if(list[i] != null) {
                queue.offer(list[i]);
            }
        }
        //设置合并的链表的头节点
        Node<Integer> head = queue.poll();
        //临时节点 向后添加元素
        Node<Integer> pre = head;
        //记录需要添加到队列中的链表元素
        Node cur = head;
        while(!queue.isEmpty()) {
            //判空
            if(cur.next != null) {
                queue.offer(cur.next);
            }
            cur = queue.poll();
            pre.next = cur;
            pre = pre.next;
        }
        return head;
    }
dudu0917
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题python之合并K个排序链表
leileii的博客
06-26 656
# Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def mergeKLists(self, lists: List[ListNode]) ...
合并K个有序链表
zkc_home
03-20 1万+
合并K个有序链表 思路：将K个有序链表的首节点放入堆中，并且维护最小堆的性质，然后依次拿走堆顶的元素，每拿走堆顶的元素，是新放一个元素到堆顶 还是将堆的最尾端的元素置换到堆顶，取决于，拿走的元素是否有下一个节点，并且每改变一次堆，就要维护堆，这样，直到堆为空为止 Java实现 /** * Definition for singly-linked list. * public cl...
【每日算法】归并排序及其应用（逆序对&合并有序链表）
jiange_zh的博客
02-19 2710
归并排序是建立在归并操作上的排序算法，是采用分治法（Divide and Conquer）的一个非常典型的应用，它常用来做外排序。若将两个有序表合并成一个有序表，称为二路归并。外排序外排序（External sorting）是指能够处理极大量数据的排序算法。通常来说，外排序处理的数据不能一次装入内存，只能放在读写较慢的外存储器（通常是硬盘）上。外排序通常采用的是一种“排序-归并”的策略。在排序阶段，
K个一组翻转链表
乐只悠悠
05-30 3200
给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。
04-反转链表.md
最新发布
03-31
大厂前端面试算法|# 数据结构和算法 数据结构和算法，是大厂前端面试的“拦路虎”，很多同学都望而生畏。其实如果了解常用数据结构，掌握基本的算法思维，就不能应对。本章将通过多个面试题，为你讲解算法面试题的...
2023大厂前端面试精选-算法题（高频）
10-08
这是一个典型的链表操作题目，要求将两个已排序的链表合并为一个新的有序链表。主要考察的是链表的处理能力和递归或迭代的思维。在JavaScript中，可以使用递归或迭代的方式来解决这个问题。 **递归解法**： 递归...
链表试题可以学习很好
11-29
1. **链表的合并**：将两个已排序的链表合并成一个新的已排序链表。 2. **判断环形链表**：检测链表中是否存在环。 3. **两个链表的交点**：找出两个链表的公共节点。 4. **删除中间节点**：给定索引，删除链表的...
前端大厂最新面试题-算法.docx
06-06
"前端大厂最新面试题-算法.docx"是一份集合了多种算法知识点和经典面试题的资源。本资源摘要将对标题、描述、标签和部分内容进行详细的知识点生成。 算法知识总结 * 排序算法：冒泡排序、选择排序、插入排序、希尔...
尚硅谷 大厂学院 大厂学院算法与数据结构解析.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
反转、合并链表操作合集
存星的博客
05-08 147
链表合集
两个链表一个升序一个降序，合并为升序链表
xiangxianghehe的博客
03-29 5214
**题目解析：**其实可以把题目拆解为：翻转链表+两个有序链表的合并。 代码： struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } void print() { printf("%d -> ",this->val); i...
c++ STL的list用法总结
热门推荐
小拳头的博客
04-21 5万+
头文件 #include   声明一个int型的list：list a； 1、list的构造函数 lista{1,2,3} lista(n) //声明一个n个元素的列表，每个元素都是0 lista(n, m) //声明一个n个元素的列表，每个元素都是m lista(first, last) //声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素，first和last是
写链表逆序，两个链表合并成有序链表
single6的博客
08-30 812
struct Node{ int data; Node *next; }; typedef struct Node Node; Node *Reverse(Node *head){ if(head==NULL||head-&gt;next==NULL) { return head;} Node *p1=head; Node *p2=p1-&gt;next; Node *p3=p2-&gt;...
两个有序链表序列的合并
白给少年
12-21 1384
@两个有序链表序列的合并 两个有序链表序列的合并 已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。 输入格式: 输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。 输出格式: 在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。 输入样例: 1 ...
递归迭代链表不掉
weixin_44895315的博客
10-13 237
24. 两两交换链表中的节点 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例 1： 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1] 提示： 链表中节点的数目在范围 [0, 100] 内 0 <= Node.val <= 100 /*...
剑指 Offer II 025. 链表中的两数相加
Tzecto
09-07 218
剑指 Offer II 025. 链表中的两数相加 给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 可以假设除了数字 0 之外，这两个数字都不会以零开头。 示例1： 输入：l1 = [7,2,4,3], l2 = [5,6,4] 输出：[7,8,0,7] 示例2： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[8,0,7] 示例3： 输入：l1 = [0], l2 = [0] 输出：[
23. 合并K个升序链表（单链表(合并)）
勿忘勿失的博客
04-17 724
题目链接：23. 合并K个升序链表 考查知识：单链表(合并) 题意描述：将K个升序链表进行合并 具体代码 方法一：迭代 依次合并两个链表，在两个链表对应位置都有结点的情况下，取结点权值小的那个连接在新建伪头结点后 最后两个链表谁有剩余，则再接上谁，完成对两个升序链表的合并 依次进行k次，将k个升序链表进行合并class Solution { public: ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {//合并两个链表 .

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值