未完待续,—【】数字越大标题越难—

自小编的代码在github上,https://github.com/WINTERFELLS/LeetCode-Answers

那边只提供个人的解题思路,不肯定是最好的。

Problems 21-40

  1. 联合多个排好序的链表,递归比较好一点,每便回来当前的结点。
  2. 给定括号的个数,生成全体的能够的括号的结缘措施,DFS,没啥好说的。
  3. 集合k个排好序的链表,一起首没做出来,后来看的discuss,先二分然后再统一多个链表。
  4. 一个链表,两两交流,链表好烦呀。。。依旧要演练。
  5. 三个链表,每k个沟通一下,倒霉意思没做出来,想不清。。。
  6. 移出排好序的数组重复成分,没啥好说的,暴力吧。
  7. 移出一个数组中有些内定的因素,暴力。
  8. 贯彻子体系在原种类中出现的职分,小编是一向3个一个子体系进行相比较的。
  9. 七个数相除不可能用除运算,不得以除这就径直除数一贯加,考虑正负和越界。
  10. 在三个字符串中找到由给定的字符串数组全体字符组成的下标,想不清了没AC。
  11. 多少个数的排序,在给定2个排序的情状下求下3个,首先总结出如今这些数是第二种排列,然后总括下一种排列,用除数和余数递归可以做。
  12. 最长的官方的括号匹配,没AC,不提。
  13. 贰个旋转过的排序,找到钦赐的值的目录,二分查找,须求相比start和mid大小。
  14. 排序数组,找到某些给定值的限制,二分。
  15. 排序数组,给定一个数,找到插入的任务,二分。
  16. 认清数独是不是建立,八个2位数组分别存放行,列和斜,然后判断是还是不是有双重字符。
  17. 求解两个数独,DFS加上一题的判断。
  18. 概念二个生成字符串的规则,就依据说的来就好了。
  19. 八个一如既往数组卯月为给定值的结缘,DFS。
  20. 二个冬日,冬辰数组中和为给定值的重组,先排序,然后DFS。

未完待续。。。

 

数组、矩阵

  1. 回形矩阵

    public static void spiralOrderPrint(int[][] matrix) {
        int tR = 0;
        int tC = 0;
        int dR = matrix.length - 1;
        int dC = matrix[0].length - 1;
        while (tR <= dR && tC <= dC) {
            printEdge(matrix, tR++, tC++, dR--, dC--);
        }
    }
    
    public static void printEdge(int[][] m, int tR, int tC, int dR, int dC) {
        if (tR == dR) { // 子矩阵只有一行时
            for (int i = tC; i <= dC; i++) {
                System.out.print(m[tR][i] + " ");
            }
        } else if (tC == dC) { // 子矩阵只有一列时
            for (int i = tR; i <= dR; i++) {
                System.out.print(m[i][tC] + " ");
            }
        } else { // 一般情况
            int curC = tC;
            int curR = tR;
            while (curC != dC) {
                System.out.print(m[tR][curC] + " ");
                curC++;
            }
            while (curR != dR) {
                System.out.print(m[curR][dC] + " ");
                curR++;
            }
            while (curC != tC) {
                System.out.print(m[dR][curC] + " ");
                curC--;
            }
            while (curR != tR) {
                System.out.print(m[curR][tC] + " ");
                curR--;
            }
        }
    }```
    
  2. 蛇形矩阵

  3. 【2】在排序数组中搜索和为给定值的多个数字(思路)
    1. 找到数组的首先个数字和结尾一个数字。
    2. 当多少个数字的和过量输入的数字时,把较大的数字往前挪动;
    3. 当多少个数字的和小于数字时,把较小的数字未来移动;
    4. 当相等时,输出等式。那样扫描的次第是从数组的两端向数组的中级扫描。

大数据

1.【3】海量N个数中求前M大个数(选用第M运气)


栈和队列

  1. 【2】用三个类别实现栈

    public class TwoQueue {
      private LinkedList<String> queue1;
      private LinkedList<String> queue2;
    
    public TwoQueue(){
        queue1 = new LinkedList<String>();
        queue2 = new LinkedList<String>();
    }   
    public String pop(){
        String re =null;
        if(queue1.size() == 0 && queue2.size() == 0){
            return null;
        }
        if(queue2.size() == 0){
            while(queue1.size() >0){
                re = queue1.removeFirst();
                if(queue1.size() != 0){ //最后一个不存进去
                    queue2.addLast(re);
                }
            }
        }else if(queue1.size() == 0){
            while(queue2.size() >0){
                re = queue2.removeFirst();
                if(queue2.size()!=0){
                    queue1.addLast(re);
                }
            }
        }
        return re;
    }
    public String push(String str){
        if(queue1.size() ==0 && queue2.size() == 0){
            queue1.addLast(str);
        }
        if(queue1.size()!=0){
            queue1.addLast(str);
        }else if(queue2.size()!=0){
            queue2.addLast(str);
        }
        return str;
    }
    
  2. 【2】用多少个栈实现队列

    class MList<T> {
      // 插入栈,只用于插入的数据
      private Stack<T> stack1 = new Stack<T>(); // 弹出栈,只用于弹出数据
      private Stack<T> stack2 = new Stack<T>();
    
    public MList() {
    }
    
    // 添加操作,入队
    public void appendTail(T t) {
        stack1.add(t);
    }
    
    // 删除操作,出队
    public T deleteHead() {
        // 先判断弹出栈是否为空,如果为空就将插入栈的所有数据弹出栈, // 并且将弹出的数据压入弹出栈中
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.add(stack1.pop());
            }
        }
        // 如果弹出栈中还没有数据就抛出异常
        if (stack2.isEmpty()) {
            throw new RuntimeException("No more element.");
        }
        // 返回弹出栈的栈顶元素,对应的就是队首元素。
        return stack2.pop();
      }
    }
    
  3. 【2】实现多少个栈,能够用常数级时间找出栈中的最小值

  4. 【3】判断栈的压栈、弹栈连串是还是不是合法

递归、动态规划

  1. 股票买入卖出的最佳时刻

     public int maxProfit(int num[]){
       int max=-1;
       int ans=-1;
       for(inti=len-1;i>=0;i--)
         if(num[i]>max)
           max=num[i];
         if(max-num[i]>ans)
           ans=max-num[i];
     return ans;
    }
    
  2. 【2】递归方法求数组的最大值

    int max(int arr[], int len) {
    if (1 == len){ // 只有一个元素
            return arr[0];
    }
    int a = arr[0]; // 第一个元素
    int b = max(arr + 1, len - 1); // 第二个元素起的最大值
    return a > b ? a : b;
    }
    
  3. 【2】背包难点

  4. 【3】一而再子数组的最大和
  5. 【4】达成不难的正则表明式匹配

树、二分

  1. 【2】二个种类,它的方式是12349678,9是峰值,经历了2个提升又下跌的经过,找出当中的最大值的地点O(logN)

    public static int findPeakElement(int [] nums){
      if (nums.length ==1) 
          return 0;
      int low = 0, high = nums.length - 1, mid;
      while (low+1 < high) {
          mid = low + ((high - low) >> 1);
          if (nums[mid] < nums[mid - 1]) 
              high = mid;  //上坡
          else if (nums[mid] < nums[mid+1]) 
              low = mid;   //下坡
          else return mid;
      }
      return nums[low ] >nums[high] ?low:high;
    }
    
  2. 【2】深度优先遍历二叉树,其实正是前序遍历

      public void depthOrderTraversal(){
        if(root==null){
            System.out.println("empty tree");
            return;
        }       
        ArrayDeque<TreeNode> stack=new ArrayDeque<TreeNode>();
        stack.push(root);       
        while(stack.isEmpty()==false){
            TreeNode node=stack.pop();
            System.out.print(node.value+"    ");
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }           
        }
        System.out.print("\n");
    }
    
  3. 【2】二叉树广度优先遍历

    public void levelOrderTraversal(){
    if(root==null){
        System.out.println("empty tree");
        return;
    }
    ArrayDeque<TreeNode> queue=new ArrayDeque<TreeNode>();
    queue.add(root);
    while(queue.isEmpty()==false){
        TreeNode node=queue.remove();  //从队头移除
        System.out.print(node.value+"    ");
        if(node.left!=null){
            queue.add(node.left);
        }
        if(node.right!=null){
            queue.add(node.right);
        }
    }
      System.out.print("\n");
    }
    
  4. 前序遍历二叉树

      public void preOrderTraverse1(TreeNoderoot){
      if(root!=null){
          System.out.print(root.val+"");
          preOrderTraverse1(root.left);
          preOrderTraverse1(root.right);
      }
    }
    //非递归
    public void preOrderTraverse2(TreeNoderoot){
      LinkedList<TreeNode>stack=newLinkedList<>();
      TreeNodepNode=root;
    while(pNode!=null||!stack.isEmpty()){
        if(pNode!=null){
           System.out.print(pNode.val+"");
          stack.push(pNode);
          pNode=pNode.left;
      }else{//pNode==null&&!stack.isEmpty()
          TreeNodenode=stack.pop();
          pNode=node.right;
        }
      }
    }
    
  5. 中序遍历二叉树

    public void inOrderTraverse1(TreeNoderoot){
    if(root!=null){
        inOrderTraverse1(root.left);
        System.out.print(root.val+"");
        inOrderTraverse1(root.right);
      }
    }
    //非递归
    public void inOrderTraverse2(TreeNoderoot){
    LinkedList<TreeNode>stack=newLinkedList<>();
    TreeNodepNode=root;
    while(pNode!=null||!stack.isEmpty()){
        if(pNode!=null){
            stack.push(pNode);
            pNode=pNode.left;
        }else{//pNode==null&&!stack.isEmpty()
            TreeNodenode=stack.pop();
            System.out.print(node.val+"");
            pNode=node.right;
        }
      }
    }
    
  6. 【2】输入一棵二叉树的根结点,求该树的吃水

    public static int treeDepth(BinaryTreeNode root) {
      if (root == null) {
        return 0;
      }
      int left = treeDepth(root.left);
      int right = treeDepth(root.right);
      return left > right ? (left + 1) : (right + 1);
     }
    
  7. 【3】依据中序和后序遍历结果重建二叉树

  8. 【3】依照中序和前序遍历结果重建二叉树

    public static BinaryTreeNode construct(int[] preorder, int ps, int pe,
            int[] inorder, int is, int ie) {
        // 开始位置大于结束位置说明已经没有需要处理的元素了
        if (ps > pe) {
            return null;
        }
        // 取前序遍历的第一个数字,就是当前的根结点
        int value = preorder[ps];
        int index = is;
        // 在中序遍历的数组中找根结点的位置
        while (index <= ie && inorder[index] != value) {
            index++;
        }
        // 如果在整个中序遍历的数组中没有找到,说明输入的参数是不合法的,抛出异常
        if (index > ie) {
            throw new RuntimeException("Invalid input");
        }
        // 创建当前的根结点,并且为结点赋值
        BinaryTreeNode node = new BinaryTreeNode();
        node.value = value;
        // 递归构建当前根结点的左子树,左子树的元素个数:index-is+1个
        // 左子树对应的前序遍历的位置在[ps+1, ps+index-is]
        // 左子树对应的中序遍历的位置在[is, index-1]
        node.left = construct(preorder, ps + 1, ps + index - is, inorder, is,
                index - 1); // 递归构建当前根结点的右子树,右子树的元素个数:ie-index个
        // 右子树对应的前序遍历的位置在[ps+index-is+1, pe]
        // 右子树对应的中序遍历的位置在[index+1, ie]
        node.right = construct(preorder, ps + index - is + 1, pe, inorder,
                index + 1, ie); // 返回创建的根结点
        return node;
    }
    
  9. 【2】翻转二叉树

    public static void mirror(BinaryTreeNode node) { // 如果当前结点不为空则进行操作
      if (node != null) {
      // 下面是交换结点左右两个子树
      BinaryTreeNode tmp = node.left;
      node.left = node.right;
      node.right = tmp;
      // 对结点的左右两个子树进行处理
      mirror(node.left);
      mirror(node.right);
      }
    }
    
  10. 【3】判断某些数组是否二叉树的后序遍历结果 (剑指 offer 第 24 题)

    public static boolean verifySequenceOfBST(int[] sequence, int start, int end) {
        // 如果对应要处理的数据只有一个或者已经没有数据要处理(start>end)就返回true
        if (start >= end) {
            return true;
        }
        // 从左向右找第一个不大于根结点(sequence[end])的元素的位置
        int index = start;
        while (index < end - 1 && sequence[index] < sequence[end]) {
            index++;
        }
        // 执行到此处[end, index-1]的元素都是小于根结点的(sequence[end]) // [end,
        // index-1]可以看作是根结点的左子树
        // right用于记录第一个不小于根结点的元素的位置
        int right = index;
        // 接下来要保证[index, end-1]的所有元素都是大于根根点的【A】
        // 因为[index, end-1]只有成为根结点的右子树
        // 从第一个不小于根结点的元素开始,找第一个不大于根结点的元素
        while (index < end - 1 && sequence[index] > sequence[end]) {
            index++;
        }
        // 如果【A】条件满足,那么一定有index=end-1,
        // 如果不满足那说明根结点的右子树[index, end-1]中有小于等于根结点的元素, // 不符合二叉搜索树的定义,返回false
        if (index != end - 1) {
            return false;
        }
        // 执行到此处说明直到目前为止,还是合法的 // [start, index-1]为根结点左子树的位置
        // [index, end-1]为根结点右子树的位置
        index = right;
        return verifySequenceOfBST(sequence, start, index - 1)
                    && verifySequenceOfBST(sequence, index, end - 1);
    }
    
  11. 【3】二叉树春天为某些值的路子

        public static void findPath(BinaryTreeNode root, int curSum,
        int expectedSum, List<Integer> result) {
        // 如果结点不为空就进行处理
        if (root != null) {
            // 加上当前结点的值
            curSum += root.value;
            // 将当前结点入队
            result.add(root.value);
            // 如果当前结点的值小于期望的和
            if (curSum < expectedSum) {
                // 递归处理左子树
                findPath(root.left, curSum, expectedSum, result);
                // 递归处理右子树
                findPath(root.right, curSum, expectedSum, result);
            }
            // 如果当前和与期望的和相等
            else if (curSum == expectedSum) {
                // 当前结点是叶结点,则输出结果
                if (root.left == null && root.right == null) {
                    System.out.println(result);
                }
            }
            // 移除当前结点,回溯吧
            result.remove(result.size() - 1);
        }
    }
    
  12. 【3*】二叉树中有个别节点的下三个节点 (强烈推荐准备一下,剑指 offer 第58 题)


字符串

  1. 【2】给一串字符串比如abbbcccd,输出a1b3c3d1,O(n)

    public static void main(String[] args) {
        String str= "abbbcccd";
        int[] count= new int[256];
        for (int i = 0 ;i<str.length();i++) {
            count[str.charAt(i)]++;
        }
        for (int i = 0;i<256;i++) {
            if(count[i]>0){
                System.out.printf("%c%d",i,count[i]);
            }
        }
    }
    
  2. 【2】例如输入字符串”I am a student. ”,则输出”student. a am I”

    public static void reverse(char[] data, int start, int end) {
       if (data == null || data.length < 1 || start < 0 || end > data.length
               || start > end) {
           return;
       }
       while (start < end) {
           char tmp = data[start];
           data[start] = data[end];
           data[end] = tmp;
           start++;
           end--;
       }
    }
    
    public static char[] reverseSentence(char[] data) {
       if (data == null || data.length < 1) {
           return data;
       }
       reverse(data, 0, data.length - 1);// 首先全局逆转
       int start = 0;
       int end = 0;
       while (start < data.length) {
           if (data[start] == ' ') { // 排除开头空格
               start++;
               end++;
           } else if (end == data.length || data[end] == ' ') {// 单词结束边界
               reverse(data, start, end - 1);
               end++;
               start = end;
           } else {
               end++;
           }
       }
       return data;
    }
    
  3. 【2】比如输入字符串”abcefg”和数字 2,该函数将回到左旋转 二人获得的结”cdefab”

    public static void reverse(char[] data, int start, int end) {
         if (data == null || data.length < 1 || start < 0 || end > data.length
                 || start > end) {
             return;
         }
         while (start < end) {
             char tmp = data[start];
             data[start] = data[end];
             data[end] = tmp;
             start++;
             end--;
         }
     }
         public static char[] leftRotateString(char[] data, int n) {
         if (data == null || n < 0 || n > data.length) {
             return data;
         }
         reverse(data, 0, data.length - 1);
         reverse(data, 0, data.length - n - 1);
         reverse(data, data.length - n, data.length - 1);
         return data;
     }
    
  4. 【2】java判断是还是不是是回文字符

    public static boolean isPalidrome(Stringstr){
      char[] ch=str.toCharArray();
      int len=ch.length;
      for(inti=0,intj=len-1;i<=j;){
      if(ch[i++]==ch[j--]){
        }else{
          return false;
        }
      }
      return ture;
    }
    
  5. 【3】最长回文子串

  6. 【3】最长无重复子串

  7. 【1*】字符串转数字

  8. 【4】KMP 算法

  9. 【2】字符串全排列

    public static void permutation(char[] chars, int begin) { // 如果是最后一个元素了,就输出排列结果
        if (chars.length - 1 == begin) {
            System.out.print(new String(chars) + " ");
        } else {
            char tmp;
            // 对当前还未处理的字符串进行处理,每个字符都可以作为当前处理位置的元素
            for (int i = begin; i < chars.length; i++) {
                // 下面是交换元素的位置
                tmp = chars[begin];
                chars[begin] = chars[i];
                chars[i] = tmp;
                // 处理下一个位置
                permutation(chars, begin + 1);
                // 恢复
                tmp = chars[begin];
                chars[begin] = chars[i];
                chars[i] = tmp;
            }
        }
    }```
    
  10. 【2*】翻转字符串


位运算

  1. 【2】给二个十进制数字,求它的二进制表示中,有多少个 1 (n &= n – 1)
  2. 【3】给一个数组,全数数字都出现了偶数十二遍,唯有3个冒出了一遍,找出那些数
  3. 【4】给3个数组,全部数字都现身了二次,只有三个油但是生了贰次,找出那个数
  4. 【3】给三个数组,全体数组都出现了偶数十一回,唯有七个数字出现了一回,找出那多少个数

链表

  1. 【2】反转链表(使用递归和迭代二种解法,精晓头插法)

    public static ListNode reverseList(ListNode head) {
       // 创建一个临时结点,当作尾插法的逻辑头结点
       ListNode root = new ListNode();
       // 逻辑头结点点的下一个结点为空
       root.next = null;
       // 用于记录要处理的下一个结点
       ListNode next;
       // 当前处理的结点不为空
       while (head != null) {
           // 记录要处理的下一个结点
           next = head.next;
           // 当前结点的下一个结点指向逻辑头结点的下一个结点
           head.next = root.next;
           // 逻辑头结点的下一个结点指向当前处理的结点
           root.next = head;
           // 上面操作完成了一个结点的头插
           // 当前结点指向下一个要处理的结点
           head = next;
       }
       // 逻辑头结点的下一个结点就是返回后的头结点
       return root.next;
    }
    
  2. 【3】删除链表的如今节点

  3. 【3】删除尾数第 k 个节点

    public static ListNode findKthToTail(ListNode head, int k) 
    { 
      // 输入的链表不能为空,并且k大于0
      if (k < 1 || head == null) {
        return null; 
    }
      // 指向头结点
      ListNode pointer = head;
      // 倒数第k个结点与倒数第一个结点相隔k-1个位置 // pointer先走k-1个位置
      for (int i = 1; i < k; i++) {
        // 说明还有结点
          if (pointer.next != null) {
            pointer = pointer.next; 
          }
        // 已经没有节点了,但是i还没有到达k-1说明k太大,链表中没有那么多的元素 
        else {
        // 返回结果
            return null; }
        }
        // pointer还没有走到链表的末尾,那么pointer和head一起走,
        // 当pointer走到最后一个结点即,pointer.next=null时,head就是倒数第k个结点 
      while (pointer.next != null) {
          head = head.next;
          pointer = pointer.next; 
      }
        // 返回结果
      return head; 
    }
    
  4. 【1】三个静止链表合并

  5. 【2*】判断链表是或不是有环

  6. 【3*】多个链表的首先个集体节点(提示:考虑链表有环的事态)

    public static ListNode findFirstCommonNode(ListNode head1, ListNode head2) {
        int length1 = getListLength(head1); 
        int length2 = getListLength(head2);
        int diff = length1 - length2;
        ListNode longListHead = head1;
        ListNode shortListHead = head2;
        if (diff < 0) {
            longListHead = head2;
            shortListHead = head1;
            diff = length2 - length1;
        }
        for (int i = 0; i < diff; i++) {
            longListHead = longListHead.next;
        }
        while (longListHead != null && shortListHead != null
                && longListHead != shortListHead) {
            longListHead = longListHead.next;
            shortListHead = shortListHead.next;
        }
        // 返回第一个相同的公共结点,如果没有返回null
        return longListHead;
    }
    
    private static int getListLength(ListNode head) {
        int result = 0;
        while (head != null) {
            result++;
            head = head.next;
        }
        return result;
    }
    
  7. 【3】删除链表中重新节点


JAVA相关题

  1. 【2】生产者/消费者(wait() / notify()方法)

    public class Storage {
    // 仓库最大存储量
    private final int MAX_SIZE = 100;
    // 仓库存储的载体
    private LinkedList<Object> list = new LinkedList<Object>();
    
    // 生产num个产品
    public void produce(int num) {
        // 同步代码段
        synchronized (list) {
            // 如果仓库剩余容量不足
            while (list.size() + num > MAX_SIZE) {
                try {
                    list.wait();    // 由于条件不满足,生产阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 生产条件满足情况下,生产num个产品
            for (int i = 1; i <= num; ++i) {
                list.add(new Object());
            }
            list.notifyAll();
        }
    }
    
    // 消费num个产品
    public void consume(int num) {
        // 同步代码段
        synchronized (list) {
            // 如果仓库存储量不足
            while (list.size() < num) {
                try {
                    list.wait();    // 由于条件不满足,消费阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            // 消费条件满足情况下,消费num个产品
            for (int i = 1; i <= num; ++i) {
                list.remove();
            }
            list.notifyAll();
        }
    }
    }
    
  2. 【3】生产者/消费者(await() / signal()方法)

    public class Storage  {  
    // 仓库最大存储量  
    private final int MAX_SIZE = 100;  
    // 仓库存储的载体  
    private LinkedList<Object> list = new LinkedList<Object>();  
    // 锁  
    private final Lock lock = new ReentrantLock();  
    // 仓库满的条件变量  
    private final Condition full = lock.newCondition();  
    // 仓库空的条件变量  
    private final Condition empty = lock.newCondition();  
    
    // 生产num个产品  
    public void produce(int num)      {  
      // 获得锁  
      lock.lock();  
      // 如果仓库剩余容量不足  
      while (list.size() + num > MAX_SIZE)   {  
          try  {  
              full.await();   // 由于条件不满足,生产阻塞  
          }  
          catch (InterruptedException e)  {  
              e.printStackTrace();  
          }  
      }  
    
      // 生产条件满足情况下,生产num个产品  
      for (int i = 1; i <= num; ++i)    {  
          list.add(new Object());  
      }  
    
      // 唤醒其他所有线程  
      full.signalAll();  
      empty.signalAll();  
    
      // 释放锁  
      lock.unlock();  
    }  
    
    // 消费num个产品  
    public void consume(int num)  {  
      // 获得锁  
      lock.lock();  
    
      // 如果仓库存储量不足  
      while (list.size() < num)   {  
          try  {  
              empty.await();  // 由于条件不满足,消费阻塞  
          }  
          catch (InterruptedException e)   {  
              e.printStackTrace();  
          }  
      }  
    
      // 消费条件满足情况下,消费num个产品  
      for (int i = 1; i <= num; ++i)  {  
          list.remove();  
      }  
    
      // 唤醒其他所有线程  
      full.signalAll();  
      empty.signalAll();  
    
      // 释放锁  
      lock.unlock();  
    }  
    }
    
  3. 【2】生产者/消费者(BlockingQueue卡住队列方法)

    public class Storage  
    {  
    // 仓库最大存储量  
    private final int MAX_SIZE = 100;  
    // 仓库存储的载体  
    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(100);  
    
    // 生产num个产品  
    public void produce(int num)  {  
        // 如果仓库剩余容量为0  
        if (list.size() == MAX_SIZE)  {  
            System.out.println("暂时不能执行生产任务!");  
        }  
    
        // 生产条件满足情况下,生产num个产品  
        for (int i = 1; i <= num; ++i)  {  
            try  {  
                // 放入产品,自动阻塞  
                list.put(new Object());  
            }  
            catch (InterruptedException e)  {  
                e.printStackTrace();  
            }   
        }  
    }  
    
    // 消费num个产品  
    public void consume(int num)  
    {  
        // 如果仓库存储量不足  
        if (list.size() == 0)  {  
            System.out.println("暂时不能执行消费任务!");  
        }  
    
        // 消费条件满足情况下,消费num个产品  
        for (int i = 1; i <= num; ++i)  {  
            try  {  
                // 消费产品,自动阻塞  
                list.take();  
            }  
            catch (InterruptedException e)  {  
                e.printStackTrace();  
            }  
        }  
     }  
    } 
    
  4. 【3】观看者设计方式

     public class SimpleObservable extends Observable{    
     private int data = 0;    
     public int getData(){     
       return data;    
    }     
     public void setData(int i){    
       if(this.data != i) {   
          this.data = i;   
          setChanged();    
          //只有在setChange()被调用后,notifyObservers()才会去调用update(),否则什么都不干。  
          notifyObservers();      
       }    
     }    
    } 
    public class SimpleObserver implements Observer{    
     public SimpleObserver(SimpleObservable simpleObservable){    
      simpleObservable.addObserver(this );    
    }        
     public void update(Observable observable ,Object data){  // data为任意对象,用于传递参数  
      System.out.println(“Data has changed to” + (SimpleObservable)observable.getData());    
     }    
    } 
    public class SimpleTest{    
     public static void main(String[] args){    
      SimpleObservable doc = new SimpleObservable ();    
      SimpleObserver view = new SimpleObserver (doc);    
      doc.setData(1);    
      doc.setData(2);    
      doc.setData(2);    
      doc.setData(3);     
       }    
    }   
    

排序

  1. 归并排序、拓展:求数组中的逆序对个数
  2. 敏捷排序 重点:partion 函数的落到实处
  3. 堆排序
  4. 数组成分值域已知时,考虑 基数排序 和 桶排序

目录

1. 栈和队列

1.用七个种类达成栈
2.用七个栈实现队列
3.兑现三个栈,能够用常数级时间找出栈中的最小值
4.判断栈的压栈、弹栈类别是不是合法

2. 链表

1.反转链表(使用递归和迭代两种解法,明白头插法)
2.删除链表的脚下节点
3.剔除尾数第 k 个节点
4.多少个不变链表合并
5.判断链表是不是有环
6.五个链表的率先个集体节点(提醒:考虑链表有环的情况)
7.删除链表中再度节点

3. 树、二分

1.三个队列,它的款型是12349678,9是峰值,经历了三个升起又下落的进度,找出里面包车型客车最大值的地方O(logN)
2.深度优先遍历二叉树
3.广度优先遍历二叉树
4.前序遍历二叉树
5.中序遍历二叉树
6.输入一棵二叉树的根结点,求该树的深浅
7.依据中序和后序遍历结果重建二叉树
8.基于中序和前序遍历结果重建二叉树
9.翻转二叉树
10.判定有个别数组是或不是二叉树的后序遍历结果
11.二叉树大壮为某些值的路径
12.二叉树中有个别节点的下三个节点

4. 递归、动态规划

1.股票买入卖出的特级时间
2.递归方法求数组的最大值
3.背包题材
4.接连子数组的最大和
5.落到实处不难的正则表达式匹配

5.字符串

1.给一串字符串比如abbbcccd,输出a1b3c3d1,O(n)
2.诸如输入字符串”I am a student. ”,则输出”student. a am I”
3.比如输入字符串”abcefg”和数字 2,该函数将回来左旋转 几人获得的结”cdefab”
4.判断是不是是回文字符
5.最长回文子串
6.最长无重复子串
7.字符串转数字
8.KMP 算法
9.字符串全排列
10.翻转字符串

6. 排序

1.归并排序、拓展:求数组中的逆序对个数
2.非常快排序 重点:partion 函数的兑现
3.堆排序
4.数组成分值域已知时,考虑 基数排序 和 桶排序

7. 大数据

1.海量N个数中求前M大个数(选取第M天数)

8. 数组、矩阵

1.回形,矩阵
2.蛇形矩阵
3.在排序数组中寻觅和为给定值的多个数字(思路)

9. 位运算

1.给叁个十进制数字,求它的二进制表示中,有多少个 1 (n &= n – 1)
2.给一个数组,全数数字都冒出了偶数11遍,只有四个出现了1遍,找出那些数
3.给叁个数组,全部数字都冒出了二次,唯有1个出现了1回,找出这一个数
4.给多个数组,全体数组都冒出了偶数十次,唯有七个数字出现了3遍,找出那四个数

10. JAVA相关题

1.生产者/消费者(wait() / notify()方法)
2.生产者/消费者(await() / signal()方法)
3.生产者/消费者(BlockingQueue闭塞队列方法)
4.观望者设计形式

—持续跟新,欢迎纠错—
—【】数字越大标题越难—
— 依据目录Ctrl C.V连忙稳定题解答—

相关文章