Java数据结构和算法（四） 链表

最新推荐文章于 2024-10-09 17:48:02 发布
最新推荐文章于 2024-10-09 17:48:02 发布
阅读量104 收藏 1
点赞数
分类专栏： # Java 数据结构与算法 文章标签： 链表 单链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45847167/article/details/108365874
版权

链表(Linked List)介绍

链表是有序的列表，但是它在内存中是存储如下：
在这里插入图片描述

  1. 链表是以节点的方式来存储, 是链式存储
  2. 每个节点包含 data 域， next 域：指向下一个节点.
  3. 如图：发现 链表的各个节点不一定是连续存储.
  4. 链表分 带头节点的链表和 没有头节点的链表，根据实际的需求来确定

单向链表

单链表(带头结点) 逻辑结构示意图：
在这里插入图片描述

代码演示

package datastructure.linked;

/**
 * @author wsh
 * @date 2020-09-03 10:48
 */
public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 1、准备工作
        // 1.1 创建节点
        Node node1 = new Node(1, "第1个节点");
        Node node2 = new Node(2, "第2个节点");
        Node node3 = new Node(3, "第3个节点");
        Node node4 = new Node(4, "第4个节点");
        // 1.2 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 2、测试添加
        // 2.1 随意添加节点
        singleLinkedList.add(node1);
        singleLinkedList.add(node4);
        singleLinkedList.add(node3);
        singleLinkedList.add(node2);
        System.out.println("随意添加节点显示：");
        singleLinkedList.list();
        singleLinkedList.removeAll();

        // 2.2 顺序添加节点
        singleLinkedList.addByOrder(node1);
        singleLinkedList.addByOrder(node4);
        singleLinkedList.addByOrder(node3);
        singleLinkedList.addByOrder(node2);
        System.out.println("顺序添加节点显示：");
        singleLinkedList.list();
        // 3、测试修改
        singleLinkedList.update(new Node(3, "第三个节点~~"));
        System.out.println("修改链表节点后显示：");
        singleLinkedList.list();
        // 4、测试删除
        singleLinkedList.delete(2);
        System.out.println("删除链表一个节点后显示：");
        singleLinkedList.list();
        singleLinkedList.delete(1);
        singleLinkedList.delete(4);
        singleLinkedList.delete(3);
        System.out.println("陆续删除链表中所有节点后显示：");
        singleLinkedList.list();

    }
}

/**
 * 单向链表
 */
class SingleLinkedList {

    /**
     * 初始化头节点，不放数据，不能动
     */
    private Node head = new Node(0, "");

    /**
     * 添加节点
     *
     * @param node 要添加的节点
     */
    public void add(Node node) {
        // temp 表示最后一个节点
        Node temp = head;
        while (temp.next != null) {
            // 没有到链表最后，将temp后移，继续找
            temp = temp.next;
        }
        // 链表最后
        temp.next = node;
    }

    /**
     * 添加节点（根据id顺序添加）
     *
     * @param node 要添加的节点
     */
    public void addByOrder(Node node) {
        // temp 实际要代表我们要添加位置的前一个节点
        Node temp = head;
        // 需要添加的编号是否存在，默认不存在
        boolean flag = false;

        while (true) {
            if (temp.next == null) {
                // 链表最后
                break;
            }
            if (temp.next.id > node.id) {
                break;
            } else if (temp.next.id == node.id) {
                flag = true;
                break;
            }
            // 将temp后移，继续遍历
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("插入的节点 %d 已存在，不能添加！\n", node.id);
        } else {
            node.next = temp.next;
            temp.next = node;
        }
    }

    /**
     * 修改链表中的节点，注意，id不变，它是节点确定的标志
     * @param node 要修改的节点
     */
    public void update(Node node) {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空！");
            return;
        }
        // 辅助变量
        Node temp = head.next;
        boolean isExist = false;
        while (temp != null) {
            if (temp.id == node.id) {
                isExist = true;
                break;
            }
            temp = temp.next;
        }
        if (isExist) {
            temp.name = node.name;
        } else {
            System.out.printf("链表中不存在编号 %d 的节点\n", node.id);
        }
    }

    /**
     * 删除节点
     * @param id 要删除节点的ip
     */
    public void delete(int id) {
        Node temp = head;
        // 是否找到要删除的几点
        boolean flag = false;
        while (temp.next != null) {
            if (temp.next.id == id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", id);
        }
    }

    /**
     * 显示链表
     */
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Node temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    /**
     * 清空链表
     */
    public void removeAll() {
        head.next = null;
        System.out.println("-------清空链表---------");
    }

}

class Node {

    public int id;
    public String name;
    public Node next;

    public Node(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

测试结果：

随意添加节点显示：
Node{id=1, name='第1个节点'}
Node{id=4, name='第4个节点'}
Node{id=3, name='第3个节点'}
Node{id=2, name='第2个节点'}
-------清空链表---------
顺序添加节点显示：
Node{id=1, name='第1个节点'}
Node{id=2, name='第2个节点'}
Node{id=3, name='第3个节点'}
Node{id=4, name='第4个节点'}
修改链表节点后显示：
Node{id=1, name='第1个节点'}
Node{id=2, name='第2个节点'}
Node{id=3, name='第三个节点~~'}
Node{id=4, name='第4个节点'}
删除链表一个节点后显示：
Node{id=1, name='第1个节点'}
Node{id=3, name='第三个节点~~'}
Node{id=4, name='第4个节点'}
陆续删除链表中所有节点后显示：
链表为空

单链表面试题

1、求单链表中有效节点的个数

/**
 * 获取有效节点的个数
 *
 * @param head 头节点
 * @return 个数
 */
public static int getLength(Node head) {
    if (head.next == null) {
        return 0;
    }
    int length = 0;
    // temp 辅助几点，不计算头节点
    Node temp = head.next;
    while (temp != null) {
        length++;
        temp = temp.next;
    }
    return length;
}

2、查找单链表中的倒数第 k 个结点

/**
 * 查找单链表中的倒数第 k 个结点
 * @param head 头节点
 * @param index 倒第几个
 * @return 倒第 几个 节点
 */
public static Node findLastIndexNode(Node head, int index) {
    if (head.next == null) {
        return null;
    }
    // 1. 获取链表的总长度
    int size = getLength(head);
    // 校验合法性
    if (index <= 0 || index > size) {
        return null;
    }
    // 辅助变量，使用for循环，定位到倒第index个节点
    Node cur = head.next;
    for (int i = 0; i < size - index; i++) {
        cur = cur.next;
    }
    return cur;
}

3、单链表反转

/**
* 单链表反转
 */
public static Node reverse(Node head) {
    if (head.next == null) {
        return null;
    }
    Node cur = head.next;
    // next 指向当前节点的下一个节点
    Node next = null;
    // 遍历原来的链表，没遍历一个节点，就将其取出，放在新的链表 reverseHead 的最前端
    Node reverseHead = new Node(0, "");
    while (cur != null) {
        // 暂时存下当前节点的下一个节点
        next = cur.next;
        // 将cur的下一个节点指向新的链表的最前端
        cur.next = reverseHead.next;
        // 将当前的cur 连接到新的链表上
        reverseHead.next = cur;
        // 当前cur后移
        cur = next;
    }
    // 最终实现单链表的反转
    head.next = reverseHead.next;
    return head;
}

4、从尾到头打印单链表

/**
 * 从尾到头打印单链表，使用栈（Stack）先进后出
 */
public static void reversePrint(Node head) {
    if (head.next == null) {
        return;
    }
    // 创建一个栈
    Stack<Node> stack = new Stack<>();
    Node cur = head.next;
    // 将节点压入栈中
    while (cur != null) {
        stack.push(cur);
        cur = cur.next;
    }
    // 将栈中的节点进行出栈打印
    while (stack.size() > 0) {
        System.out.println(stack.pop());
    }
}

双向链表

和单向链表的对比：

  • 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
  • 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到 temp,temp 是待删除节点的前一个节点。

代码演示：

package datastructure.linked;

/**
 * @author wsh
 * @date 2020-09-03 10:48
 */
public class DoubleLinkedListDemo {

    public static void main(String[] args) {
        System.out.println("双向链表测试：");
        // 1、准备工作
        // 1.1 创建节点
        Node2 node1 = new Node2(1, "第1个节点");
        Node2 node2 = new Node2(2, "第2个节点");
        Node2 node3 = new Node2(3, "第3个节点");
        Node2 node4 = new Node2(4, "第4个节点");
        // 1.2 创建链表
        DoubleLinkedList linkedList = new DoubleLinkedList();
        // 2、测试添加
        linkedList.add(node1);
        linkedList.add(node4);
        linkedList.add(node3);
        linkedList.add(node2);
        System.out.println("添加节点显示：");
        linkedList.list();
        // 3、修改
        linkedList.update(new Node2(3, "修改节点3"));
        System.out.println("修改后的链表显示：");
        linkedList.list();
        // 4、删除
        linkedList.delete(2);
        System.out.println("删除后链表显示：");
        linkedList.list();
    }
}

/**
 * 单向链表
 */
class DoubleLinkedList {

    /**
     * 初始化头节点，不放数据，不能动
     */
    private Node2 head = new Node2(0, "");

    public Node2 getHead() {
        return head;
    }

    /**
     * 添加节点
     *
     * @param node 要添加的节点
     */
    public void add(Node2 node) {
        // temp 表示最后一个节点
        Node2 temp = head;
        while (temp.next != null) {
            // 没有到链表最后，将temp后移，继续找
            temp = temp.next;
        }
        // 链表最后
        temp.next = node;
        node.pre = temp;
    }

    /**
     * 修改链表中的节点，注意，id不变，它是节点确定的标志
     *
     * @param node 要修改的节点
     */
    public void update(Node2 node) {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空！");
            return;
        }
        // 辅助变量
        Node2 temp = head.next;
        boolean isExist = false;
        while (temp != null) {
            if (temp.id == node.id) {
                isExist = true;
                break;
            }
            temp = temp.next;
        }
        if (isExist) {
            temp.name = node.name;
        } else {
            System.out.printf("链表中不存在编号 %d 的节点\n", node.id);
        }
    }

    /**
     * 删除节点
     * 双向链表可以自我删除
     * @param id 要删除节点的ip
     */
    public void delete(int id) {
        Node2 temp = head.next;
        // 是否找到要删除的几点
        boolean flag = false;
        while (temp != null) {
            if (temp.id == id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            // 这里实现了自我删除
            temp.pre.next = temp.next;
            // 这里要判断下，不判断，如果temp是最后一个节点会出现空指针
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", id);
        }
    }

    /**
     * 显示链表
     */
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Node2 temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

class Node2 {

    public int id;
    public String name;
    public Node2 pre;
    public Node2 next;

    public Node2(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node2{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

测试结果:

双向链表测试：
添加节点显示：
Node2{id=1, name='第1个节点'}
Node2{id=4, name='第4个节点'}
Node2{id=3, name='第3个节点'}
Node2{id=2, name='第2个节点'}
修改后的链表显示：
Node2{id=1, name='第1个节点'}
Node2{id=4, name='第4个节点'}
Node2{id=3, name='修改节点3'}
Node2{id=2, name='第2个节点'}
删除后链表显示：
Node2{id=1, name='第1个节点'}
Node2{id=4, name='第4个节点'}
Node2{id=3, name='修改节点3'}

单向环形链表

Josephu(约瑟夫、约瑟夫环) 问题

Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

分析

用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

代码演示

package datastructure.linked;

/**
 * @author wsh
 * @date 2020/9/7 4:30 下午
 */
public class Josephu {

    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        // 圈中小孩总数
        int nums = 20;
        circleSingleLinkedList.add(nums);
        System.out.println("圈中所有小孩：");
        circleSingleLinkedList.showChild();
        // 从第几个小孩开始报数
        int startNo = 3;
        // 报几下数
        int countNum = 4;
        System.out.printf("圈中共有 %d 个小孩，从第 %d 个小孩开始报数，报 %d 下出圈\n", nums, startNo, countNum);
        circleSingleLinkedList.countChild(startNo, countNum, nums);
    }
}

class CircleSingleLinkedList {
    private Child first = null;

    /**
     * 构建环形链表
     *
     * @param nums 小孩数
     */
    public void add(int nums) {
        if (nums < 1) {
            System.out.println("nums的值不正确！");
            return;
        }
        Child cur = null;
        for (int i = 1; i <= nums; i++) {
            Child child = new Child(i);

            if (i == 1) {
                first = child;
                first.setNext(first);
                cur = first;
            } else {
                cur.setNext(child);
                child.setNext(first);
                cur = child;
            }
        }
    }

    /**
     * 显示环形链表
     */
    public void showChild() {
        if (first == null) {
            System.out.println("没有小孩");
            return;
        }
        Child curChild = first;
        while (true) {
            System.out.printf("小孩编号 %d \n", curChild.getId());
            if (curChild.getNext() == first) {
                break;
            }
            curChild = curChild.getNext();

        }

    }

    /**
     * 根据入参，计算小孩出圈的顺序
     *
     * @param startNo  从第几个小孩开始数数
     * @param countNum 数几下
     * @param nums     一共多少个小孩
     */
    public void countChild(int startNo, int countNum, int nums) {
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数错误");
            return;
        }
        Child helper = first;
        // 把辅助节点指向环形链表的最后一个节点
        while (helper.getNext() != first) {
            helper = helper.getNext();
        }
        // 小孩报数前，把first和helper 移动到第一个报数小孩上
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        // 圈中有两个或两个以上小孩
        // helper == first 表示圈中只有一个小孩
        while (helper != first) {
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            System.out.printf("小孩 %d 出圈\n", first.getId());
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号 %d\n", first.getId());
    }
}

/**
 * 小孩
 */
class Child {
    private int id;
    private Child next;

    public Child(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Child getNext() {
        return next;
    }

    public void setNext(Child next) {
        this.next = next;
    }
    
}

测试结果:

圈中所有小孩：
小孩编号 1 
小孩编号 2 
小孩编号 3 
小孩编号 4 
小孩编号 5 
小孩编号 6 
小孩编号 7 
小孩编号 8 
小孩编号 9 
小孩编号 10 
小孩编号 11 
小孩编号 12 
小孩编号 13 
小孩编号 14 
小孩编号 15 
小孩编号 16 
小孩编号 17 
小孩编号 18 
小孩编号 19 
小孩编号 20 
圈中共有 20 个小孩，从第 3 个小孩开始报数，报 4 下出圈
小孩 6 出圈
小孩 10 出圈
小孩 14 出圈
小孩 18 出圈
小孩 2 出圈
小孩 7 出圈
小孩 12 出圈
小孩 17 出圈
小孩 3 出圈
小孩 9 出圈
小孩 16 出圈
小孩 4 出圈
小孩 13 出圈
小孩 1 出圈
小孩 15 出圈
小孩 8 出圈
小孩 5 出圈
小孩 11 出圈
小孩 20 出圈
最后留在圈中的小孩编号 19
逆流者blog
关注
专栏目录
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
java数据结构和算法实践
03-18
以下是关于Java数据结构和算法的一些介绍: Java作为一种流行的编程语言,在数据结构和算法的实现方面有着广泛的应用。数据结构指的是在计算机中组织和存储数据的方式,算法则是明确定义的解决特定问题的规则和步骤。...
Java数据结构与算法——双向链表
★★光亭★★
03-11 6150
Java数据结构与算法——双向链表
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1420
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
Java数据结构与算法之链表插入操作
m0_43405302的博客
10-29 1898
一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构，关于Java链表的定义以及数据实例化，请查看数据结构之数组和链表（Java语言描述）。 二、插入元素操作 在介绍插入元素之前，我先对数据进行进行节点实例化。首先，我们建立n1、n2和n3的三个节点，其中n1的后继节点是n2，现在我们想把n3插入其中。这样我们有三种插入方式： class ListNode{ int val; //节点值 ListNode next; //后续节点使用 ListNode(int x){val=x;} } Li
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Java数据结构与算法——单向链表
★★光亭★★
03-11 5907
Java数据结构与算法——单向链表
Java数据结构与算法之链表删除操作
m0_43405302的博客
10-29 817
一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构，关于Java链表的定义以及数据实例化，请查看数据结构之数组和链表（Java语言描述）。 二、删除元素操作 在介绍删除元素之前，我先对数据进行进行节点实例化。首先，我们建立n1、n2和n3的三个节点，其中n1的后继节点是n2，n2的后继节点是n3。下面我将介绍删除元素的操作 class ListNode{ int val; //节点值 ListNode next; //后续节点使用 ListNode(int x){val=x;} } Lis
Java数据结构和算法学习笔记
zth13015409853的博客
01-05 1045
Java程序员必须要掌握的几种数据结构和算法
java数据结构-链表详解
m0_63526467的博客
05-04 4175
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
java数据结构与算法之单向链表以及三种插入方式
m0_72315083的博客
08-08 1282
我们在学习之前首先要知道链表是一个什么东西，那它是个啥呢，直接上图简单明了，看图来介绍。我们可以清楚的看到这个链有头有尾，最后面是NULL，最前面是头指针，学过C语言指针的同学可以看出java数据结构学习的链表与C语言中的极其相似。其实他们的道理也差不多。怎么构建链表呢，首先链表的主要元素有head头，data数据，next与下一个节点的链接部分。根据这些条件就可以轻松的构建出链表了。
Java数据结构和算法中文第二版_Java数据结构_
10-04
《Java数据结构和算法中文第二版》是一本深入探讨Java编程中数据结构和算法的书籍。数据结构是计算机科学的基础，它涉及到如何有效地组织和存储数据，以便在各种操作下高效地访问和修改。算法则是解决问题的具体步骤...
Java数据结构和算法.pdf
10-02
资源摘要信息是关于Java数据结构和算法的知识点总结，涵盖了数组、栈与队列、链表、递归、哈希表、高级排序、二叉树、红黑树、堆、带权图等数据结构和算法概念。 一、数组 * 数组是相同类型变量的集合，可以使用...
【Java数据结构与算法】双向链表
12-21
在计算机科学中，数据结构是组织、存储和处理数据的方式，而算法是解决问题或执行特定任务的步骤。本文主要讨论的是双向链表，这是一种重要的线性数据结构，它弥补了单向链表的一些缺点。 双向链表是一种链式存储...
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 539
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
查找与排序-插入排序
wlq_567的博客
10-02 584
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。是一种简单直观的排序算法，其基本思想是将未排序的元素逐个插入到已排序的部分中，直到所有元素都被插入到合适的位置为止。假设我们有以下待排序的数组：[5, 3, 8, 6, 2]最终，数组变为有序状态：[2, 3, 5, 6, 8]
Java：数据结构-ArrayList和顺序表（2）
最新发布
blamep的博客
10-09 389
创建一个空的ArrayList，指定容量为initialCapacity。
（JAVA）浅入数据结构 “堆” - 实现和理论
ZunXin_2580的博客
10-09 413
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
Java数据结构与算法实战指南
"Java数据结构和算法（英文版）" 本书《Java数据结构和算法》是学习数据结构和算法的重要参考资料，由Robert Lafore撰写。作者以其轻松易懂的写作风格，通过Java语言实例深入浅出地介绍了如何处理和操纵数据。这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值