Rumah  >  Artikel  >  Java  >  Struktur data Java senarai pautan tunggal dan soalan OJ

Struktur data Java senarai pautan tunggal dan soalan OJ

WBOY
WBOYke hadapan
2022-11-24 17:38:022146semak imbas

Artikel ini membawa anda pengetahuan yang berkaitan tentang java terutamanya kandungan yang berkaitan tentang struktur data, termasuk senarai pautan tunggal dan soalan OJ. Saya harap ia akan membantu Semua orang adalah membantu.

Struktur data Java senarai pautan tunggal dan soalan OJ

Pembelajaran yang disyorkan: "tutorial video java"

Apakah itu senarai terpaut?

Senarai terpaut ialah struktur storan fizikal yang tidak berterusan Susunan logik elemen data dicapai melalui susunan pautan rujukan dalam senarai terpaut.

Ringkasnya, setiap elemen ialah nod, dan medan penunjuk digunakan untuk menyambungkan nod berikutnya Nod pertama tidak mempunyai pendahulu, dan nod terakhir tidak mempunyai pengganti.

Struktur senarai terpaut yang akan dilaksanakan dalam amalan sangat pelbagai Terdapat 8 jenis struktur senarai terpaut apabila digabungkan dengan situasi berikut:

1 . Sehala, dua hala 2. Mendahului, tidak mendahului 3. Kitaran, bukan kitaran

Kami fokus untuk menerangkan yang satu senarai terpaut asiklik dua hala dan senarai terpaut asiklik dua hala, dan kedua-duanya juga diuji dalam peperiksaan bertulis.

2. Laksanakan senarai terpaut akiklik sehala

2.1 Perjanjian sebelum pelaksanaan

Kerana setiap elemen yang dipautkan list ialah nod, jadi kami menggunakan pendekatan kelas dalaman, dan kami juga perlu mentakrifkan rujukan kepada nod kepala untuk sentiasa menunjuk ke nod kepala.

public class MySingleList {
    private ListNode head; //引用头节点
    // 链表每个元素是一个节点
    private class ListNode {
        private int val; //存放数据元素
        private ListNode next; //存放下一个节点地址
        //构造方法
        public ListNode(int val) {
            this.val = val;
        }
    }
}

Nota: Senarai terpaut mempunyai sekurang-kurangnya dua medan, iaitu medan data dan medan penunjuk Sudah tentu, anda juga boleh mempunyai berbilang medan data dan medan penunjuk.

Kami juga perlu melaksanakan kaedah biasa berikut:

public void addFirst(int data); //头插法

public void addLast(int data); //尾插法

public boolean addIndex(int index,int data); //任意位置插入,第一个数据节点为0号下标

public boolean contains(int key); //查找关键字key是否在单链表当中

public void remove(int key); //删除第一次出现关键字为key的节点

public void removeAllKey(int key); //删除所有值为key的节点

public int size(); //得到单链表的长度

public void clear(); //清空链表

2.2 kaedah addFirst

public void addFirst(int data) {
    ListNode newNode = new ListNode(data); //把传过来的值放到新的节点中
    newNode.next = this.head; //新节点的next指向头节点
    this.head = newNode; //使新节点成为头节点
}

Kerana kepala lalai Ia menunjuk ke null. Apabila senarai terpaut adalah batal, ia tidak menjejaskan pelaksanaan kod ini. Jika anda tidak percaya saya, datang dan lukis gambar.

2.3 kaedah addList

public void addLast(int data) {
    ListNode newNode = new ListNode(data);
    // 如果链表为空的情况
    if (this.head == null) {
        this.head = newNode;
        return;
    }
    // 先找到最后一个节点
    ListNode cur = this.head;
    while (cur.next != null) {
        cur = cur.next;
    }
    cur.next = newNode;
}

2.4 kaedah addIndex

//任意位置插入,第一个数据节点为0号下标
private ListNode findIndexPrevNode(int index) {
    ListNode cur = this.head;
    while (index - 1 != 0) {
        cur = cur.next;
        index--;
    }
    return cur;
}
public boolean addIndex(int index,int data) {
    // 判断index下标的有效性
    if (index < 0 || index > size()) {
        return false;
    }
    // 如果在0下标插入则是头插
    if (index == 0) {
        addFirst(data); //头插
        return true;
    }
    // 如果在末尾插入则是尾插
    if (index == size()) {
        addLast(data); //尾插
        return true;
    }

    ListNode newNode = new ListNode(data); //新节点
    // 在中间插入
    ListNode prevNode = findIndexPrevNode(index); //找到index下标的前一个节点
    newNode.next = prevNode.next; //新节点的next被改为index的位置的节点
    prevNode.next = newNode; //index位置前一个节点next被改成新节点
    return true;
}

Untuk kod ini kita perlu mencari terlebih dahulu indeks Untuk menyasarkan nod sebelumnya, mula-mula ikat nod baharu pada kedudukan indeks, dan kemudian sambungkan nod sebelumnya pada indeks ke nod baharu. Rakan boleh turun dan melukis gambar mengikut kepada kod saya Anda boleh memahaminya, atau anda boleh terus membaca lajur blogger sebelumnya mengenai pelaksanaan struktur data dalam bahasa C, yang mempunyai gambar rajah.

2.5 mengandungi kaedah

//查找关键字key是否在单链表当中
public boolean contains(int key) {
    // 当链表为空的情况
    if (this.head == null) {
        return false;
    }
    ListNode cur = this.head;
    // 遍历列表
    while (cur != null) {
        if (cur.val == key) {
            return true; //找到了返回true
        }
        cur = cur.next;
    }
    return false; //找不到返回false
}

Ideanya sangat mudah. ​​Lintas senarai terpaut dan cari kedudukan kosong cur Jika benar dikembalikan, jika salah tidak dikembalikan, serahkan kepada Xiao Turun dan lukis gambar itu sendiri.

Kaedah alih keluar 2.6

//删除第一次出现关键字为key的节点
public void remove(int key) {
    if (this.head == null) {
        return;
    }
    ListNode cur = this.head;

    // 如果删除的是key为头节点
    if (this.head.val == key) {
        this.head = head.next;
        return;
    }

    // 这里不能是cur!=null, 不然会越界!!!
    while (cur.next != null) {
        // 找到 key 的前一个节点
        if (cur.next.val == key) {
            //当前的cur为key的前一个节点
            cur.next = cur.next.next; //cur链接到key的后一个节点
            return;
        }
        cur = cur.next;
    }
}

Di sini kita perlu mencari nod kunci sebelumnya, dan kemudian mengikatnya pada nod di belakang kunci sepadan dengan nod Jika tiada sesiapa yang merujuknya, ia akan dikitar semula secara automatik.

2.7 kaedah removeAllKey

//删除所有值为key的节点
public void removeAllKey(int key) {
    if (this.head == null) {
        return;
    }
    // 采用前后指针的方法
    ListNode cur = this.head;
    ListNode prev = this.head;
    while (cur != null) {
        if (cur.val == key) {
            prev.next = cur.next; //跳过key节点指向下一个节点
        } else {
            prev = cur;
        }
        cur = cur.next;
    }
    // 判断第一个节点是不是key
    if (this.head.val == key) {
        this.head = this.head.next; //head指向下一个节点
    }
}

Mari kita lihat sendiri dahulu Soalan ini akan diterangkan secara terperinci kemudian apabila kami menerangkan soalan OJ.

Saiz 2.8 dan kaedah yang jelas

Saya percaya tidak perlu bercakap lebih lanjut mengenai kedua-dua kaedah ini, bukan? Melintasi? Tetapkan langsung penuding kepala kepada nol? Bukankah ini mudah? Saya tidak akan menulisnya di sini.

3. Anatomi mendalam bagi soalan OJ senarai pautan tunggal

Ini adalah kemuncak hari ini. Bukannya lelaki bola keranjang itu tidak melukis gambar kerana gambar sebelum ini terlalu mudah, kawan-kawan Kita juga boleh melukisnya sendiri dengan menggabungkan kod, tetapi untuk soalan OJ, anda masih perlu melukis gambar, saya percaya bahawa selepas membaca soalan-soalan ini, anda akan jatuh cinta dengan struktur data.

3.1 Alih keluar elemen senarai terpaut (Sumber: LeetCode Kesukaran: Mudah)

Soalan: Di sini anda pergi Nod kepala senarai terpaut head dan integer val, sila padamkan semua nod dalam senarai terpaut yang memenuhi Node.val == val dan kembalikan nod kepala baharu .

这个题我们可以用前后指针的思路来做,这样也比较通俗易懂,更适合初学者,大概的思路是这样的:我们可以定义一个cur和first的引用,如果碰到相等,也就是first.val == val,我们则让cur的next指向first的下一个节点,如果不相等,则让cur走到first的位置,最后first往后走一步,图解:

这里还没有完,如果第一个节点的值也是val呢?所以最后我们别忘了进行一个判断,那么最终的代码是这样的:

public ListNode removeElements(ListNode head, int val) {
    if (head == null) {
        return null;
    }
    ListNode cur = head;
    ListNode first = head;
    while (first != null) {
        if (first.val == val) {
            cur.next = first.next;
        } else {
            cur = first;
        }
        first = first.next;
    }
    // 判断头节点的值是否也是val
    if (head.val == val) {
        head = head.next;
    }
    return head;
}

3.2 反转链表(来源:LeetCode 难度:简单)

题目:给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。 

这个题我们可以先取到头节点,后续的节点都进行头插法即可?我们取到头节点,并且先将头节点的next置空,但是这样一来,就找不到后面的节点了,所以我们还需要有一个curNext引用来记录要反转节点的下一个节点:

我们的思路是这样的:首先找到头节点的next置空,cur走到curNext位置,curNext往前走,使得cur位置的next指向头节点,头节点cur再次成为新的头节点,当curNext走到null的时候循环结束。

public ListNode reverseList(ListNode head) {
    // 空链表的情况
    if (head == null) {
        return null;
    }
    ListNode cur = head;
    ListNode curNext = cur.next;
    head.next = null;
    while (curNext != null) {
        cur = curNext;
        curNext = curNext.next;
        cur.next = head;
        head = cur;
    }
    return head;
}

3.4 链表中倒数第k个节点

题目:输入一个链表,输出该链表中倒数第k个结点。 

这个题也是很简单的一道题,可以采用前后指针法,先让first指针走k步,走完之后slow和first一起走,这样slow和first之间就相差了k步,当first为null时,slow就是倒数第k个节点,在这个过程中,我们还要判断k的合法性,如果k小于等于0?或者k大于链表的长度呢?于是我们就能写出如下的代码:

public ListNode FindKthToTail(ListNode head,int k) {
    // 判断k的合法性
    if (k <= 0 || head == null) {
        return null;
    }
    ListNode first = head;
    ListNode slow = head;
    // 先让first走k步
    while (k != 0) {
        // k的长度大于链表的长度
        if (first == null) {
            return null;
        }
        first = first.next;
        k--;
    }
    // 一起走,当first为null,slow就是倒数第k个节点
    while (first != null) {
        first = first.next;
        slow = slow.next;
    }
    return slow;
}

3.6 链表分割(来源:牛客网 难度:较难) 

题目:现有一链表的头指针 ListNode* pHead,给一定值x,编写一段代码将所有小于x的结点排在其余结点之前,且不能改变原来的数据顺序,返回重新排列后的链表的头指针。 

这个题的思路我们可以这样做,既然是按照给定的值x进行分割,那么我们设定两个盘子,盘子A放小于x的节点,盘子B放大于x的节点,最后把这两个盘子的节点连起来,放回盘子A的头节点即可!

 public ListNode partition(ListNode pHead, int x) {
        if (pHead == null) {
            return null;
        }
        ListNode headA = null;
        ListNode headB = null;
        ListNode curA = null;
        ListNode curB = null;
        ListNode cur = pHead;
        while (cur != null) {
            if (cur.val < x) {
                // 第一次放入A盘子
                if (headA == null) {
                    headA = cur;
                    curA = cur;
                } else {
                    curA.next = cur;
                    curA = cur;
                }
            } else {
                // 第一次放入B盘子
                if (headB == null) {
                    headB = cur;
                    curB = cur;
                } else {
                    curB.next = cur;
                    curB = cur;
                }
            }
            cur = cur.next;
        }
        // 如果A盘子为空
        if (headA == null) {
            return headB;
        }
        curA.next = headB;
        // 避免B盘子尾节点形成环
        if (headB != null) {
            curB.next = null;
        }
        return headA;
    }

3.7 链表的回文结构(来源:LeetCode 难度:较难) 

题目:对于一个链表,请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法,判断其是否为回文结构。

给定一个链表的头指针A,请返回一个bool值,代表其是否为回文结构。保证链表长度小于等于900。

这个题有要求的,要求空间复杂度为O(1),并且还得在O(n)的时间复杂度下,那我们就原地解决这个题,我们可以分为三个步骤,首先找到中间节点,然后把中间节点往后的节点进行反转,最后左右两个指针同时往中间走。如果光看下面代码看不懂,可以结合着代码画图才能理解更透彻哦!

public boolean chkPalindrome(ListNode A) {
    if (A == null) {
        return false;
    }
    // 只有一个节点的情况
    if (A.next == null) {
        return true;
    }
    // 首先找到中间节点
    ListNode first = A;
    ListNode slow = A;
    while (first != null && first.next != null) {
        first = first.next.next;
        slow = slow.next;
    }
    // 走到这,slow是链表的中间节点,采用头插法反转slow后续的节点
    first = slow.next;
    ListNode cur = slow;
    while (first != null) {
        cur = first;
        first = first.next;
        cur.next = slow; //链接前一个节点
        slow = cur; //更新头节点的位置
    }
    // 走到这,反转完毕,cur指向最后一个节点,让slow等于A,往中间找
    slow = A;
    while (slow != cur) {
        if (slow.val != cur.val) {
            return false;
        }
        // 偶数的情况下需要特殊判断
        if (slow.next == cur) {
            return true;
        }
        slow = slow.next;
        cur = cur.next;
    }
    return true;
}

3.8 相交链表(来源:LeetCode 难度:简单) 

题目:给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null 。

题目数据 保证 整个链式结构中不存在环。

注意,函数返回结果后,链表必须 保持其原始结构 。

这个题我们可以这样做,长链表先走两个链表的长度差的步数,因为相交之后的节点都是一样的个数,所以走了差值后,就两个链表一起往后走,相等了则就是相交节点。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) {
        return null;
    }
    ListNode longList = headA; //longList始终记录长的链表
    ListNode shortList = headB;
    // 分别求出两个链表的长度
    int lenA = 0;
    int lenB = 0;
    ListNode cur = headA;
    while (cur != null) {
        lenA++;
        cur = cur.next;
    }
    cur = headB;
    while (cur != null) {
        lenB++;
        cur = cur.next;
    }
    int len = lenA - lenB;
    // 如果B链表长于A链表
    if (len < 0) {
        // 修正相差长度
        len = lenB - lenA;
        longList = headB; //longList始终记录长的链表
        shortList = headA;
    }
    // 让长链表先走差值len步,然后同步走,相等了即为相交节点
    while (len != 0) {
        longList = longList.next;
        len--;
    }
    while (longList != shortList) {
        longList = longList.next;
        shortList = shortList.next;
    }
    // 如果两个链表走到了null,则没有中间节点返回null,如果有,返回任意一个即可
    return longList;
}

推荐学习:《java视频教程

Atas ialah kandungan terperinci Struktur data Java senarai pautan tunggal dan soalan OJ. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Kenyataan:
Artikel ini dikembalikan pada:csdn.net. Jika ada pelanggaran, sila hubungi admin@php.cn Padam