算法入门--20191106

数据结构与算法 邓俊辉
https://dsa.cs.tsinghua.edu.cn/~deng/ds/dsaj/index.htm

1、波兰式、逆波兰式与表达式求值
https://blog.csdn.net/linraise/article/details/20459751

2、力扣“两数之和”练习
https://leetcode-cn.com/problems/two-sum/

/*给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

来源：力扣（LeetCode）
* */

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
package addTwoListNode;

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        this.val = x;
        this.next = null;
    }
}


class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(0);
        ListNode p = l1, q = l2, curr = dummyHead;
        int carry = 0;
        while (p != null || q != null) {
            int x = (p != null) ? p.val : 0;
            int y = (q != null) ? q.val : 0;
            int sum = carry + x + y;
            carry = sum / 10;
            curr.next = new ListNode(sum % 10);
            curr = curr.next;
            if (p != null) p = p.next;
            if (q != null) q = q.next;
        }
        if (carry > 0) {
            curr.next = new ListNode(carry);
        }
        return dummyHead.next;
    }
}

public class AddTwoListNode {

    private static ListNode buildListNode(int[] input){
        ListNode first = null, last = null, newNode;
        int num;
        if (input.length > 0) {
            last = first = newNode = new ListNode(input[0]);
            for(int i = 1; i < input.length; i++){
                newNode=new ListNode(input[i]);
                last.next = newNode;
                last = newNode;
            }
        }
        return first;
    }

    public static void main(String[] args) {
        ListNode l1 = buildListNode(new int[] {2, 3, 4});
        ListNode l2 = buildListNode(new int[] {5, 6, 7}) ;

        Solution solution = new Solution();
        ListNode l3 = solution.addTwoNumbers(l1, l2);

        ListNode temp = l3;
        System.out.println(temp.val);
        while (temp.next != null) {
            temp = temp.next;
            System.out.println(temp.val);
        }
    }
}

3、红黑树(一)之 原理和算法详细介绍
https://www.cnblogs.com/skywang12345/p/3245399.html

4、算法学习：我终于明白二分查找的时间复杂度为什么是O(logn)了
https://www.cnblogs.com/yellowgg/p/11272908.html
直接看看二分查找的。

我们都知道二分查找在最坏的情况下依次是n/2,n/4,n/8。。。。 一直到1为止，这就有点惨了。
然后，意思就是要循环多少次才能查找到目标数呢，我们假设是x次。

然后我们可以观察到分母是每次都乘以1/2，分子不变，所以可以根据题意列出下面等式：

5、Java求最大公约数和最小公倍数
https://blog.csdn.net/lwcumt/article/details/8029241

import java.util.Scanner;
 
/*求最大公约数和最小公倍数*/
public class MaxCommonDivisorAndMinCommonMultiple {
 
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);// 接收控制台输入的信息
 
		System.out.print("请输入第一个整数：");
		int num1 = scan.nextInt(); // 取出控制台输入的信息
 
		System.out.print("请输入第二个整数：");
		int num2 = scan.nextInt(); // 取出控制台输入的信息
 
		System.out.println(maxCommonDivisor(num1, num2));// 调用maxCommonDivisor()方法
		System.out.println(minCommonMultiple(num1, num2));// 调用minCommonMultiple()方法
	}
 
	// 递归法求最大公约数
	public static int maxCommonDivisor(int m, int n) {
		if (m < n) {// 保证m>n,若m<n,则进行数据交换
			int temp = m;
			m = n;
			n = temp;
		}
		if (m % n == 0) {// 若余数为0,返回最大公约数
			return n;
		} else { // 否则,进行递归,把n赋给m,把余数赋给n
			return maxCommonDivisor(n, m % n);
		}
	}
 
	// 循环法求最大公约数
	public static int maxCommonDivisor2(int m, int n) {
 
		if (m < n) {// 保证m>n,若m<n,则进行数据交换
			int temp = m;
			m = n;
			n = temp;
		}
		while (m % n != 0) {// 在余数不能为0时,进行循环
			int temp = m % n;
			m = n;
			n = temp;
		}
		return n;// 返回最大公约数
	}
 
	// 求最小公倍数
	public static int minCommonMultiple(int m, int n) {
		return m * n / maxCommonDivisor(m, n);
	}
}

6、通过移动数组中的元素，使2个数组中的平均数都增大，约束条件：调整后数组不新增值相等的元素。实例代码（20200323）

import java.util.Arrays;

public class GetMaxAverageVal {
    public static void main(String[] args) {
        int[] teamA = {20, 10, 50};
        int[] teamB = {20, 30, 40, 41, 50, 60};
        GetMaxAverageVal getMaxAverageVal = new GetMaxAverageVal();

        int ret = getMaxAverageVal.maxTime(teamA, teamB);
        System.out.println("ret = " + ret);

    }

    private   int maxTime(int[] teamA, int[] teamB) {
        if (teamA == null || teamB == null) {
            return 0;
        }

        int ret = 0;
        Arrays.sort(teamA);
        float aAverage = calAverage(teamA);
        //System.out.println("aAverage = " + aAverage);
        float bAverage = calAverage(teamB);
        //System.out.println("bAverage = " + bAverage);
        if(aAverage == bAverage) {
            return 0;
        } else if (aAverage < bAverage) {
            for(int j = 0; j < teamB.length; j++) {
                //int index = Arrays.binarySearch(teamA,teamB[j]);
                //System.out.println("index = " + index);
                if(teamB[j] < bAverage && teamB[j] > aAverage && Arrays.binarySearch(teamA,teamB[j]) < 0) {
                    ret++;
                }
            }
        } else {
            for(int j = 0; j < teamA.length; j++) {
                if(teamA[j] < aAverage && teamA[j] > bAverage && Arrays.binarySearch(teamB,teamA[j]) < 0) {
                    ret++;
                }
            }
        }
        return ret;
    }

    private float calAverage(int[] team) {
        int sum = 0;
        for (int i = 0; i < team.length; i++) {
            sum += team[i];
        }
        float average = (float) sum/team.length;
        return average;
    }
}

7、快速排序算法详解（原理、实现和时间复杂度）
http://data.biancheng.net/view/117.html