面试算法整理

1、使用3个线程循环打印ABC，打印10次

package org.article.controller;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 三个线程轮流打印123，输出10次
 * 
 * @Author: yangyang7
 * @Description:
 * @Date: Created in 14:30 2019-03-07
 */

@RestController
@RequestMapping("/api/test")
public class ThreadPrint {

    public static void main(final String[] args) {
        print123(10);
    }

    public static void print123(final Integer times) {
        if (times == null || times < 1) {
            return;
        }
        final Semaphore semaphore1 = new Semaphore(1);
        final Semaphore semaphore2 = new Semaphore(0);
        final Semaphore semaphore3 = new Semaphore(0);
        final AtomicInteger i = new AtomicInteger();
        final Thread thread1 = new Thread(() -> {
            while (true) {
                try {
                    if (i.intValue() == times) {
                        return;
                    }
                    semaphore1.acquire();
                    System.out.println(Thread.currentThread().getName() + "-1");
                    i.getAndIncrement();
                    semaphore2.release();
                } catch (final InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "thead1");
        final Thread thread2 = new Thread(() -> {
            while (true) {
                try {
                    semaphore2.acquire();
                    System.out.println(Thread.currentThread().getName() + "-2");
                    semaphore3.release();
                } catch (final InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "thead2");
        final Thread thread3 = new Thread(() -> {
            while (true) {
                try {
                    semaphore3.acquire();
                    System.out.println(Thread.currentThread().getName() + "-3");
                    semaphore1.release();
                } catch (final InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "thead3");
        thread1.start();
        thread2.start();
        thread3.start();
    }

}

2、将一个链表分段反转

package org.article.controller;

/**
 * 将一个链表分段反转
 * 
 * @Author: yangyang7
 * @Description:
 * @Date: Created in 14:30 2019-03-07
 */

public class LinkListSegmentReverse {

    public static void main(final String[] args) {

        // 单向链表
        final Node head = new Node(1);
        final Node node1 = new Node(2);
        final Node node2 = new Node(3);
        final Node node3 = new Node(4);
        final Node node4 = new Node(5);
        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;

        final Node node = reverseNode(4, head);
        if (node != null) {
            printNode(node);
        } else {
            System.out.println("null");
        }
    }

    private static Node reverseNode(final int i, Node node) {
        if (node == null || node.next == null) {
            return node;
        }
        int step = 0;
        Node stepNode;
        Node resultHead = null;
        Node tempNode = node;
        while (true) {
            stepNode = node.next;
            step++;
            if (stepNode != null) {
                if (step == i) {
                    node.next = null;
                    if (resultHead != null) {
                        final Node lastNode = getLastNode(resultHead);
                        lastNode.next = reverseSingleNode(tempNode);
                    } else {
                        resultHead = reverseSingleNode(tempNode);
                    }
                    step = 0;
                    node = stepNode;
                    tempNode = stepNode;
                    continue;
                }
            } else {
                if (step != 0) {
                    if (resultHead != null) {
                        final Node lastNode = getLastNode(resultHead);
                        lastNode.next = reverseSingleNode(tempNode);
                        return resultHead;
                    } else {
                        resultHead = reverseSingleNode(tempNode);
                        return resultHead;
                    }
                } else {
                    return resultHead;
                }
            }
            node = node.next;
        }

    }

    private static Node reverseSingleNode(Node node) {
        if (node == null || node.next == null) {
            return node;
        }
        Node next = node;
        Node pre = null;
        while (next != null) {
            next = node.next;
            node.next = pre;
            pre = node;
            node = next;
        }
        return pre;
    }

    private static Node getLastNode(Node node) {
        if (node == null || node.next == null) {
            return node;
        }
        Node next = node;
        while (node.next != null) {
            next = node.next;
            node = node.next;
        }
        return next;
    }

    public static void printNode(Node node) {
        if (node == null) {
            System.out.println("null");
        }
        while (true) {
            System.out.println(node.data);
            if (node.next != null) {
                node = node.next;
            } else {
                break;
            }
        }
    }

    static class Node {
        private final Integer data;
        private Node next;

        public Node(final Integer data) {
            this.data = data;
        }
    }

}

3、冒泡排序+快速排序

package org.article.controller;

/**
 * 排序算法总结
 *
 * @author yangyang14
 * @date 2022/11/3 18:48
 **/
public class Sort {

    public static void main(final String[] args) {
        // 冒泡排序 O(n²)
        // final int[] arr = {5, 4, 6, 2, 3, 9};
        // bubbleSort(arr);
        // for (final int i : arr) {
        // System.out.print(i + ",");
        // }

        // 快速排序 O(nlogn)
        final int[] arr1 = {5, 4, 6, 2, 3, 9};
        quickSort(arr1, 0, arr1.length - 1);
        for (final int i : arr1) {
            System.out.print(i + ",");
        }
    }

    private static void quickSort(final int[] num, final int left, final int right) {
        if (left < right) {
            // 获取一个基数
            final int base = num[left];
            // 获取一个左指针
            int i = left;
            // 获取一个右指针
            int j = right;
            while (i < j) {
                // 当右指针大于基数，右指针向左移动
                while (i < j && num[j] >= base) {
                    j--;
                }
                // 当右指针小于基数，和左指针交换位置
                num[i] = num[j];
                // 当左指针小于基数，左指针向右移动
                while (i < j && num[i] <= base) {
                    i++;
                }
                // 当左指针大于基数，右指针交换位置
                num[j] = num[i];
            }
            num[i] = base;
            quickSort(num, left, i);
            quickSort(num, i + 1, right);
        }
    }

    /**
     * 冒泡排序 平均时间复杂度 O(n²)
     *
     * @param arrs
     */
    private static void bubbleSort(final int[] arrs) {
        int temp;
        for (int i = 0; i < arrs.length - 1; i++) {
            for (int j = 0; j < arrs.length - 1 - i; j++) {
                if (arrs[j] > arrs[j + 1]) {
                    temp = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = temp;
                }
            }
        }
    }

}