系列文章目录

本系列文章主要面向马上要进行算法实习，就业，跳槽的友友们。
本系列文章暂时不会进行实例解析，只提供模板，目的是以最快的速度给这些友友们提供尽可能的帮助！

1、选择排序

public static void selectionSort(int[] arr) {
        if(arr == null || arr.length < 2) {
            return;
        }
        for(int i = 0; i < arr.length - 1; ++i) {
            int minIndex = i;
            for(int j = i + 1; j < arr.length; ++j) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

2、插入排序

public static void insertionSort(int[] arr) {
        if(arr == null || arr.length < 2) {
            return;
        }
        for(int i = 1; i < arr.length; ++i) {
            for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; --j) {
                swap(arr, j, j + 1);
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

3、冒泡排序

public static void bubbleSort(int[] arr) {
        if(arr == null || arr.length < 2) {
            return;
        }
        for(int e = arr.length - 1; e > 0; --e) {
            for(int i = 0; i < e; ++i) {
                if(arr[i] > arr[i + 1]){
                    swap(arr, i, i + 1);
                }
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

4、BFS

public class Edge {
        public int weight;
        public Node from;
        public Node to;

        public Edge(int weight, Node from, Node to) {
            this.weight = weight;
            this.from = from;
            this.to = to;
        }
    }

    // 点结构的描述
    public class Node {
        public int value;
        public int in;
        public int out;
        public ArrayList<Node> nexts;
        public ArrayList<Edge> edges;

        public Node(int value) {
            this.value = value;
            in = 0;
            out = 0;
            nexts = new ArrayList<>();
            edges = new ArrayList<>();
        }

        // 从node出发，进行宽度优先遍历
        public void bfs(Node start) {
            if (start == null) {
                return;
            }
            Queue<Node> queue = new LinkedList<>();
            HashSet<Node> set = new HashSet<>();
            queue.add(start);
            set.add(start);
            while (!queue.isEmpty()) {
                Node cur = queue.poll();
                System.out.println(cur.value);
                for (Node next : cur.nexts) {
                    if (!set.contains(next)) {
                        set.add(next);
                        queue.add(next);
                    }
                }
            }
        }
    }

5、DFS

public class Edge {
        public int weight;
        public Node from;
        public Node to;

        public Edge(int weight, Node from, Node to) {
            this.weight = weight;
            this.from = from;
            this.to = to;
        }
    }

    public class Node {
        public int value;
        public int in;
        public int out;
        public ArrayList<Node> nexts;
        public ArrayList<Edge> edges;

        public Node(int value) {
            this.value = value;
            in = 0;
            out = 0;
            nexts = new ArrayList<>();
            edges = new ArrayList<>();
        }

        public static void dfs(Node node) {
            if (node == null) {
                return;
            }
            Stack<Node> stack = new Stack<>();
            HashSet<Node> set = new HashSet<>();
            stack.add(node);
            set.add(node);
            System.out.println(node.value);
            while (!stack.isEmpty()) {
                Node cur = stack.pop();
                for (Node next : cur.nexts) {
                    if (!set.contains(next)) {
                        stack.push(cur);
                        stack.push(next);
                        set.add(next);
                        System.out.println(next.value);
                        break;
                    }
                }
            }
        }
    }