【Java算法(一)】Java冒泡排序、二分查找和二叉树遍历（前序、中序和后序）,亲测有效

代码无疆

于 2024-04-30 10:05:28 发布

阅读量1.1k

点赞数 3

分类专栏： Java百宝箱文章标签：算法 java 排序算法

本文链接：https://blog.csdn.net/PythonAigc/article/details/138336633

版权

Java百宝箱专栏收录该内容

180 篇文章 4 订阅

订阅专栏

当冒泡排序

public class BubbleSort {
    
    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]) {
                    // 交换 arr[j] 和 arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("排序后的数组:");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

在上面的代码中，bubbleSort 方法接收一个整数数组 arr 并对其进行排序。它使用两个嵌套的 for 循环，外层循环控制排序的轮数，内层循环用于比较相邻的元素并进行交换（如果需要的话）。如果 arr[j] 大于 arr[j + 1]，则交换这两个元素的位置。

在 main 方法中，我们创建了一个待排序的整数数组 arr，并调用 bubbleSort 方法对其进行排序。最后，我们遍历排序后的数组并打印出来。

二分查找

public class BinarySearch {

    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int 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;
            }
        }

        // 没有找到目标，返回-1
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 10, 40};
        int target = 10;
        int result = binarySearch(arr, target);

        if (result == -1) {
            System.out.println("元素未找到");
        } else {
            System.out.println("元素找到，索引为：" + result);
        }
    }
}

在这个示例中，binarySearch 方法接收一个整数数组 arr 和一个目标值 target。它使用 left 和 right 变量来追踪当前搜索的数组范围。在每次迭代中，它计算中间索引 mid，并检查 arr[mid] 是否等于 target。如果相等，则返回 mid。如果 arr[mid] 小于 target，则更新 left 为 mid + 1，因为目标值必定在 mid 的右侧。如果 arr[mid] 大于 target，则更新 right 为 mid - 1，因为目标值必定在 mid 的左侧。

在 main 方法中，我们创建了一个已排序的整数数组 arr，并调用 binarySearch 方法来查找目标值 target。最后，我们打印出查找结果。如果目标值在数组中，则打印出索引；否则，打印出“元素未找到”。

二叉树前序遍历

首先，我们需要定义一个二叉树节点的类（TreeNode），然后实现前序遍历（preOrderTraversal）的方法。

// 定义二叉树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    
    TreeNode(int x) {
        val = x;
    }
}

// 实现前序遍历的类
public class BinaryTreePreOrderTraversal {

    // 前序遍历（根-左-右）
    public List<Integer> preOrderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        preOrderHelper(root, result);
        return result;
    }

    // 前序遍历的辅助方法（递归）
    private void preOrderHelper(TreeNode node, List<Integer> result) {
        if (node == null) {
            return;
        }
        // 访问根节点
        result.add(node.val);
        // 遍历左子树
        preOrderHelper(node.left, result);
        // 遍历右子树
        preOrderHelper(node.right, result);
    }

    // 主方法，用于测试
    public static void main(String[] args) {
        // 创建测试二叉树
        TreeNode root = new TreeNode(1);
        root.right = new TreeNode(2);
        root.right.left = new TreeNode(3);

        BinaryTreePreOrderTraversal traversal = new BinaryTreePreOrderTraversal();
        List<Integer> result = traversal.preOrderTraversal(root);

        // 打印遍历结果
        for (int val : result) {
            System.out.print(val + " ");
        }
    }
}

在上面的代码中，我们首先定义了一个TreeNode类来表示二叉树的节点。BinaryTreePreOrderTraversal类中的preOrderTraversal方法是前序遍历的入口，它接受一个根节点并返回一个包含前序遍历结果的整数列表。preOrderHelper是一个私有辅助方法，它使用递归实现前序遍历的逻辑。在main方法中，我们创建了一个简单的二叉树并调用preOrderTraversal方法来测试前序遍历的实现。

Java实现二叉树中序遍历（左-根-右）

// 定义二叉树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    
    TreeNode(int x) {
        val = x;
    }
}

// 实现中序遍历的类
public class BinaryTreeInorderTraversal {

    // 中序遍历（左-根-右）
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        inorderHelper(root, result);
        return result;
    }

    // 中序遍历的辅助方法（递归）
    private void inorderHelper(TreeNode node, List<Integer> result) {
        if (node == null) {
            return;
        }
        // 遍历左子树
        inorderHelper(node.left, result);
        // 访问根节点
        result.add(node.val);
        // 遍历右子树
        inorderHelper(node.right, result);
    }

    // 主方法，用于测试
    public static void main(String[] args) {
        // 创建测试二叉树
        TreeNode root = new TreeNode(1);
        root.right = new TreeNode(2);
        root.right.left = new TreeNode(3);

        // 注意：上面的树结构没有左子树，为了测试中序遍历，我们可以添加一个左子树
        root.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        BinaryTreeInorderTraversal traversal = new BinaryTreeInorderTraversal();
        List<Integer> result = traversal.inorderTraversal(root);

        // 打印遍历结果
        for (int val : result) {
            System.out.print(val + " ");
        }
    }
}

在这个例子中，我们定义了一个TreeNode类来表示二叉树的节点，并在BinaryTreeInorderTraversal类中实现了中序遍历。inorderTraversal方法接受一个根节点并返回一个包含中序遍历结果的整数列表。inorderHelper是一个私有辅助方法，它使用递归来实现中序遍历的逻辑。在main方法中，我们创建了一个测试用的二叉树，并调用了inorderTraversal方法来测试中序遍历的实现。最后，我们遍历结果列表并打印出每个节点的值。

二叉树后序遍历（左-右-根）

// 定义二叉树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

// 实现后序遍历的类
public class BinaryTreePostorderTraversal {

    // 后序遍历（左-右-根）
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        postorderHelper(root, result);
        return result;
    }

    // 后序遍历的辅助方法（递归）
    private void postorderHelper(TreeNode node, List<Integer> result) {
        if (node == null) {
            return;
        }
        // 遍历左子树
        postorderHelper(node.left, result);
        // 遍历右子树
        postorderHelper(node.right, result);
        // 访问根节点
        result.add(node.val);
    }

    // 主方法，用于测试
    public static void main(String[] args) {
        // 创建测试二叉树
        TreeNode root = new TreeNode(1);
        root.right = new TreeNode(2);
        root.right.left = new TreeNode(3);

        // 为了测试后序遍历，我们添加一个左子树
        root.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        BinaryTreePostorderTraversal traversal = new BinaryTreePostorderTraversal();
        List<Integer> result = traversal.postorderTraversal(root);

        // 打印遍历结果
        for (int val : result) {
            System.out.print(val + " ");
        }
    }
}

在这个例子中，我们同样定义了一个TreeNode类来表示二叉树的节点，并在BinaryTreePostorderTraversal类中实现了后序遍历。postorderTraversal方法接受一个根节点并返回一个包含后序遍历结果的整数列表。postorderHelper是一个私有辅助方法，它使用递归来实现后序遍历的逻辑。在main方法中，我们创建了一个测试用的二叉树，并调用了postorderTraversal方法来测试后序遍历的实现。最后，我们遍历结果列表并打印出每个节点的值。