《漫画算法》源码整理-6

Posted 2022-01-30 GarfieldEr007

判断链表有环

public class LinkedListCycle 

    /**
     * 判断是否有环
     * @param head  链表头节点
     */
    public static boolean isCycle(Node head) 
        Node p1 = head;
        Node p2 = head;
        while (p2!=null && p2.next!=null)
            p1 = p1.next;
            p2 = p2.next.next;
            if(p1 == p2)
                return true;
            
        
        return false;
    

    /**
     * 链表节点
     */
    private static class Node 
        int data;
        Node next;
        Node(int data) 
            this.data = data;
        
    

    public static void main(String[] args) throws Exception 
        Node node1 = new Node(5);
        Node node2 = new Node(3);
        Node node3 = new Node(7);
        Node node4 = new Node(2);
        Node node5 = new Node(6);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node2;

        System.out.println(isCycle(node1));
    

最小数栈

import java.util.Stack;


public class MinStack 

    private Stack<Integer> mainStack = new Stack<Integer>();
    private Stack<Integer> minStack = new Stack<Integer>();

    /**
     * 入栈操作
     * @param element  入栈的元素
     */
    public void push(int element) 
        mainStack.push(element);
        //如果辅助栈为空，或新元素小于等于辅助栈栈顶，则新元素压入辅助栈
        if (minStack.empty() || element  <= minStack.peek()) 
            minStack.push(element);
        
    

    /**
     * 出栈操作
     */
    public Integer pop() 
        //如果出栈元素和辅助栈栈顶元素值相等，辅助栈出栈
        if (mainStack.peek().equals(minStack.peek())) 
            minStack.pop();
        
        return mainStack.pop();
    

    /**
     * 获取栈的最小元素
     */
    public int getMin() throws Exception 
        if (mainStack.empty()) 
            throw new Exception("stack is empty");
        

        return minStack.peek();
    

    public static void main(String[] args) throws Exception 
        MinStack stack = new MinStack();
        stack.push(4);
        stack.push(9);
        stack.push(7);
        stack.push(3);
        stack.push(8);
        stack.push(5);
        System.out.println(stack.getMin());
        stack.pop();
        stack.pop();
        stack.pop();
        System.out.println(stack.getMin());
    

最大公约数

public class GreatestCommonDivisor 

    public static int getGreatestCommonDivisor(int a, int b)
        int big = a>b ? a:b;
        int small = a<b ? a:b;
        if(big%small == 0)
            return small;
        
        for(int i= small/2; i>1; i--)
            if(small%i==0 && big%i==0)
                return i;
            
        
        return  1;
    

    public static int getGreatestCommonDivisorV2(int a, int b)
        int big = a>b ? a:b;
        int small = a<b ? a:b;
        if(big%small == 0)
            return small;
        
        return getGreatestCommonDivisorV2(big%small, small);
    

    public static int getGreatestCommonDivisorV3(int a, int b)
        if(a == b)
            return a;
        
        int big = a>b ? a:b;
        int small = a<b ? a:b;
        return getGreatestCommonDivisorV3(big - small, small);
    

    public static int gcd(int a, int b)
        if(a == b)
            return a;
        
        if((a&1)==0 && (b&1)==0)
            return gcd(a >> 1, b >> 1)<<1;
         else if((a&1)==0 && (b&1)!=0)
            return gcd(a >> 1, b);
         else if((a&1)!=0 && (b&1)==0)
            return gcd(a, b >> 1);
         else 
            int big = a>b ? a:b;
            int small = a<b ? a:b;
            return gcd(big - small, small);
        
    

    public static void main(String[] args) 
        System.out.println(gcd(25, 5));
        System.out.println(gcd(100, 80));
        System.out.println(gcd(27, 14));
    

2的幂

public class PowerOf2 

    public static boolean isPowerOf2(int num) 
        int temp = 1;
        while(temp<=num)
            if(temp == num)
                return true;
            
            temp = temp*2;
        
        return false;
    

    public static boolean isPowerOf2V2(int num) 
        int temp = 1;
        while(temp<=num)
            if(temp == num)
                return true;
            
            temp = temp<<1;
        
        return false;
    

    public static boolean isPowerOf2V3(int num) 
        return (num&num-1) == 0;
    

    public static void main(String[] args) 
        System.out.println(isPowerOf2V3(32));
        System.out.println(isPowerOf2V3(19));
    

最大有序距离

public class MaxSortedDistance 

    public static int getMaxSortedDistance(int[] array)

        //1.得到数列的最大值和最小值
        int max = array[0];
        int min = array[0];
        for(int i=1; i<array.length; i++) 
            if(array[i] > max) 
                max = array[i];
            
            if(array[i] < min) 
                min = array[i];
            
        
        int d = max - min;
        //如果max和min相等，说明数组所有元素都相等，返回0
        if(d == 0)
            return 0;
        

        //2.初始化桶
        int bucketNum = array.length;
        Bucket[] buckets = new Bucket[bucketNum];
        for(int i = 0; i < bucketNum; i++)
            buckets[i] = new Bucket();
        

        //3.遍历原始数组，确定每个桶的最大最小值
        for(int i = 0; i < array.length; i++)
            //确定数组元素所归属的桶下标
            int index = ((array[i] - min)  * (bucketNum-1) / d);
            if(buckets[index].min==null || buckets[index].min>array[i])
                buckets[index].min = array[i];
            
            if(buckets[index].max==null || buckets[index].max<array[i])
                buckets[index].max = array[i];
            
        

        //4.遍历桶，找到最大差值
        int leftMax = buckets[0].max;
        int maxDistance = 0;
        for (int i=1; i<buckets.length; i++) 
            if (buckets[i].min == null) 
                continue;
            
            if (buckets[i].min - leftMax > maxDistance) 
                maxDistance = buckets[i].min - leftMax;
            
            leftMax = buckets[i].max;
        

        return maxDistance;
    

    /**
     * 桶
     */
    private static class Bucket 
        Integer min;
        Integer max;
    

    public static void main(String[] args) 
        int[] array = new int[] 2,6,3,4,5,10,9;
        System.out.println(getMaxSortedDistance(array));
    

用栈实现队列

import java.util.Stack;

public class StackQueue 

    private Stack<Integer> stackA = new Stack<Integer>();
    private Stack<Integer> stackB = new Stack<Integer>();

    /**
     * 入队操作
     * @param element  入队的元素
     */
    public void enQueue(int element) 
        stackA.push(element);
    

    /**
     * 出队操作
     */
    public Integer deQueue() 
        if(stackB.isEmpty())
            if(stackA.isEmpty())
                return null;
            
            transfer();
        
        return stackB.pop();
    

    /**
     * 栈A元素转移到栈B
     */
    private void transfer()
        while (!stackA.isEmpty())
            stackB.push(stackA.pop());
        
    

    public static void main(String[] args) throws Exception 
        StackQueue stackQueue = new StackQueue();
        stackQueue.enQueue(1);
        stackQueue.enQueue(2);
        stackQueue.enQueue(3);
        System.out.println(stackQueue.deQueue());
        System.out.println(stackQueue.deQueue());
        stackQueue.enQueue(4);
        System.out.println(stackQueue.deQueue());
        System.out.println(stackQueue.deQueue());
    

最近数字

import java.util.Arrays;

public class FindNearestNumber 

    public static int[] findNearestNumber(int[] numbers)
        //1.从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界
        int index = findTransferPoint(numbers);
        //如果数字置换边界是0，说明整个数组已经逆序，无法得到更大的相同数字组成的整数，返回null
        if(index == 0)
            return null;
        
        //2.把逆序区域的前一位和逆序区域中刚刚大于它的数字交换位置
        //拷贝入参，避免直接修改入参
        int[] numbersCopy = Arrays.copyOf(numbers, numbers.length);
        exchangeHead(numbersCopy, index);
        //3.把原来的逆序区域转为顺序
        reverse(numbersCopy, index);
        return numbersCopy;
    

    private static int findTransferPoint(int[] numbers)
        for(int i=numbers.length-1; i>0; i--)
            if(numbers[i] > numbers[i-1])
                return i;
            
        
        return 0;
    

    private static int[] exchangeHead(int[] numbers, int index)
        int head = numbers[index-1];
        for(int i=numbers.length-1; i>0; i--)
            if(head < numbers[i])
                numbers[index-1] =  numbers[i];
                numbers[i] = head;
                break;
            
        
        return numbers;
    

    private static int[] reverse(int[] num, int index)
        for(int i=index,j=num.length-1; i<j; i++,j--)
            int temp = num[i];
            num[i] = num[j];
            num[j] = temp;
        
        return num;
    

    public static void main(String[] args) 
        int[] numbers = 1,2,3,4,5;
        //打印12345之后的10个全排列整数
        for(int i=0; i<10;i++)
            numbers = findNearestNumber(numbers);
            outputNumbers(numbers);
        
    

    //输出数组
    private static void outputNumbers(int[] numbers)
        for(int i : numbers)
            System.out.print(i);
        
        System.out.println();
    

删除整数的k个数字，获得删除后的最小值

public class RemoveKDigits 

    /**
     * 删除整数的k个数字，获得删除后的最小值
     * @param num  原整数
     * @param k  删除数量
     */
    public static String removeKDigits(String num, int k) 
        for(int i=0; i<k; i++)
            boolean hasCut = false;
            //从左向右遍历，找到比自己右侧数字大的数字并删除
            for(int j=0; j<num.length()-1;j++)
                if(num.charAt(j) > num.charAt(j+1))
                    num = num.substring(0, j) + num.substring(j+1,num.length());
                    hasCut = true;
                    break;
                
            
            //如果没有找到要删除的数字，则删除最后一个数字
            if(!hasCut)
                num = num.substring(0, num.length()-1);
            
        
        //清除整数左侧的数字0
        int start = 0;
        for(int j=0; j<num.length()-1; j++)
            if(num.charAt(j) != '0')
                break;
            
            start++;
        
        num = num.substring(start, num.length()) ;
        //如果整数的所有数字都被删除了，直接返回0
        if(num.length() == 0)
            return "0";
        
        return num;
    

    /**
     * 删除整数的k个数字，获得删除后的最小值
     * @param num  原整数
     * @param k  删除数量
     */
    public static String removeKDigitsV2(String num, int k) 
        //新整数的最终长度 = 原整数长度 - k
        int newLength = num.length() - k;
        //创建一个栈，用于接收所有的数字
        char[] stack = new char[num.length()];
        int top = 0;
        for (int i = 0; i < num.length(); ++i) 
            //遍历当前数字
            char c = num.charAt(i);
            //当栈顶数字大于遍历到的当前数字，栈顶数字出栈（相当于删除数字）
            while (top > 0 && stack[top-1] > c && k > 0) 
                top -= 1;
                k -= 1;
            
            //如果遇到数字0，且栈为空，0不入栈
            if('0' == c && top == 0)
                newLength--;
                if(newLength <= 0)
                    return "0";
                
                continue;
            
            //遍历到的当前数字入栈
            stack[top++] = c;
        
        // 用栈构建新的整数字符串
        return newLength<=0 ? "0" : new String(stack, 0, newLength);
    

    public static void main(String[] args) 
        System.out.println(removeKDigits("1593212", 3));
        System.out.println(removeKDigits("30200", 1));
        System.out.println(removeKDigits("10", 2));
        System.out.println(removeKDigits("541270936", 3));
        System.out.println(removeKDigits("1593212", 4));
        System.out.println(removeKDigits("1000020000000010", 2));
    

大整数求和

public class BigNumberSum 

    /**
     * 大整数求和
     * @param bigNumberA  大整数A
     * @param bigNumberB  大整数B
     */
    public static String bigNumberSum(String bigNumberA, String bigNumberB) 
        //1.把两个大整数用数组逆序存储，数组长度等于较大整数位数+1
        int maxLength = bigNumberA.length() > bigNumberB.length() ? bigNumberA.length() : bigNumberB.length();
        int[] arrayA = new int[maxLength+1];
        for(int i=0; i< bigNumberA.length(); i++)
            arrayA[i] = bigNumberA.charAt(bigNumberA.length()-1-i) - '0';
        
        int[] arrayB = new int[maxLength+1];
        for(int i=0; i< bigNumberB.length(); i++)
            arrayB[i] = bigNumberB.charAt(bigNumberB.length()-1-i) - '0';
        
        //2.构建result数组，数组长度等于较大整数位数+1
        int[] result = new int[maxLength+1];
        //3.遍历数组，按位相加
        for(int i=0; i<result.length; i++)
            int temp = result[i];
            temp += arrayA[i];
            temp += arrayB[i];
            //判断是否进位
            if(temp >= 10)
                temp = temp-10;
                result[i+1] = 1;
            
            result[i] = temp;
        
        //4.把result数组再次逆序并转成String
        StringBuilder sb = new StringBuilder();
        //是否找到大整数的最高有效位
        boolean findFirst = false;
        for (int i = result.length - 1; i >= 0; i--) 
            if(!findFirst)
                if(result[i] == 0)
                    continue;
                
                findFirst = true;
            
            sb.append(result[i]);
        
        return sb.toString();
    

    public static void main(String[] args) 
        System.out.println(bigNumberSum("426709752318", "95481253129"));
    

获得金矿最优收益

public class GoldMining 

    /**
     * 获得金矿最优收益
     * @param w  工人数量
     * @param p  金矿开采所需工人数量
     * @param g  金矿储量
     */
    public static int getBestGoldMiningV3(int w, int[] p, int[] g)
        //创建当前结果
        int[] results = new int[w+1];
        //填充一维数组
        for(int i=1; i<=g.length; i++)
            for(int j=w; j>=1; j--)
               if(j>=p[i-1])
                    results[j] = Math.max(results[j],  results[j-p[i-1]]+ g[i-1]);
                
            
        
        //返回最后一个格子的值
        return results[w];
    

    /**
     * 获得金矿最优收益
     * @param w  工人数量
     * @param p  金矿开采所需工人数量
     * @param g  金矿储量
     */
    public static int getBestGoldMiningV2(int w, int[] p, int[] g)
        //创建表格
        int[][] resultTable = new int[g.length+1][w+1];
        //填充表格
        for(int i=1; i<=g.length; i++)
            for(int j=1; j<=w; j++)
                if(j<p[i-1])
                    resultTable[i][j] = resultTable[i-1][j];
                else
                    resultTable[i][j] = Math.max(resultTable[i-1][j],  resultTable[i-1][j-p[i-1]]+ g[i-1]);
                
            
        
        //返回最后一个格子的值
        return resultTable[g.length][w];
    

    /**
     * 获得金矿最优收益
     * @param w  工人数量
     * @param n  可选金矿数量
     * @param p  金矿开采所需工人数量
     * @param g  金矿储量
     */
    public static int getBestGoldMining(int w, int n, int[] p, int[] g)
        if(w==0 || n==0)
            return 0;
        
        if(w<p[n-1])
            return getBestGoldMining(w, n-1, p, g);
        
        return Math.max(getBestGoldMining(w, n-1, p, g), getBestGoldMining(w-p[n-1], n-1, p, g)+g[n-1]);
    


    public static void main(String[] args) 
        int w = 10;
        int[] p = 5, 5, 3, 4 ,3;
        int[] g = 400, 500, 200, 300 ,350;
        System.out.println("最优收益：" + getBestGoldMining(w, g.length, p, g));
    

找到缺失的数字

public class FindLostNum 

    public static int[] findLostNum(int[] array) 
        //用于存储两个出现奇数次的整数
        int result[] = new int[2];
        //第一次整体异或
        int xorResult = 0;
        for(int i=0;i<array.length;i++)
            xorResult^=array[i];
        
        //如果异或结果为0，说明输入数组不符合题目
        if(xorResult == 0)
            return null;
        
        //确定两个整数的不同位，以此来做分组
        int separator = 1;
        while (0==(xorResult&separator))
            separator<<=1;
        
        //第二次分组异或
        for(int i=0;i<array.length;i++)
            if(0==(array[i]&separator))
                result[0]^=array[i];
            else 
                result[1]^=array[i];
            
        

        return result;
    

    public static void main(String[] args) 
        int[] array = 4,1,2,2,5,1,4,3;
        int[] result = findLostNum(array);
        System.out.println(result[0] + "," + result[1]);