00第四节课笔记

xyqudamah

已于 2023-02-06 23:33:52 修改

阅读量60

点赞数

分类专栏： 00算法文章标签： java 数据结构开发语言

于 2023-02-06 23:30:21 首次发布

本文链接：https://blog.csdn.net/xyqudamah/article/details/128901347

版权

00算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.反转单链表

//    单链表反转
    public static Node reverseLinkedList(Node head){
        Node pre = null;
        Node next = null;
        while (head !=null){
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }

2.反转双链表

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

3.用单链表实现队列

4.用双链表实现双端队列

5.K个节点的组内逆序调整问题

给定一个单链表的头节点head，和一个正数k 实现k个节点的小组内部逆序，如果最后一组不够k个就不调整

例子:

调整前：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8，k = 3

调整后：3 -> 2 -> 1 -> 6 -> 5 -> 4 -> 7 -> 8

package 左乘云.新手班.第4节;

public class k个节点局部逆序 {
    public static void main(String[] args) {
        Node node = new Node(1);
        inserNode(node, new Node(2));
        inserNode(node, new Node(3));
        inserNode(node, new Node(4));
        inserNode(node, new Node(5));
        inserNode(node, new Node(6));
        inserNode(node, new Node(7));
        inserNode(node, new Node(8));
        print(node);
        System.out.println();
        Node rev = rev(node, 9);
        print(rev);
    }
    public static class Node{
        int value;
        Node next;
        Node pre;
        public Node(int value){
            this.value = value;
        }
    }
    public static void inserNode(Node head, Node node){
        Node p = head;
        while (p.next!=null){
            p = p.next;
        }
        p.next = node;
        node.pre = p;
    }

    public static void print(Node head){
        Node p = head;
        while (p != null){
            if (p.next!=null) System.out.print(p.value + " -> ");
            else System.out.println(p.value);
            p = p.next;
        }
    }
//    k表示几个变
    public static Node rev(Node head, int k){
        if (k<1) return head;
        int size = size(head);
        Node h = head;
        Node duantou = head;

        if (size/k >= 1){
            for (int i = 0; i < k-1; i++){
                h = h.next;//找出新头
            }
        }
            int headNum = 1;
            int tailNum = k;
            for (int i = 0; i < size/k; i++){
                Node headP = head;
                Node tailP = head;
                for (int j = 1; j < headNum; j++){
                    headP = headP.next;
                }
                for (int j = 1; j < tailNum; j++){
                    tailP = tailP.next;
                }
                head = duantou(head, tailP, headP);
                System.out.println("new:");
                print(head);
                headNum = headNum+k;//5
                tailNum = tailNum+k;//8
            }
        return head;
    }

    public static Node duantou(Node head, Node tailP, Node headP){
        if (headP.pre == null && tailP.next == null){
            return reverseDoubleLinked(head);
        }
        else if (headP.pre == null){
            Node right = tailP.next;
            right.pre = null;
            tailP.next = null;
            Node newDuan = reverseDoubleLinked(head);
            Node tempP = newDuan;
            while (tempP.next!=null) tempP = tempP.next;
            tempP.next = right;
            right.pre = tempP;
            return newDuan;
        }
        else if (tailP.next == null){
            Node left = headP.pre;
            left.next = null;
            headP.pre = null;
            Node newDuan = reverseDoubleLinked(headP);
            Node tempP = newDuan;
            left.next = newDuan;
            newDuan.pre = left;
            return head;
        }
        else {
            Node right = tailP.next;
            right.pre = null;
            tailP.next = null;
            Node left = headP.pre;
            left.next = null;
            headP.pre = null;
            Node newDuan = reverseDoubleLinked(headP);
            left.next = newDuan;
            Node tempP = newDuan;
            newDuan.pre = left;
            while (tempP.next!=null) tempP = tempP.next;
            tempP.next = right;
            right.pre = tempP;
            return head;
        }

    }

//    获取链表长度
    public static int size(Node head){
        Node p = head;
        int size = 0;
        while (p != null){
            size++;
            p = p.next;
        }
        return size;
    }

    public static Node reverseDoubleLinked(Node head){
        Node pre = null;
        Node next = null;
        while (head!=null){
            next = head.next;
            head.next = pre;
            if (pre!=null) pre.pre = head;
            pre = head;
            head = next;
        }
        return pre;
    }
}

6.两个链表相加问题

给定两个链表的头节点head1和head2，认为从左到右是某个数字从低位到高位，返回相加之后的链表

例子 4 -> 3 -> 6 2 -> 5 -> 3

返回 6 -> 8 -> 9 解释 634 + 352 = 986

（我在代码中用的是链表的拆下来转换成数字，再加再转换成链表，此题求的是直接用链表计算，就像竖式计算一样）

7.两个有序链表的合并

给定两个有序链表的头节点head1和head2，返回合并之后的大链表，要求依然有序

例子 1 -> 3 -> 3 -> 5 -> 7 2 -> 2 -> 3 -> 3-> 7

返回 1 -> 2 -> 2 -> 3 -> 3 -> 3 -> 3 -> 5 -> 7

（造孽啊，没听完，应该用不建立新链表的方法写的）

package 左乘云.新手班.第4节;

import java.util.ArrayList;

public class 有序链表的合并 {
    public static void main(String[] args) {
        Node node = new Node(1);
        insertNode(node, 3);
        insertNode(node, 3);
        insertNode(node, 5);
        insertNode(node, 7);
        print(node);
        System.out.println();
        Node node1 = new Node(2);
        insertNode(node1, 2);
        insertNode(node1, 3);
        insertNode(node1, 3);
        insertNode(node1, 7);
        print(node1);
        System.out.println();
        Node hebing = hebing(node, node1);
        hebing = hebing.next;
        print(hebing);
    }
    public static Node hebing(Node node1, Node node2){
        Node node = new Node();
        Node temp1 = node1;
        Node temp2 = node2;
        while (temp1!=null&&temp2!=null){
            if (temp1.value<temp2.value){
                insertNode(node, temp1.value);
                temp1=temp1.next;
            }else {
                insertNode(node, temp2.value);
                temp2 = temp2.next;
            }
        }
        while (temp1!=null){
            insertNode(node, temp1.value);
            temp1 = temp1.next;
        }
        while (temp2!=null){
            insertNode(node, temp2.value);
            temp2 = temp2.next;
        }
        return node;
    }
    public static Node insertNode(Node head, int value){
        Node newNode = new Node(value);
        Node temp = head;
        while (temp.next!=null) temp = temp.next;
        temp.next = newNode;
        return newNode;
    }

    public static void print(Node node){
        while (node!=null){
            if (node.next != null)
                System.out.print(node.value + " -> ");
            else System.out.print(node.value);
            node = node.next;
        }
    }

    //    单链表节点
    public static class Node{
        public int value;
        public Node next;

        public Node(){

        }

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

}