初级查找算法

文章目录

  • 1. 顺序查找(Sequential Search):
  • 2. 二分查找(Binary Search):
  • 3. 哈希查找(Hashing):
    • 方案1 模拟hash底层
    • 方案2 hash算法章节:
  • 4. 广度优先搜索(Breadth-First Search,BFS):
  • 5. 深度优先搜索(Depth-First Search,DFS):
    • 方案1 递归实现:
    • 方案2 栈结构实现:

1. 顺序查找(Sequential Search):

顺序查找是一种简单直接的查找算法,逐个元素依次查找,直到找到目标元素或遍历完整个数据结构。

举例:假设有一个整数数组arr,我们要查找是否存在目标元素target。

public class SequentialSearch {
    public static boolean sequentialSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int target = 3;
        boolean result = sequentialSearch(arr, target);
        if (result) {
            System.out.println("目标元素存在");
        } else {
            System.out.println("目标元素不存在");
        }
    }
}

2. 二分查找(Binary Search):

二分查找是一种针对已排序的数据结构的查找算法,通过将目标元素与中间元素进行比较,不断缩小查找范围,直到找到目标元素或查找范围为空。

举例:假设有一个有序整数数组arr,我们要查找是否存在目标元素target。

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

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int target = 3;
        boolean result = binarySearch(arr, target);
        if (result) {
            System.out.println("目标元素存在");
        } else {
            System.out.println("目标元素不存在");
        }
    }
}

3. 哈希查找(Hashing):

哈希查找通过哈希函数将目标元素映射到数据结构中的位置,以快速定位目标元素。

方案1 模拟hash底层

示例:我们首先定义了一个HashNode类来表示哈希表中的节点,每个节点包含一个键和一个值。然后,我们定义了一个HashTable类来实现哈希表的功能。该类使用一个ArrayList来存储桶(每个桶是一个链表),并提供了插入和查找方法。

main方法中,我们创建了一个HashTable对象,并向其中插入了几个键值对。然后,我们使用get方法来查找指定键对应的值,并打印结果。

import java.util.ArrayList;
import java.util.LinkedList;

// 哈希表节点类
class HashNode<K, V> {
    K key;
    V value;

    public HashNode(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

// 哈希表类
class HashTable<K, V> {
    private int maxSize;
    private ArrayList<LinkedList<HashNode<K, V>>> buckets;

    public HashTable(int maxSize) {
        this.maxSize = maxSize;
        buckets = new ArrayList<>(maxSize);

        // 初始化桶
        for (int i = 0; i < maxSize; i++) {
            buckets.add(new LinkedList<>());
        }
    }

    // 哈希函数,计算键的哈希值
    private int getHash(K key) {
        return Math.abs(key.hashCode() % maxSize);
    }

    // 向哈希表中插入键值对
    public void insert(K key, V value) {
        int index = getHash(key);
        LinkedList<HashNode<K, V>> bucket = buckets.get(index);

        // 检查是否已存在相同的键,若存在则更新值
        for (HashNode<K, V> node : bucket) {
            if (node.key.equals(key)) {
                node.value = value;
                return;
            }
        }

        // 若不存在相同的键,则添加新节点
        bucket.add(new HashNode<>(key, value));
    }

    // 从哈希表中查找键对应的值
    public V get(K key) {
        int index = getHash(key);
        LinkedList<HashNode<K, V>> bucket = buckets.get(index);

        // 遍历桶中的节点,查找相应的键值对
        for (HashNode<K, V> node : bucket) {
            if (node.key.equals(key)) {
                return node.value;
            }
        }

        // 若未找到对应的键,则返回null
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建哈希表对象
        HashTable<String, Integer> hashTable = new HashTable<>(10);

        // 向哈希表中插入键值对
        hashTable.insert("apple", 5);
        hashTable.insert("banana", 7);
        hashTable.insert("orange", 3);

        // 查找键对应的值
        System.out.println("apple: " + hashTable.get("apple"));
        System.out.println("banana: " + hashTable.get("banana"));
        System.out.println("orange: " + hashTable.get("orange"));
        System.out.println("grape: " + hashTable.get("grape"));
    }
}

方案2 hash算法章节:

用数组简单模拟hash原理

4. 广度优先搜索(Breadth-First Search,BFS):

广度优先搜索是一种对于树或图等结构的查找算法,从根节点开始逐层遍历,直到找到目标元素。

代码实现了广度优先搜索(BFS)算法来查找二叉树中是否存在目标元素。以下是代码的要点:

1. 定义了一个TreeNode类,每个节点有一个整数值,以及左右子节点。
2. 定义了一个bfsSearch方法,接受一个根节点和目标元素作为参数,返回一个boolean值。该方法使用队列来实现广度优先搜索。
3. 在bfsSearch方法中,首先判断根节点是否为空,如果为空则返回false4. 创建一个队列,并将根节点加入队列。
5. 当队列非空时,循环执行以下步骤:
   - 弹出队列的第一个节点,并将其值与目标元素进行比较,如果相等则返回true- 如果节点的左子节点不为空,则将左子节点加入队列。
   - 如果节点的右子节点不为空,则将右子节点加入队列。
6. 如果循环结束后仍未找到目标元素,则返回false7. 在main方法中创建一个测试用的二叉树,并定义一个目标元素。
8. 调用bfsSearch方法,并根据返回值输出结果。如果返回true,则表示目标元素存在,否则表示目标元素不存在。

举例:假设有一棵二叉树,我们要查找是否存在目标元素target。

import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BFS {
    public static boolean bfsSearch(TreeNode root, int target) {
        if (root == null) {
            return false;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.val == target) {
                return true;
            }
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return false;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        int target = 3;
        boolean result = bfsSearch(root, target);
        if (result) {
            System.out.println("目标元素存在");
        } else {
            System.out.println("目标元素不存在");
        }
    }
}

5. 深度优先搜索(Depth-First Search,DFS):

深度优先搜索是一种对于树或图等结构的查找算法,从根节点开始一直遍历到叶子节点,直到找到目标元素或遍历完所有节点。

方案1 递归实现:

代码实现了一个深度优先搜索(DFS)算法来搜索给定二叉树中是否存在目标元素。下面是对代码的分析:

1. 定义了一个 `TreeNode` 类,表示二叉树的节点。该类包含一个整数值 `val`,以及左右子节点的引用。

2.`DFS` 类中定义了一个静态方法 `dfsSearch`,用于在给定的二叉树中搜索目标值。该方法的参数包括一个二叉树的根节点 `root` 和目标值 `target`3.`dfsSearch` 方法中,首先判断当前节点 `root` 是否为 `null`,如果是则返回 `false`,表示在该子树中不存在目标值。

4. 然后判断当前节点 `root` 的值是否等于目标值 `target`,如果是则返回 `true`,表示目标值存在于该子树中。

5. 如果当前节点不是目标值,则递归调用 `dfsSearch` 方法分别对左子节点和右子节点进行搜索,只要其中一棵子树返回 `true`,即可返回 `true`,表示目标值存在于该子树中。

6.`main` 方法中创建了一个二叉树,并调用 `dfsSearch` 方法来搜索目标值。如果搜索结果为 `true`,则输出 "目标元素存在",否则输出 "目标元素不存在"

举例:假设有一棵二叉树,我们要查找是否存在目标元素target。

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

public class DFS {
    public static boolean dfsSearch(TreeNode root, int target) {
        if (root == null) {
            return false;
        }

        if (root.val == target) {
            return true;
        }
        return dfsSearch(root.left, target) || dfsSearch(root.right, target);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        int target = 3;
        boolean result = dfsSearch(root, target);
        if (result) {
            System.out.println("目标元素存在");
        } else {
            System.out.println("目标元素不存在");
        }
    }
}

方案2 栈结构实现:

 - 我们使用一个栈来模拟DFS的过程。
 - 首先将根节点压入栈中,然后进入循环,直到栈为空。
 - 在每次循环中,我们弹出栈顶的节点并进行比较,如果找到目标元素,则返回true- 如果当前节点有右子节点,则将右子节点压入栈中。
 - 如果当前节点有左子节点,则将左子节点压入栈中。
 - 通过不断重复这个过程,直到栈为空或找到目标元素。
 - 如果循环结束仍然没有找到目标元素,则返回false
import java.util.Stack;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

public class DFS {
    public static boolean dfsSearch(TreeNode root, int target) {
        if (root == null) {
            return false;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();

            if (node.val == target) {
                return true;
            }

            if (node.right != null) {
                stack.push(node.right);
            }

            if (node.left != null) {
                stack.push(node.left);
            }
        }

        return false;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        int target = 3;
        boolean result = dfsSearch(root, target);
        if (result) {
            System.out.println("目标元素存在");
        } else {
            System.out.println("目标元素不存在");
        }
    }
}

你可能感兴趣的:(算法,算法,java,哈希算法)