从0开始的算法（数据结构和算法）基础（三）

Solidao

于 2024-07-29 10:46:11 发布

阅读量943

点赞数 19

文章标签：算法数据结构

本文链接：https://blog.csdn.net/Solidao/article/details/140762032

版权

数据结构的分类——线性和非线性

逻辑关系

线性关系就是有顺序关系，最开始学的数组就是。
非线性关系就是节点之间联系，关系之间的顺序性没有那么强。最开始学代码的时候学递归的时候画的那个图。

public class Combination {

    // 递归方法计算组合数
    public static int recursiveCombination(int n, int k) {
        // 边界条件
        if (k == 0 || k == n) {
            return 1;
        }
        // 递归公式 C(n, k) = C(n-1, k-1) + C(n-1, k)
        return recursiveCombination(n - 1, k - 1) + recursiveCombination(n - 1, k);
    }

    public static void main(String[] args) {
        int n = 5;
        int k = 0;

        int result = recursiveCombination(n, k);
        System.out.println("递归方法：C(" + n + "," + k + ") = " + result);
    }
}

在这里插入图片描述
高中学的生物的遗传图图谱也是非线性的。

物理结构——连续和分散

连续就是一片连续的空间，分散就是将内存分散来存储，两个在时间和空间上面有区别，一个通过连续的方式减少了在检索花费的时间，如数组一类的，索引本质上是内存地址的偏移量。首个元素的地址偏移量是 0
，因此它的索引为 0是合理的。在数组中访问元素非常高效，我们可以在 O(1) 时间内随机访问数组中的任意一个元素。
在这里插入图片描述
学习了C语言会知道(int*) malloc(n * sizeof(int))，我们寻址的时候只要加一个size就可以了，当然操作不当就会烫烫烫烫。学习过计算机组成原理的会知道运行程序寻找数据最重要一个寻址，学习了操作系统就会知道为了提高我们的效率，段页式存储也是和地址相关，储存管理中的内存映射文件高效利用小存储就是离散的，节省了空间，就会增加时间。链表就是这样。
在这里插入图片描述

链表

链表（Linked List）是一种常见的数据结构，它由一系列节点（Node）组成，每个节点包含数据部分和指向下一个节点的引用（指针）。链表可以分为单向链表、双向链表和循环链表等类型。

这些链表的实现只是基础功能，现实应用中可能需要更多的操作和优化。包括插入节点、删除节点、查找节点操作。

单向链表（Singly Linked List）

// 单向链表节点类
class SinglyNode {
    int data;
    SinglyNode next;

    SinglyNode(int data) {
        this.data = data;
        this.next = null;
    }
}

// 单向链表类
class SinglyLinkedList {
    SinglyNode head;

    // 在链表末尾添加一个新节点
    public void append(int data) {
        if (head == null) {
            head = new SinglyNode(data);
            return;
        }
        SinglyNode current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = new SinglyNode(data);
    }

    // 在链表头部插入一个新节点
    public void prepend(int data) {
        SinglyNode newHead = new SinglyNode(data);
        newHead.next = head;
        head = newHead;
    }

    // 删除链表中第一个值为data的节点
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data) {
            head = head.next;
            return;
        }
        SinglyNode current = head;
        while (current.next != null) {
            if (current.next.data == data) {
                current.next = current.next.next;
                return;
            }
            current = current.next;
        }
    }

    // 查找节点
    public boolean contains(int data) {
        SinglyNode current = head;
        while (current != null) {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    // 打印链表中的所有节点
    public void printList() {
        SinglyNode current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

增（Insert）
在链表末尾添加一个新节点
检查链表是否为空。
如果为空，创建新节点并将其设为头节点。
如果不为空，遍历链表到达末尾，将新节点添加到末尾。
在链表头部插入一个新节点
创建新节点。
将新节点的下一个引用指向当前头节点。
将新节点设为头节点。
删（Delete）
删除链表中第一个值为data的节点
检查链表是否为空。
如果头节点是目标节点，将头节点指向下一个节点。
遍历链表找到目标节点的前一个节点，将前一个节点的next引用指向目标节点的下一个节点。
改（Update）
单向链表的节点数据是不可变的，因此通常不需要更新操作。如果需要，可以通过删除旧节点并插入新节点来实现。
查（Retrieve）
查找节点
从头节点开始遍历链表。
如果找到目标数据，返回true。
如果遍历完整个链表未找到目标数据，返回false。

双向链表（Doubly Linked List）

// 双向链表节点类
class DoublyNode {
    int data;
    DoublyNode next;
    DoublyNode prev;

    DoublyNode(int data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

// 双向链表类
class DoublyLinkedList {
    DoublyNode head;

    // 在链表末尾添加一个新节点
    public void append(int data) {
        if (head == null) {
            head = new DoublyNode(data);
            return;
        }
        DoublyNode current = head;
        while (current.next != null) {
            current = current.next;
        }
        DoublyNode newNode = new DoublyNode(data);
        current.next = newNode;
        newNode.prev = current;
    }

    // 在链表头部插入一个新节点
    public void prepend(int data) {
        DoublyNode newHead = new DoublyNode(data);
        newHead.next = head;
        if (head != null) {
            head.prev = newHead;
        }
        head = newHead;
    }

    // 删除链表中第一个值为data的节点
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data) {
            head = head.next;
            if (head != null) {
                head.prev = null;
            }
            return;
        }
        DoublyNode current = head;
        while (current != null) {
            if (current.data == data) {
                if (current.next != null) {
                    current.next.prev = current.prev;
                }
                if (current.prev != null) {
                    current.prev.next = current.next;
                }
                return;
            }
            current = current.next;
        }
    }

    // 查找节点
    public boolean contains(int data) {
        DoublyNode current = head;
        while (current != null) {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    // 打印链表中的所有节点
    public void printList() {
        DoublyNode current = head;
        while (current != null) {
            System.out.print(current.data + " <-> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

增（Insert）
在链表末尾添加一个新节点
检查链表是否为空。
如果为空，创建新节点并将其设为头节点。
如果不为空，遍历链表到达末尾，将新节点添加到末尾，并设置新节点的prev引用。
在链表头部插入一个新节点创建新节点。
将新节点的下一个引用指向当前头节点。
如果头节点不为空，将头节点的prev引用指向新节点。
将新节点设为头节点。
删（Delete）
删除链表中第一个值为data的节点
检查链表是否为空。
如果头节点是目标节点，将头节点指向下一个节点，并将新头节点的prev引用设为null。
遍历链表找到目标节点，将目标节点前后的节点相连。
改（Update）
类似于单向链表，通过删除旧节点并插入新节点来实现更新操作。
查（Retrieve）
查找节点
从头节点开始遍历链表。
如果找到目标数据，返回true。
如果遍历完整个链表未找到目标数据，返回false。

单向循环链表（Singly Circular Linked List）

// 单向循环链表节点类
class SinglyCircularNode {
    int data;
    SinglyCircularNode next;

    SinglyCircularNode(int data) {
        this.data = data;
        this.next = null;
    }
}

// 单向循环链表类
class SinglyCircularLinkedList {
    SinglyCircularNode head;

    // 在链表末尾添加一个新节点
    public void append(int data) {
        if (head == null) {
            head = new SinglyCircularNode(data);
            head.next = head;
            return;
        }
        SinglyCircularNode current = head;
        while (current.next != head) {
            current = current.next;
        }
        SinglyCircularNode newNode = new SinglyCircularNode(data);
        current.next = newNode;
        newNode.next = head;
    }

    // 在链表头部插入一个新节点
    public void prepend(int data) {
        SinglyCircularNode newHead = new SinglyCircularNode(data);
        if (head == null) {
            head = newHead;
            head.next = head;
            return;
        }
        SinglyCircularNode current = head;
        while (current.next != head) {
            current = current.next;
        }
        current.next = newHead;
        newHead.next = head;
        head = newHead;
    }

    // 删除链表中第一个值为data的节点
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data && head.next == head) {
            head = null;
            return;
        }
        if (head.data == data) {
            SinglyCircularNode current = head;
            while (current.next != head) {
                current = current.next;
            }
            current.next = head.next;
            head = head.next;
            return;
        }
        SinglyCircularNode current = head;
        while (current.next != head) {
            if (current.next.data == data) {
                current.next = current.next.next;
                return;
            }
            current = current.next;
        }
    }

    // 查找节点
    public boolean contains(int data) {
        if (head == null) return false;
        SinglyCircularNode current = head;
        do {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        } while (current != head);
        return false;
    }

    // 打印链表中的所有节点
    public void printList() {
        if (head == null) return;
        SinglyCircularNode current = head;
        do {
            System.out.print(current.data + " -> ");
            current = current.next;
        } while (current != head);
        System.out.println("(head)");
    }
}

双向循环链表（Doubly Circular Linked List）

// 双向循环链表节点类
class DoublyCircularNode {
    int data;
    DoublyCircularNode next;
    DoublyCircularNode prev;

    DoublyCircularNode(int data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

// 双向循环链表类
class DoublyCircularLinkedList {
    DoublyCircularNode head;

    // 在链表末尾添加一个新节点
    public void append(int data) {
        if (head == null) {
            head = new DoublyCircularNode(data);
            head.next = head;
            head.prev = head;
            return;
        }
        DoublyCircularNode current = head;
        while (current.next != head) {
            current = current.next;
        }
        DoublyCircularNode newNode = new DoublyCircularNode(data);
        newNode.next = head;
        head.prev = newNode;
        newNode.prev = current;
        current.next = newNode;
    }

    // 在链表头部插入一个新节点
    public void prepend(int data) {
        DoublyCircularNode newHead = new DoublyCircularNode(data);
        if (head == null) {
            head = newHead;
            head.next = head;
            head.prev = head;
            return;
        }
        DoublyCircularNode current = head;
        while (current.next != head) {
            current = current.next;
        }
        current.next = newHead;
        newHead.prev = current;
        newHead.next = head;
        head.prev = newHead;
        head = newHead;
    }

    // 删除链表中第一个值为data的节点
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data && head.next == head) {
            head = null;
            return;
        }
        if (head.data == data) {
            DoublyCircularNode current = head;
            while (current.next != head) {
                current = current.next;
            }
            current.next = head.next;
            head.next.prev = current;
            head = head.next;
            return;
        }
        DoublyCircularNode current = head;
        while (current.next != head) {
            if (current.next.data == data) {
                current.next.next.prev = current;
                current.next = current.next.next;
                return;
            }
            current = current.next;
        }
    }

    // 查找节点
    public boolean contains(int data) {
        if (head == null) return false;
        DoublyCircularNode current = head;
        do {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        } while (current != head);
        return false;
    }

    // 打印链表中的所有节点
    public void printList() {
        if (head == null) return;
        DoublyCircularNode current = head;
        do {
            System.out.print(current.data + " <-> ");
            current = current.next;
        } while (current != head);
        System.out.println("(head)");
    }
}

测试代码

public class Main {
    public static void main(String[] args) {
        // 测试单向链表
        System.out.println("测试单向链表:");
        SinglyLinkedList singlyList = new SinglyLinkedList();
        singlyList.append(1);
        singlyList.append(2);
        singlyList.append(3);
        singlyList.prepend(0);
        singlyList.printList(); // 输出: 0 -> 1 -> 2 -> 3 -> null
        singlyList.delete(2);
        singlyList.printList(); // 输出: 0 -> 1 -> 3 -> null
        System.out.println("Contains 3: " + singlyList.contains(3)); // 输出: true

        // 测试双向链表
        System.out.println("\n测试双向链表:");
        DoublyLinkedList doublyList = new DoublyLinkedList();
        doublyList.append(1);
        doublyList.append(2);
        doublyList.append(3);
        doublyList.prepend(0);
        doublyList.printList(); // 输出: 0 <-> 1 <-> 2 <-> 3 <-> null
        doublyList.delete(2);
        doublyList.printList(); // 输出: 0 <-> 1 <-> 3 <-> null
        System.out.println("Contains 3: " + doublyList.contains(3)); // 输出: true

        // 测试单向循环链表
        System.out.println("\n测试单向循环链表:");
        SinglyCircularLinkedList singlyCircularList = new SinglyCircularLinkedList();
        singlyCircularList.append(1);
        singlyCircularList.append(2);
        singlyCircularList.append(3);
        singlyCircularList.prepend(0);
        singlyCircularList.printList(); // 输出: 0 -> 1 -> 2 -> 3 -> (head)
        singlyCircularList.delete(2);
        singlyCircularList.printList(); // 输出: 0 -> 1 -> 3 -> (head)
        System.out.println("Contains 3: " + singlyCircularList.contains(3)); // 输出: true

        // 测试双向循环链表
        System.out.println("\n测试双向循环链表:");
        DoublyCircularLinkedList doublyCircularList = new DoublyCircularLinkedList();
        doublyCircularList.append(1);
        doublyCircularList.append(2);
        doublyCircularList.append(3);
        doublyCircularList.prepend(0);
        doublyCircularList.printList(); // 输出: 0 <-> 1 <-> 2 <-> 3 <-> (head)
        doublyCircularList.delete(2);
        doublyCircularList.printList(); // 输出: 0 <-> 1 <-> 3 <-> (head)
        System.out.println("Contains 3: " + doublyCircularList.contains(3)); // 输出: true
    }
}

循环的就是成环形的没有太大区别就不做赘述了，我们进一步完善了链表的操作，包括插入、删除和查找节点的功能，并为每种类型的链表提供了相应的测试代码。这样，你就可以更加全面地了解各种链表的数据结构及其操作方法。
链表作为一种基础的数据结构，在实际应用中有着广泛的使用场景。以下是一些链表在实际应用中的具体用途：

动态内存分配:链表常用于操作系统的动态内存分配管理，如实现内存池、垃圾回收机制等。
实现栈和队列:链表可以用来实现栈（Stack）和队列（Queue），这两种数据结构在编程中非常常见。
文件系统：在文件系统中，链表用于管理文件分配表（FAT），帮助跟踪磁盘上的文件存储位置。
浏览器历史记录想：浏览器使用链表来管理用户的历史记录，实现前进和后退功能。
LRU缓存淘汰算法：在缓存系统中，链表结合哈希表可以实现LRU（Least Recently Used）缓存淘汰算法。
图和树的表示：链表可以用来表示图的邻接表和树的节点，特别是在稀疏图的情况下，链表比矩阵更节省空间。
链式结构数据库：某些数据库系统使用链表来管理数据记录，特别是在需要频繁插入和删除操作的场景中。
音乐播放列表：音乐播放器中的播放列表通常使用链表来实现，以便于动态添加、删除和顺序播放歌曲。
编辑器中的撤销/重做功能：文本编辑器和图形编辑器中的撤销/重做功能通常使用链表来存储操作历史。
动态数组：链表可以作为动态数组（如Java中的ArrayList）的底层实现，支持高效的插入和删除操作。
内存管理：在某些内存管理策略中，链表用于跟踪可用内存块和已分配内存块。
      链表的灵活性和动态性使其在需要频繁插入和删除操作的场景中非常有用。然而，链表的缺点是访问元素的时间复杂度为O(n)，因此在需要频繁随机访问元素的场景中，数组或其他数据结构可能更为合适。
      内存管理是一个好的习惯，保证分配空间临时要回收，虽然储存现在比较便宜，很多的软件并不注意，导致缓存垃圾太大了，这种东西越大，发生问题的可能性就越大。
      持续更新中~~

Solidao

关注

19
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
从0开始的算法（数据结构和算法）基础（三）

循环的就是成环形的没有太大区别就不做赘述了，我们进一步完善了链表的操作，包括插入、删除和查找节点的功能，并为每种类型的链表提供了相应的测试代码。连续就是一片连续的空间，分散就是将内存分散来存储，两个在时间和空间上面有区别，一个通过连续的方式减少了在检索花费的时间，如数组一类的，索引本质上是内存地址的偏移量。内存管理是一个好的习惯，保证分配空间临时要回收，虽然储存现在比较便宜，很多的软件并不注意，导致缓存垃圾太大了，这种东西越大，发生问题的可能性就越大。单向链表的节点数据是不可变的，因此通常不需要更新操作。
复制链接

扫一扫