weixin_44718747的博客

转载自：https://www.cnblogs.com/leesf456/p/6107600.html【分布式】Zookeeper的Leader选举一、前言前面学习了Zookeeper服务端的相关细节，其中对于集群启动而言，很重要的一部分就是Leader选举，接着就开始深入学习Leader选举。二、Leader选举2.1 Leader选举概述Leader选举是保证分布式数据一致性的关键所在。当Zookeeper集群中的一台服务器出现以下两种情况之一时，需要进入Leader选举。(1) 服务器初

limit 以及 offest 关键字常用技巧# 仅使用limit关键字 此时 limit i，j后面两个参数各自表示的意义是 从第i+1条记录开始 取 j 条# 如果此时limit 后只跟了1个参数 j，表示从第1条数据开始(包括第i条记录)，取 j 条#使用limit和offset组合使用的时候，limit后面只能有一个参数，表示要取的的数量,offset表示要跳过的数量(从第1条记录开始) 。#以下均为查询入职时间倒数第三的员工的所有信息select * from employees ord

【思想】：考虑使用中序的非递归遍历实现

【思想】：现在想通过交换相邻元素的操作把一个给定序列交换成有序，最少需要交换的次数即为此时序列中的逆序对的个数然后就转化为求逆序对的个数的题

package Math;import java.util.HashMap;import java.util.Map;import java.util.Scanner;/** * n进制加法，n进制就表示数的访问从0到n-1,如果当前位上的值为n则令其对n取余，然后进位 = num/n * 然后，当n<10时，因为数组均是从0-9不用进行转换，但是当n>=10时，此时用字母来表示数字，所以需要进行额外转化 * * */public class NjinzhiSUm {

递归公式推导法：我们可以知道第n行有2n-1个字符，其中前2(n-1)-1个字符是上一个字符串的值，第2(n-1)个是新加的1，后面2(n-1)-1个字符是上一个字符串翻转取反得来的。那么对于给定的n和k,我们只需求这个位置的k最初是由之前哪次的字符串的哪个字符变来的，并计算被反转的次数，我们就能得到当前k是啥。每次递归中三种情况：1.如果k>2^(n-1),说明它是上一个字符串翻转（因为是翻转会生成的后半段，所以其位置=2 ^ (n-1）-k而不是直接是k！！！）并invert过来的部分，可

看清题意，给定的分别是每个矩阵的左下角和右上角class Solution { public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) { int x1 = Math.max(A,E),y1 = Math.max(B,F); int x2 = Math.min(C,G),y2 = Math.min(D,H); if(E>=C||F>=D||A&

public class Solution { public int JumpFloor(int target) { if(target==0) return 0; if(target==1) return 1; if(target==2) return 2; int i_1 = 2;//注意这里跟斐波那契数列的初始不同，斐波那契数列初始f(2) = 1,这里f(2)初始=2，其他的完全一样 int i_2 = 1; for(i

import java.util.*;public class Solution { /** * 二分查找 * @param n int整型 数组长度 * @param v int整型 查找值 * @param a int整型一维数组 有序数组 * @return int整型 */ public int upper_bound_ (int n, int v, int[] a) { int start = 0, end

【思想】：因为是有序序列，所有可以采用二分查找，在这个有序序列中找这个数，找到的时候再从这个位置相左右两端去找public class Solution { public int GetNumberOfK(int [] array , int k) { int start = 0,end = array.length-1; while(start<=end){ int mid = (start+end)/2; if(ar

import java.util.*;public class Solution { /** * * @param x int整型 * @return int整型 */ public int sqrt (int x) { if(x<=0) return 0; long left = 1,right = x; while(left<right){ long mid = (l

package 多线程;/** * 实现死锁 * */public class deadLock implements Runnable { String name; Object a; Object b; public deadLock(String name,Object a,Object b){ this.name = name; this.a = a; this.b = b; } @Overrid

思想：跟从前序和中序序列构造二叉树相反，这里依据后序遍历来确定每个子树的root，基于后序遍历的特定可知当前子树区间的最后一个节点即为其root，然后去中序遍历序列中找到这个root的位置即为rootIdx，则在对应的中序区间[instart,int inend]中从[rootIdx+1,inEnd]即为其右子树区间，然后根据右子树区间是否为空(也就是中序区间是否越界)来判定root是否有右孩子，如果有的话则root的右孩子一定是后序序列中root的前一个，没有的话则为空，然后其左孩子即为后序序列中第ro

DP思想：F[i,n]表示总共有n个结点且根节点为i的不同二叉树的数量G[i]表示用i个结点能构成的不同二叉树的数量F[i,n] = G[i-1]G[n-i]G[n]= i=1∑ G(i−1)⋅G(n−i)n这里用1…i-1这(i-1)个数为结点构成左子树用i+1…n这(n-i)个数为结点来构成右子树用i这个数表示的结点作为根节点。这样当i不同时所构成出的二叉树结构一定不同，且根节点为i时其对应的结构不同的二叉树数量=左子树的所有不同结构的数量右子树的所有不同结构的数量（它俩的笛卡儿

import java.util.Scanner;/** * 【阿里笔试题目】：给定一个数n，然后从1到n的这n个数构成一个环，每次从这个环中抽取m(1<=m<=n)个连续的数，问总共有多少种不同抽取方案 * 【思想】：先统计正序的组合数，再求反序的组合数 * 比如：n = 4 * 正序的组合有： * {1}，{1，2}，{1，2，3}，{1，2，3，4} ：n种 * {2}，{2，3}，{2，3，4} ：n-1种 * {3}，{3，4}

import java.util.ArrayList;import java.util.List;/** * 【题目】:别人面经上的一道题：求两个有序数组中的交集。看似很简单的一道题，但是最终想要的思路是一个来回二分查找的思路 * 【思想】：求交集的就需要去查找两个数组中的重复元素。然后要查找的话，又是有序数组，自然想到二分查找。所以，首先遍历数组A中的数numsA[idx] * 然后再数组B中去二分查找numsA[idx]，返回一个索引idx2; 然后if(numsA[idx]==numsB[

【题目】：给定一个整数序列，问你最少删去多少个数字后使得整个数序列严格单调(可以是单调增也可以是单调减)【思想】：可以先去求最长连续递增或者递减子序列的长度，假设为l，然后len - l即为结果时间复杂度O(N) 空间复杂度O(N)import java.util.Scanner;public class Main2 { public static int helper(int[]nums){ int len = nums.length; int[]dp .

思想：求所有串的公共前缀，则我们就可以以其中的任何一个串为基准，从左到右遍历其每个字符是否在其他串中按序出现，这里为了后序子串的遍历方便，选择以第一个串为基准时间复杂度O(n*len),len为串的最大长度，n为串的个数空间复杂度O(len)class Solution { public String longestCommonPrefix(String[] strs) { int len = strs.length; StringBuilder res = new

【题目】：给定一个数组，找出数组内两两组合使得差最大或者最小的组合个数，注意原数组无序且每个数都是正整数时间复杂度O(nlogn) 空间复杂度O(1)import java.util.Arrays;import java.util.Scanner;public class T3 { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.n

思想：把情况考虑周全，比如第一个字符就为],},)的其中一个时要如何处理class Solution { public boolean isValid(String s) { int len = s.length(); if(len<=1)return false; LinkedList<Character> stack = new LinkedList<>(); for(int i=0;i<len;i++){

思想：跟前面的一道链表加法题很像，特别注意不要忘了对最高位产生的进位进行处理时间复杂度O(N) 空间复杂度O(N) N为两个字符串的最大长度class Solution { public String addStrings(String num1, String num2) { int jw = 0; int len1 = num1.length(),len2 = num2.length(); char[]longStr = (len1>len2)

Case1:import java.util.Scanner;/*** 判断一个数是否为2的幂次，本质还是一个找规律的题 * 一个数如果是2的幂次，那么其二进制表示一定为最高位是1，后面全跟着0 * 然后呢这个数-1 ，一定是最高位为0，后面跟着一串1 * 所以若n是2的幂次则 n & n-1 一定为0* */public class T2 { public static void main(String[] args) { Scanner in = new

【题目】：给定一个n*2的数组，第一列是字母，第二列是一组随机数字，要求实现去重，保留第二列值最大的那个字母，若值相等则保留前面那一行，并且还要保证相对顺序不变【思想】：先求出每个字母权值最大时所处的位置，记录一下，然后再建立一个结果数组将这个记录权值最大的位置的字母给映射回去import java.util.Arrays;public class Main1 { static int n = 6; public static void main(String[] args) {

思想：迭代枚举即可(当然也可以递归求)，这里利用Map来存储之前的结果，也可以用数组也就是dp来实现时间复杂度O(n*m) m是生成子串的最大长度 ，空间复杂度O(n)class Solution { public String countAndSay(int n) { if(n==1){ return "1"; } if(n==2){ return "11"; } Map<Integer,

思想：先建立那几个基准字符与对应数字之间的映射，然后之后就抓住一点即可：如果当前字符表示的数字比下一个字符表示的数字小，则令res-=当前字符表示的数字，否则令res+=当前字符表示的数字class Solution { public int romanToInt(String s) { int len = s.length(); if(len<=0)return 0; Map<Character,Integer> map = new H

思想：找规律，看最终生成的Z字型排列，发现，串s中的各字符是先按numRows递增的顺序插入到最终排列的各行，遍历到边界处时，再按numRows递减的顺序插入到最终排列的各行(Z字形嘛，一个左旋90度的Z)class Solution { public String convert(String s, int numRows) { if(numRows<=1)return s; StringBuilder[] temp = new StringBuilder[

思想:采用滑动窗口思想，利用Map来实现一个窗口，每扩充一下窗口就去更新结果res需要特别注意的是在扩充窗口时需注意：如果map中不包含right所指向的字符，直接扩充即可；但是如果map中包含right所指向的字符，此时需要区分到底是因为跟当前窗口之前(外)的字符重复，还是跟当前窗口内的元素重复。如果是因为跟当前窗口之前(外)的字符重复，而不是跟当前窗口内的元素重复，那么此时left还是指向当前窗口的left，否则就指向发生重复的下一个位置时间复杂度O(n) 空间复杂度O(n)class Solu

思想：既然想要将原链表尽可能的均分为k段，那么可以先求出整个链表的长度，然后，如果当前链表的剩余长度能够整除k，那么每次从原链表中取(total / k) 个组成一段，如果不能整除，那么每次从每次从原链表中取(total / k + 1) 个组成一段(因为题目要求前面的段的长度要>=后面的段的长度，且各段的长度差不能超过1)；然后令k–表示再把剩下的链表均分为k段即可。最终，如果分割出的段数小于给定值，那么用null进行替代即可时间复杂度O(N) ,空间复杂度O(N)class Solutio

思想：删除倒数第n个节点相当于删除正数第len-n+1个节点，要删去它，找其前驱class Solution { public ListNode removeNthFromEnd(ListNode head, int n) { if(head==null)return head; int len = 0; ListNode temp = head; while(temp!=null){ len++; temp

CASE1【思想】：利用一个map来存储每个节点在有序链表中的前驱节点，剩下的就直接暴力插排就行时间复杂度O(n^2) 空间复杂度O(n)class Solution { public ListNode insertionSortList(ListNode head) { if(head==null||head.next==null) return head; ListNode tempHead = new ListNode(Integer.MIN_VALUE);

1、懒汉模式(不具备线程安全性)public class Singleton{ private static Singleton instance; private Singleton(){ } public static Singleton getSingletonInstance(){ if(instance==null){ instance = new Singleton(); } return instance; }

T82：【题目】：给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。【思想】： 跟下面那个题一样，也是创建一个辅助链表，利用尾插法将原链表中的唯一节点进行插入，还是要注意断链class Solution { public ListNode deleteDuplicates(ListNode head) { if(head==null||head.next==null)return head; ListNode tempHead =

1、fast = head.next slow = head (这样初始化后如果链表长度为奇数，最终slow指向的是当前链表的正中间位置上的结点，如果链表长度为偶的话，则指向中间偏左的那个结点)2、fast = head, slow = head(这样初始化后如果链表长度为奇数，最终slow指向的是当前链表的正中间位置上的结点，如果链表长度为偶的话，则指向中间偏右的那个结点)注意两个的区别，看题目要求来选择快慢指针的初始化方式...

思想:从有序序列中构造AVL，首先想到的就是利用二分查找来构造，因为这里是链表所以还要结合快慢指针法来分割链表的左右区间及找到当前区间的中间结点【Tips:】注意快慢指针法的两种初始化方式的区别:1、fast = head.next slow = head (这样初始化后如果链表长度为奇数，最终slow指向的是当前链表的正中间位置上的结点，如果链表长度为偶的话，则指向中间偏左的那个结点)2、fast = head, slow = head(这样初始化后如果链表长度为奇数，最终slow指向的是当前链表

思想：既然不让直接逆置链表，则借助stack进行翻转，然后再按从低位开始计算，并将计算后的结果存入长链表节点中，这里需要额外注意：1、需要对短链表中的元素要进行特殊处理因为有可能它此时为null 2、另外还需要对最高位的进位进行处理时间复杂度O(n) 空间复杂度O(m+n) m:短链表的长度 n:长链表的长度class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { LinkedList&

case1思想：类似插排，借助一个辅助头节点，遍历链表，如果ListNode.val ! = 给定值，则把其摘出来，尾插进新的辅助链表中class Solution { public ListNode removeElements(ListNode head, int val) { if(head==null)return head; if(head.next==null&&head.val==val)return null; ListNode

题目：请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。class Solution { public void deleteNode(ListNode node) { node.val = node.next.val; node.next = node.next.next; }}...

思想：先基于快慢指针法将链表分为左右两个子链表，然后将右链表逆置后按顺序将各元素插入进左链表中的每个元素的后面时间复杂度O(N) ,空间复杂度O(1)class Solution { public void reorderList(ListNode head) { if(head==null)return; ListNode fast = head.next,slow = head; while(fast!=null&&fast.next!=n

思想：借助辅助空间，同时维护两个链表：lowList按原先顺序保存所有val小于x的节点，hightList按原先顺序保存所有val>=x的节点，最后将这两个链表拼接起来即可时间复杂度O(N),空间复杂度O(1)class Solution { public ListNode partition(ListNode head, int x) { if(head==null)return head; ListNode lowList = new ListNode(-1)

思想：将各种情况分开讨论，且注意最好统一进行移动操作，这样不容易混淆时间复杂度O(n),空间复杂度O(1)示例:输入: 1->2->3->4->5->NULL, m = 2, n = 4输出: 1->4->3->2->5->NULLclass Solution { public ListNode reverseBetween(ListNode head, int m, int n) { if(head==null||