【算法】算法进阶

最新推荐文章于 2020-08-27 11:36:49 发布
置顶 最新推荐文章于 2020-08-27 11:36:49 发布
阅读量431 收藏 6
点赞数
分类专栏： JAVA基础 Algorithms 基础算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cheidou123/article/details/94009505
版权

文章目录

1.整数

1.1判断一个数是不是回文数
public boolean isPalindrome(int x) {
    if (x<0 || (x!=0 && x%10==0)) return false;
    int rev = 0;
    while (x>rev){
    	rev = rev*10 + x%10;
    	x = x/10;
    }
    return (x==rev || x==rev/10);
}
1.2LeetCode231. Power of Two（判断一个数是不是2的n次幂）
class Solution {
    public boolean isPowerOfTwo(int n) {
        return (n > 0) && ((n & (n-1)) == 0);
    }
}
1.3整数中1出现的次数,即从1到n整数中1出现的次数（剑指Offer）

求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
       int count=0;
       StringBuilder link=new StringBuilder();
       for(int i=0;i<n+1;i++)
           link.append(i);
       String test=link.toString();
       for(int j=0;j<test.length();j++)
           {
           if(test.charAt(j)=='1')    //这里是最需要注意的地方
               count++;
            }
       return count;
       }
}

2.数组

2.1LeetCode27 Remove Element

Given an array and a value, remove all instances of that value in place and return the new length.
Do not allocate extra space for another array, you must do this in place with constant memory.
The order of elements can be changed. It doesn’t matter what you leave beyond the new length.

Example:
Given input array nums = [3,2,2,3], val = 3
Your function should return length = 2, with the first two elements of nums being 2.
解答:


public class Solution {
    public int removeElement(int[] nums, int val) {
        int m=0;
        for(int j=0;j<nums.length;j++){
            if(nums[j]!=val){
                nums[m]=nums[j];
                m++;
       }}
        return m;
    }
}
2.2连续子数组的最大和（剑指Offer）

一个整数数组中的元素有正有负，在该数组中找出一个连续子数组，要求该连续子数组中各元素的和最大，这个连续子数组便被称作最大连续子数组。

public class Solution {  
    public int FindGreatestSumOfSubArray(int[] array) {  
        if(array.length==0)  
            return 0;  
        int temp=array[0];                        
        int sum=array[0];                       //这个sum一定要是array[0]，为了防止数组全是负数  
        for(int i=1;i<array.length;i++)         //注意这个i的起始值是1  
            {  
            if(temp>0)  temp=temp+array[i];     //如果前一段和>0,保留temp  
            else  
            temp=array[i];                      //如果前一段和<0,舍弃temp  
            if(temp>sum)  
            sum=temp;  
            }  
        return sum;  
    }
2.3数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        int match=0;
        int flag=1;
        if(array.length<2)
            return;
        for(int i=0;i<array.length;i++){
            match^=array[i];
        } 
        //如果有两个数字不相同，那么肯定macth有一位是1，然后通过while找到那个1 进行分组！
        while((match&flag)==0) flag<<=1;    //找到那个1
        for(int j=0;j<array.length;j++)
        {
            if((flag&array[j])==0) num1[0]^=array[j];
                else 
                   num2[0]^=array[j];      
        }       
    }
}
2.4LeetCode217 Contains Duplicate(判断数组是否包含重复值)

Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.


public class Solution {  
    public boolean containsDuplicate(int[] nums) {  
        Set<Integer> a=new HashSet<Integer>();  
       for(int i:nums){  
           if(!a.add(i))  
        return true;  
       }  
        return false;  
    }  
}
2.5第一个只出现一次的字符

在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置

import java.util.*;
 
public class Solution {
        public int FirstNotRepeatingChar(String str) {
                Map<Character, Integer> map = new HashMap<Character, Integer>();
        for(int i=0;i<str.length();i++){
            if(map.containsKey(str.charAt(i))){
                int time = map.get(str.charAt(i));
                map.put(str.charAt(i), ++time);
            }
            else {
                map.put(str.charAt(i), 1);
            }
        }
        for(int i=0;i<str.length();i++){
            char c = str.charAt(i);
            if (map.get(c) == 1) {
                return i;
            }
        }
        return -1;
       }
}
2.6Remove Duplicates from Sorted Array

Given a sorted array, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.


Given nums = [1,1,2],
 
Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
It doesn't matter what you leave beyond the new length.

解答:


public int removeDuplicates(int[] nums) {
    int cur = 0 ; 
    for(int n:nums)
        if(n>nums[cur])
            nums[++cur] = n;
    return cur+1;
}
2.7LeetCode238 Product of Array Except Self(数组元素除它自身之外的乘积)

Given an array nums of n integers where n > 1, return an array out such that output[i] is equal to the product of all the elements of nums except nums[i]

Input:  [1,2,3,4]
Output: [24,12,8,6]

Note: Please solve it without division and in O(n).
解题思路：

先遍历数组左边的相乘，然后再乘以右边的。


class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int [] result = new int[n];
        result[0] = 1;
        for (int i = 1; i < n; i++){
            result[i] = result[i -1] * nums[i - 1];   
        }
        int right = 1;
        for (int i = n - 1; i >= 0; i--){   //注意边界
            result[i] = result[i] * right;
            right = right * nums[i];      
        }
        return result;
    }
}

3.链表

3.1倒数第k个节点（剑指Offer）
/* 
public class ListNode { 
    int val; 
    ListNode next = null; 
 
    ListNode(int val) { 
        this.val = val; 
    } 
}*/  
public class Solution {  
    public ListNode FindKthToTail(ListNode head,int k) {     
      if(head==null||k==0)  
          return null;                              //防止链表是空   或者倒数第0个结点  
      ListNode p1=head;                             //倒数越界  
      ListNode p2=head;                               
      int i=1;  
      while(i<k){                                        //从1个节点去第k个节点，就是往前走k-1步  
          if(p1.next==null)                              //主要是防止K大于了链表的长度,p1.next是空，说明将要越界了。  
              return null;  
          p1=p1.next;  
          i++;  
      }  
      while(p1.next!=null){  
          p1=p1.next;  
          p2=p2.next;  
      }  
      return p2;  
      }  
}

这个题的思路是设立两个结点，让第一个先走到k节点，然后两个节点同时往后走，当第一个结点走到最后一个结点时，第二个正好走到倒数第K个节点。

3.2LeetCode83 Remove Duplicates from Sorted List(删除排序链表中的重复元素)

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.

Given 1->1->2->3->3, return 1->2->3.

注意：这里是排序好的！
解答:

/** 
 * Definition for singly-linked list. 
 * public class ListNode { 
 *     int val; 
 *     ListNode next; 
 *     ListNode(int x) { val = x; } 
 * } 
 */  
  
class Solution {  
    public ListNode deleteDuplicates(ListNode head) {  
        if(head==null||head.next==null)  
         return head;                     //     如果链表为空或只有一个节点，返回null或这个节点就可以  
        ListNode temp=head;                        
        while(temp.next!=null){           //     如果当前结点的下一个节点不为空，比较当前结点和下一个结点  
        if(temp.next.val==temp.val)  
            temp.next=temp.next.next;     //     如果当前结点和下一个结点相同，直接将下一个节点改为下下结点  
        else  
            temp=temp.next;               //     如果不同，继续往后  
        }  
        return head;  
    }  
}
3.3LeetCode82 Remove Duplicates from Sorted List II(删除排序链表的重复元素2)

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3

解答:

class Solution {  
    public ListNode deleteDuplicates(ListNode head) {  
            if (head == null) return null;  
      
    if (head.next != null && head.val == head.next.val) {              //如果当前结点和他下一结点相等         
        while (head.next != null && head.val == head.next.val) {         
            head = head.next;                                          //head一直往后  
        }  
        return deleteDuplicates(head.next);                            //把这一段的舍去,然后判断剩下的  
    } else {  
        head.next = deleteDuplicates(head.next);                       //如果不相等保留，从下一个结点继续判断  
    }  
    return head;                                                         
    }  
}
3.4约瑟夫环（程序员面试金典）

约瑟夫问题是一个非常著名的趣题，即由n个人坐成一圈，按顺时针由1开始给他们编号。然后由第一个人开始报数，数到m的人出局。现在需要求的是最后一个出局的人的编号。

给定两个int n和m，代表游戏的人数。请返回最后一个出局的人的编号。保证n和m小于等于1000。

import java.util.*;  
public class Joseph {  
    public int getResult(int n, int m) {  
      
        LinkedList<Integer> test=new LinkedList<Integer>();   //注意链表初始化，别忘了()  
        for (int i=1;i<=n;i++)  
        {test.add(i);}  
        int start=0;  
        while(test.size()>1){                                 //注意链表长度取法  
            int need=(start+m-1)%test.size();  
            test.remove(need);  
            start=need%test.size();  
            }  
            return test.get(0);  
    }  
 }
3.5LeetCode203. Remove Linked List Elements（移除链表元素）
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head != null && head.val == val) {
            head = head.next;
        }
        if(head == null)
            return head;
        ListNode temp = head;
        while(temp.next != null){
            if(temp.next.val == val){
            temp.next = temp.next.next;}
            else{
            temp = temp.next;}
        }
        return head;
    }
}

4.二叉树

4.1LeetCode104 Maximum Depth of Binary Tree(求二叉树的最大深度)
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int maxDepth(TreeNode root) {
       if(root==null) return 0;
       int  left=maxDepth(root.left);
       int  right=maxDepth(root.right);
       return 1+Math.max(left,right);
    }
}
4.2LeetCode111 Minimum Depth of Binary Tree（求二叉树的最小深度）
**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        int left=minDepth(root.left);
        int right=minDepth(root.right);
        return (left==0||right==0)?left+right+1:Math.min(left,right)+1;    
}
}

注意防止斜树

4.3等价二叉树（剑指Offer）
/** 
 * Definition of TreeNode: 
 * public class TreeNode { 
 *     public int val; 
 *     public TreeNode left, right; 
 *     public TreeNode(int val) { 
 *         this.val = val; 
 *         this.left = this.right = null; 
 *     } 
 * } 
 */  
  
  
public class Solution {  
    /* 
     * @param a: the root of binary tree a. 
     * @param b: the root of binary tree b. 
     * @return: true if they are identical, or false. 
     */  
    public boolean isIdentical(TreeNode a, TreeNode b) {  
        // write your code here  
        if(a==null&&b==null)  return true;  
        if(a==null||b==null)  return false;  
        if(a.val==b.val) return isIdentical(a.left,b.left)&&isIdentical(a.right,b.right);  
        else  
        return false;  
          
          
    }  
}
4.4LeetCode404 Sum of Left Leaves（左叶子节点和）
    3
   / \
  9  20
    /  \
   15   7
 
There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum=0;
        if(root==null)                  
            return 0;
        if(root.left!=null)
        {
            if((root.left.left==null)&&(root.left.right==null)){
                sum=sum+root.left.val;
            }else
            sum=sum+sumOfLeftLeaves(root.left);
        }
        sum=sum+sumOfLeftLeaves(root.right);
        return sum;
    }
  }
4.5二叉树中和为某一值的路径（剑指Offer）
import java.util.ArrayList;  
/** 
public class TreeNode { 
    int val = 0; 
    TreeNode left = null; 
    TreeNode right = null; 
 
    public TreeNode(int val) { 
        this.val = val; 
        } 
*/  
public class Solution {  
    private ArrayList<Integer> child=new ArrayList<Integer>();  
    private ArrayList<ArrayList<Integer>> father=new ArrayList<ArrayList<Integer>>();  
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {  
        if(root==null)  
            return father;  
        child.add(root.val);  
        target-=root.val;                                  //通过一个节点就减去这个节点的值  
        if(target==0&&root.left==null&&root.right==null)   //关键1  如果是叶子结点且target已经减到0了  
            father.add(new ArrayList<Integer>(child));     //关键2  注意的是这种写法  
        FindPath(root.left,target);                          
        FindPath(root.right,target);                         
        child.remove(child.size()-1);   //关键3  
        return father;  
    }  
}
4.6树的子结构—判断B是不是A的子结构（剑指Offer）

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/** 
public class TreeNode { 
    int val = 0; 
    TreeNode left = null; 
    TreeNode right = null; 
 
    public TreeNode(int val) { 
        this.val = val; 
 
    } 
 
} 
*/  
public class Solution {  
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {  
       boolean temp=false;     
       if(root1!=null && root2!=null){  
           if(root1.val==root2.val)                         //当遇到结点相等时，开始判断  
              temp=doS(root1,root2);  
           if(!temp){                                      
              temp=HasSubtree(root1.left,root2);            //结点不相等，再判断A树左节点  
           }  
           if(!temp){  
              temp=HasSubtree(root1.right,root2);           //判断A树右节点  
           }  
       }  
      return temp;  
    }  
      
    public boolean doS(TreeNode root1,TreeNode root2)  
    {  
        if(root2==null)                                     //如果B树走完了，说明A树完全包含了B树  
            return true;    
        if(root1==null)                                     //如果A树走完了，B树未走完，说明A树不完全包含B树，记住和上面不能颠倒  
            return false;            
        if(root1.val!=root2.val)                            //判断结点是否相等，不相等返回false  
            return false;  
        return doS(root1.left,root2.left)&&doS(root1.right,root2.right);  //继续判断A树B树左节点，A树B树右节点  
    }  
 }
4.7LeetCode110 Balanced Binary Tree（判断是不是平衡二叉树）

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

/** 
 * Definition for a binary tree node. 
 * public class TreeNode { 
 *     int val; 
 *     TreeNode left; 
 *     TreeNode right; 
 *     TreeNode(int x) { val = x; } 
 * } 
 */  
class Solution {  
    boolean result=true;  
    public boolean isBalanced(TreeNode root) {  
        TestIsBalanced(root);  
        return result;  
    }  
    public int TestIsBalanced(TreeNode root){  
        if(root==null)  
            return 0;  
        int l=TestIsBalanced(root.left);  
        int r=TestIsBalanced(root.right);  
        if(Math.abs(l-r)>1)              //注意绝对值用法  
             result=false;               //注意这里没有return  
        return 1+Math.max(l,r);  
        }  
}
4.8求二叉树的最大宽度
public static int getMaxWidth(TreeNode root) {  
        if (root == null)  
            return 0;  
  
        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();  
        int maxWitdth = 1; // 最大宽度  
        queue.add(root); // 入队  
  
        while (true) {  
            int len = queue.size(); // 当前层的节点个数  
            if (len == 0)  
                break;  
            while (len > 0) {// 如果当前层，还有节点  
                TreeNode t = queue.poll();  
                len--;  
                if (t.left != null)  
                    queue.add(t.left); // 下一层节点入队  
                if (t.right != null)  
                    queue.add(t.right);// 下一层节点入队  
            }  
            maxWitdth = Math.max(maxWitdth, queue.size());  
        }  
        return maxWitdth;  
}
4.9二叉树的所有路径

Given a binary tree, return all root-to-leaf paths.For example, given the following binary tree:

   1
 /   \
2     3
 \
  5

["1->2->5", "1->3"]

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
       List<String> test=new ArrayList<String>();   //数组是对象，引用传递
       if(root!=null) searchBT(root,"",test);
       return test;
    }
    public void searchBT(TreeNode root,String path,List<String> test)
    {
        if((root.left==null)&&(root.right==null)) test.add(path+root.val);//注意r：string+int就是string了 
        if(root.left!=null)  searchBT(root.left,path+root.val+"->",test);
        if(root.right!=null) searchBT(root.right,path+root.val+"->",test);    
    }
}

5.综合算法

5.1矩形覆盖（剑指Offer）

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

public class Solution {
    public int RectCover(int target) {
       if(target==1||target==0)
           return target;
       else if(target==2)
            return 2;
       else 
       return RectCover(target-1)+RectCover(target-2);
    }
}
5.2Leetcode121 Best Time to Buy and Sell Stock(买卖股票的最佳时机1)

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
例子:

Input: [7, 1, 5, 3, 6, 4]
Output: 5
max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)

Input: [7, 6, 4, 3, 1]
Output: 0
In this case, no transaction is done, i.e. max profit = 0.

解答:

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length==0)
            return 0;
        int min=prices[0];              //先把第一个值设为最小值
        int profit=0;                     
        for(int i=0;i<prices.length;i++)
        {
            if(prices[i]<min)          //如果当前值小于最小值（买入点），把最小值改为当前值
                min=prices[i];
            if(prices[i]-min>profit)   //如果利润大于以前的利润，则把最大利润换成当前情况的
                profit=prices[i]-min;
        }
        return profit;
      }
}
菜丸子
关注
专栏目录
进阶算法04
神秘的火柴人的专栏
06-23 238
无后效性问题： 不管通过什么方式到达某个状态，其返回值都一样。 1. 换钱的方法数 暴力递归 以arr = [5, 10, 25, 1]，aim = 15为例： 节点中的内容表示： 从下标为[i~j]的数组中取任意张，可以换到aim的方法数 class Solution{ public: int coins(int *arr, int len, int aim)...
进阶算法——树形DP
weixin_30307921的博客
08-30 322
特点（特别之处） DP这种东西…跟玄学一样…除非讲题，不然是真的没啥东西总结… 通过少量局部不完全不具代表性的刷题得出… 树形DP一般是在递归环境进行的，并且是先递到底 树形DP的第一维状态往往是以i为节点的子树。 题目中的ShowTime 因为动态规划的恐怖之处…所以还是多通过题目感受吧… 选课 首先很容易看出来，这题的数据是二叉树。 对于某一个非根...
进阶的排序算法（比较类+非比较类）
sk_tsuki的博客
06-15 1002
比较类排序 1. 快速排序 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。  1、特征：      平均时间复杂度：O(nlogn)      最坏时间复杂度：O(n²)      最好时间复杂度：O(nlogn)      空间复杂度：O(nlogn)      稳定性：不稳定  2、算法描述：    ①从数列中挑出一个元素，称为 “基准”；    ②重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素
进阶优化算法
JRRG的博客
10-30 1109
本文主要讨论在优化模型求解中用到的高级优化算法，这些算法基于常见的优化算法思想，采用一些非常巧妙的技巧，而使得算法到达更快的收敛等特点。这些高级优化算法也只限定于特定的模型求解，下面将对其进行简单总结。
算法进阶之路
北邮Renyi的博客
05-29 660
算法进阶之路 ## **自我介绍** 楼主北邮计算机渣硕，目前混迹于鹅厂，方向服务器端开发 ## **为什么要搞这个算法专栏？** 前天组内分享的时候，老大一句话让我受益颇深，他说不管在哪，都要记得提升自己的技术影响力。 首先对于一个程序员来说，算法思想必不可少，不管到哪面试都会被问算法。白板编程是程序员的功底。 既然我会时常温习算法，我为什么不展示出来，帮助更多升学求职的...
Scratch编程入门与算法进阶.pptx
10-12
"Scratch编程入门与算法进阶" 《Scratch编程入门与算法进阶》是一本面向青少年和初学者的Scratch编程和算法教育书籍，本书以图文并茂的方式，系统地介绍了Scratch编程的基础知识和常用算法，旨在帮助读者深入理解...
Python编程入门与算法进阶.pptx
10-13
"Python编程入门与算法进阶.pptx" Python编程入门与算法进阶是一本全面介绍Python编程语言和算法的书籍。本书分为两个部分，第一部分是Python编程入门，第二部分是算法进阶。 在Python编程入门部分，本书详细讲解...
Scratch编程入门与算法进阶.docx
09-13
Scratch 编程入门与算法进阶 Scratch 是一款为青少年设计的编程语言和平台，由麻省理工学院的媒体实验室（Media Lab）和哈佛大学的实验室（Graduate School of Education）联合开发。Scratch 的起源与发展可以追溯...
漫画算法2：小灰的算法进阶.pptx
最新发布
10-13
漫画算法2：小灰的算法进阶 《漫画算法2：小灰的算法进阶》是一本以漫画形式生动展现算法进阶知识的图书。本书以小灰的视角，通过一系列有趣的场景和生动的漫画，深入浅出地讲解了算法的高级概念和技术，包括图算法...
算法竞赛入门到进阶 课件+源码
06-17
《算法竞赛入门到进阶 课件+源码》这套资源是为想要在算法竞赛中提升自己能力的初学者和进阶者准备的宝贵资料。它涵盖了从基础到高级的各种算法，通过课件和源码的结合，使学习者能够理论与实践相结合，更好地理解和...
算法学习之--进阶排序算法（时间复杂度O(nlogn)）
j_oop的博客
06-13 831
1.归并排序 基本思想：不断的将数据进行二分（逻辑上的二分，即将数组元素索引分块，并不是真的把数组内存进行二分），当二分到只有一个数组元素时开始归并，数组的每一个元素由其二分后数组的两个元素进行比较确定： 首先进行二分： 二分到第三层数组中仅有一个元素（即数组有序），然后开始向上进行归并：第二层左边的数组 [ 0 ] 位置元素由其二分后数组元素比较得出，显然应该是3，那么 [ 1 ]位置就是6，同理第二层右边数组归并后是1，4。再次向上归并，第一层数组[0]位置由其二分数组【3，6】【1，4..
进阶算法：动态规划 (笔记)
Nnnn的博客
08-27 213
很久以前考过计算机软考中级，看过推荐教材里的算法篇章。少有应用渐渐忘切，直到最近刷题重遇该问题。在多变的应用中，灵活运用是关键。 动态规划是跟递归关联的，着重于计算重叠子问题的最优解的算法。因此，简单来说，动态规划的应用条件为： 1）最优子结构 如果一个问题包含最优子问题，那么最优解则在该问题中。 2）重叠子问题。 在计算过程中，不断计算重复的子问题。此时，仅需在首次遇到该问题时，保存求解的结果，下一次重新计算该问题时，直接读取问题解即可。 经典的案例 – “背包问题”1： 假设一个背包的最大承重为W，现有
左 . 进阶算法---KMP算法
多多
06-14 1381
KMP算法：常规想法：一个个匹配   时间复杂度太高总结： 我们发现 每次匹配前面的并没有给后面一些指导信息Note:   子串 和子序列不一样 前者是连续的 后者可以是不连续的   注意区分...
算法的进阶修炼
u011707861的博客
03-21 562
一、算法最最基础 1、时间复杂度 2、空间复杂度 一般最先接触的就是时间复杂度和空间复杂度的学习了，这两个概念以及如何计算，是必须学的，也是必须最先学的，主要有最大复杂度、平均复杂度等，直接通过博客搜索学习即可。 文章推荐： 算法分析神器—时间复杂度 二、基础数据结构 1、线性表 列表（必学） 链表（必学） 跳跃表（知道原理，应用，最后自己实现一遍） 并查集（建议结合刷...
FFC：进阶算法题
凝弧
05-31 728
1. Sum All Numbers in a Range 2. Diff Two Arrays 3. Roman Numeral Converter 4. Where art thou 5. Search and Replace 6. Pig Latin 7. DNA Pairing 8. Missing letters 9. Boo who 10. Sorted Union 11. Con...
进阶算法02
神秘的火柴人的专栏
04-18 160
文章目录1. 窗口2. 单调栈 1. 窗口 例1： /** *@ w：窗口大小 *@ return：每个窗口中最大值组成的数组 */ int *getMaxWindow(int *arr, int len, int w) { deque<int> dqMax; //dqMax存放数组下标 int *ret = new int[len - w + 1]; ...
算法进阶3-2
浅简
11-25 344
题目一： 设计可以变更的缓存结构。 【题目】         设计一种缓存结构，该结构在构造时确定大小，假设大小为K，并有两个功能：                 （1）set(key, value)：将记录(key, value)插入该结构。                 （2）get(key)：返回key对应的value值。 【要求】         （1）set和get方法
十大经典排序算法（动图演示）
09-21 1901
0.1 算法分类比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。0.2 算法复杂度0.3 相关概念稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。时间复杂度：对排序数据的总的操作次数。
算法进阶3-3
浅简
11-25 281
题目一： 统计完全二叉树的节点个数（二分思路）。 题目二： 找到被指的新类型字符 【题目】 新类型字符的定义如下：         1．新类型字符是长度为1或者2的字符串。         2．表现形式可以仅是小写字母，例如，"e"；也可以是大写字母+小写字母，例如，"Ab"；还可以是大写字母+大写字母，例如，"DC"。 现在给定一个字符串str，str一定是若干新
Python算法进阶指南
书中涵盖了从基础到进阶的各种算法，包括排序、搜索、图论以及动态规划等核心主题。 1. **排序算法**：书中有详尽的介绍，如冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。这些算法不仅有助于理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值