一文读懂 Java 数据结构与算法：从菜鸟到大神的蜕变-优快云博客

嘿，各位 Java 小能手们！今天咱们要来聊聊 Java 编程世界里的两大 “扛把子”—— 数据结构和算法。这俩家伙，就像是游戏里的超级武器，掌握好了，写代码那叫一个顺风顺水，要是没搞懂，就只能在代码的迷宫里瞎转悠啦！

啥是数据结构？

数据结构，简单来说，就是数据的 “收纳整理术”。你想想，你房间里的东西是不是得分类放好，找起来才方便？数据结构就是干这个的，把数据按照特定的方式组织起来，方便我们存储、查找和使用。

数组：最基础的 “收纳盒”

数组就像是一排整齐的小抽屉，每个抽屉都有编号（索引），你可以直接根据编号快速找到里面的东西。在 Java 里创建一个数组就像这样：

int[] numbers = new int[5];

这就创建了一个能装 5 个整数的数组。你可以这样给抽屉里放东西：

numbers[0] = 10;
numbers[1] = 20;

然后像这样取出来：

int firstNumber = numbers[0];

数组的优点是访问速度超快，就像你知道抽屉编号，一下子就能打开拿到东西。但缺点也很明显，大小固定，要是东西装多了，就装不下啦！

链表：灵活的 “糖葫芦串”

链表就像一串糖葫芦，每个山楂（节点）都连着下一个山楂。在 Java 里，一个链表节点可以这样定义：

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

链表的好处是非常灵活，你可以随时在任何位置添加或删除山楂（节点）。比如你想在链表开头加个节点：

ListNode newNode = new ListNode(5);
newNode.next = head;
head = newNode;

不过，链表的查找就比较麻烦了，你得像吃糖葫芦一样，一个一个顺着找，不像数组能直接跳着找。

栈：“后进先出” 的神奇箱子

栈就像一个只有一个开口的箱子，你放进去的东西，最后放进去的那个会最先拿出来，就像你往箱子里叠盘子，最后放的那个在最上面，先被拿走。在 Java 里，我们可以用Stack类来操作栈：

Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
int topElement = stack.pop();

栈在很多场景都很有用，比如计算表达式的时候，它能帮你理清计算顺序。

队列：“先进先出” 的排队队伍

队列就像排队买奶茶，先来的人先买到。在 Java 里，我们可以用Queue接口来实现队列，常用的是LinkedList类，因为它实现了Queue接口。

Queue<Integer> queue = new LinkedList<>();
queue.add(1);
queue.add(2);
int firstInQueue = queue.poll();

队列在处理需要按顺序处理的任务时非常有用，比如任务调度。

算法又是什么鬼？

算法就是解决问题的 “套路”，是一系列清晰的指令，告诉计算机怎么把输入数据变成我们想要的输出。

排序算法：给数据 “排排站”

排序算法就是把一堆乱序的数据按照一定顺序排好。

冒泡排序：两个两个比，小的往前冒

冒泡排序就像一群人站成一排，相邻的两个人依次比较身高，矮的往前站。每一轮比较完，最大的那个人就像泡泡一样 “浮” 到了最后面。

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

冒泡排序简单易懂，但效率不高，就像你让一群人慢慢挪位置，得花不少时间。

快速排序：选个 “基准”，两边分开排

快速排序就像老师把班上同学按成绩分成两组，一组比某个同学（基准）成绩好，一组比他差，然后再分别对这两组进行同样的操作，直到每个小组都排好序。

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
private static int partition(int[] arr, int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}

快速排序效率高很多，就像老师分小组一样，一下子就能把问题简化不少。

搜索算法：在数据堆里找 “宝藏”

搜索算法就是在一堆数据里找到你想要的那个。

顺序搜索：一个一个翻找

顺序搜索就像你在书架上找一本书，一本一本地翻，直到找到为止。

public static int sequentialSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

顺序搜索简单直接，但要是书架很大，找起来就很慢了。

二分搜索：折半查找，效率翻倍

二分搜索就像你知道书在书架的某一层，然后你先从中间开始找，如果不是你要的，就根据书的位置，确定是在左边一半还是右边一半继续找，每次都把查找范围缩小一半。

public static int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

二分搜索效率高多了，前提是数据得是有序的，就像书架上的书得按顺序排好，你才能这么高效地找。