算法刷题模板

最新推荐文章于 2023-03-10 16:11:21 发布
最新推荐文章于 2023-03-10 16:11:21 发布
阅读量761 收藏 2
点赞数 1
分类专栏： lintcode 刷题 博客写作入门 安装配置 文章标签： 算法 Java 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014089160/article/details/77715786
版权

BFS和DFS

public void dfs(boolean[][] grid,boolean[][] vis,int i,int j){
//      vis的访问放在最后面
        if(i<0||i>=grid.length||j<0||j>=grid[0].length) return;
        if(grid[i][j]==true&&vis[i][j]==false){
            vis[i][j]=true;
            dfs(grid,vis,i-1,j);
            dfs(grid,vis,i+1,j);
            dfs(grid,vis,i,j-1);
            dfs(grid,vis,i,j+1);
        }
        else return;
    }
    public void bfs(boolean[][] grid,boolean[][] vis,int i,int j){
        Vector<Point> record=new Vector<>();
        int[] delta_x=new int[]{-1,1,0,0};
        int[] delta_y=new int[]{0,0,-1,1};
        record.add(new Point(i, j));
        while(record.size()>0){
            Point p=record.remove(0);
            vis[p.x][p.y]=true;
            for(int index=0;index<4;index++){
                int new_x=p.x+delta_x[index];
                int new_y=p.y+delta_y[index];
                if(new_x>=0&&new_x<grid.length&&new_y>=0&&new_y<grid[0].length&&vis[new_x][new_y]==false&&grid[new_x][new_y]==true){
                    record.add(new Point(new_x,new_y));
                }
            }
        }
    }
    public int numIslands(boolean[][] grid) {
        // Write your code here
        boolean[][] vis=new boolean[grid.length][grid[0].length];
        int cnt=0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j]==true&&vis[i][j]==false){
                    cnt++;
//                  dfs(grid,vis,i,j);
                    bfs(grid,vis,i,j);
                }
            }
        }
        return cnt;
    }

BFS

题目地址：http://www.lintcode.com/problem/binary-tree-level-order-traversal/

public List<List<Integer>> levelOrder(TreeNode root) {
        // write your code here
        List result = new ArrayList();
        if(root== null)
        return result;

        Queue<TreeNode> queue = new LinkedList<TreeNode>();//linkedlist 是queue的子类
        queue.add(root);
        while(!queue.isEmpty()){
            ArrayList<Integer>level = new ArrayList<Integer>();
            int size = queue.size();
            for(int i=0; i< size;i++){
                    TreeNode head = queue.poll();
                    level.add(head.val);
                if(head.left!=null){
                        queue.offer(head.left);
                }
                if (head.right!=null){
                    queue.offer(head.right);
                }
            }
            result.add(level);
        }
        return result;
    }

了解一下递归的写法

问题描述：求解Fibonacci数列的第n个位置的值？指的是这样一个数列：1、1、2、3、5、8、13、21、……

解法1：传统的递归做法，当n比较大的时候比较费时间

public int fib(int index){  
        if(index==1||index==2){  
            return 1;  
        }else{  
            return fib(index-1)+fib(index-2);  
        }  
    }

解法2：在传统的做法上加上了一个记录数组，节省了一定时间

public int fibona(int index,int[] nums){  
        if(nums[index]!=0) return nums[index];
        if(index==1||index==2){  
            nums[index]=1;
            return 1;  
        }else{  
            nums[index]=fib(index-1)+fib(index-2)
            return nums[index];  
        }  
    }

解法3：相当与动态规划的做法，从边界向目标一边记录一边遍历。

public int fibonacci(int index){  
        int a=1,b=1,result=0;
        for(int i=0;i<=index;i++){
            if(i<=2) result=a;
            else{
                result=a+b;
                a=b;
                b=result;
            }
        }
        return result;
    }

对于回溯问题（递归）的通用解法

这个解法可以应用于很多回溯问题，比如Subsets, Permutations, and Combination Sum。

Subsets : https://leetcode.com/problems/subsets/

解法1：把问题分成很多子问题。（推荐这种，因为方便处理后面的subsets II ）

public List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, 0);
    return list;
}

private void backtrack(List<List<Integer>> list , List<Integer> tempList, int [] nums, int start){
    list.add(new ArrayList<>(tempList));
    for(int i = start; i < nums.length; i++){
        tempList.add(nums[i]);
        backtrack(list, tempList, nums, i + 1);
        tempList.remove(tempList.size() - 1);
    }
}

解法2：对于每个数都有放入和不放入两种状态，从左到右遍历数组，枚举每种状态。

public void backstrack2(List<List<Integer>> list,List<Integer> temp,int index,int[] nums){
        if(index==nums.length){
            list.add(new ArrayList<>(temp));
            return;
        }else{
            temp.add(nums[index]);
            backstrack2(list, temp, index+1, nums);
            temp.remove(temp.size()-1);
            backstrack2(list, temp, index+1, nums);
        }
    }
    public List<List<Integer>> subsets(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> list=new ArrayList<>();
        backstrack2(list, new ArrayList<>(), 0, nums);
        return list;
    }

Subsets II (contains duplicates) : https://leetcode.com/problems/subsets-ii/

public List<List<Integer>> subsetsWithDup(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, 0);
    return list;
}

private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums, int start){
    list.add(new ArrayList<>(tempList));
    for(int i = start; i < nums.length; i++){
        if(i > start && nums[i] == nums[i-1]) continue; // skip duplicates
        tempList.add(nums[i]);
        backtrack(list, tempList, nums, i + 1);
        tempList.remove(tempList.size() - 1);
    }
}

Permutations : https://leetcode.com/problems/permutations/

public List<List<Integer>> permute(int[] nums) {
   List<List<Integer>> list = new ArrayList<>();
   // Arrays.sort(nums); // not necessary
   backtrack(list, new ArrayList<>(), nums);
   return list;
}

private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums){
   if(tempList.size() == nums.length){
      list.add(new ArrayList<>(tempList));
   } else{
      for(int i = 0; i < nums.length; i++){ 
         if(tempList.contains(nums[i])) continue; // element already exists, skip
         tempList.add(nums[i]);
         backtrack(list, tempList, nums);
         tempList.remove(tempList.size() - 1);
      }
   }
}

Permutations II (contains duplicates) : https://leetcode.com/problems/permutations-ii/

public List<List<Integer>> permuteUnique(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);//不能忘记这步
    backtrack(list, new ArrayList<>(), nums, new boolean[nums.length]);
    return list;
}

private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums, boolean [] used){
    if(tempList.size() == nums.length){
        list.add(new ArrayList<>(tempList));
    } else{
        for(int i = 0; i < nums.length; i++){
        //如果这个位置已经被访问过
        //两个位置的数如果是一样的，那么只有前面的数用过之后，采用现在这个数，这样就保证了2，2，只有有一种组合
            if(used[i] || i > 0 && nums[i] == nums[i-1] && !used[i - 1]) continue;
            used[i] = true; 
            tempList.add(nums[i]);
            backtrack(list, tempList, nums, used);
            //回溯回来要修改两个地方
            used[i] = false; 
            tempList.remove(tempList.size() - 1);
        }
    }
}

Combination Sum : https://leetcode.com/problems/combination-sum/

public List<List<Integer>> combinationSum(int[] nums, int target) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, target, 0);
    return list;
}

private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums, int remain, int start){
    if(remain < 0) return;
    else if(remain == 0) list.add(new ArrayList<>(tempList));
    else{ 
        for(int i = start; i < nums.length; i++){
            tempList.add(nums[i]);
            backtrack(list, tempList, nums, remain - nums[i], i); // not i + 1 because we can reuse same elements
            tempList.remove(tempList.size() - 1);
        }
    }
}

Combination Sum II (can’t reuse same element) : https://leetcode.com/problems/combination-sum-ii/

public List<List<Integer>> combinationSum2(int[] nums, int target) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, target, 0);
    return list;

}

private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums, int remain, int start){
    if(remain < 0) return;
    else if(remain == 0) list.add(new ArrayList<>(tempList));
    else{
        for(int i = start; i < nums.length; i++){
            if(i > start && nums[i] == nums[i-1]) continue; // skip duplicates
            tempList.add(nums[i]);
            backtrack(list, tempList, nums, remain - nums[i], i + 1);
            tempList.remove(tempList.size() - 1); 
        }
    }
}

Palindrome Partitioning : https://leetcode.com/problems/palindrome-partitioning/

public List<List<String>> partition(String s) {
   List<List<String>> list = new ArrayList<>();
   backtrack(list, new ArrayList<>(), s, 0);
   return list;
}

public void backtrack(List<List<String>> list, List<String> tempList, String s, int start){
   if(start == s.length())
      list.add(new ArrayList<>(tempList));
   else{
      for(int i = start; i < s.length(); i++){
         if(isPalindrome(s, start, i)){
            tempList.add(s.substring(start, i + 1));
            backtrack(list, tempList, s, i + 1);
            tempList.remove(tempList.size() - 1);
         }
      }
   }
}

public boolean isPalindrome(String s, int low, int high){
   while(low < high)
      if(s.charAt(low++) != s.charAt(high--)) return false;
   return true;
}

链表

Reverse Linked List

https://leetcode.com/problems/reverse-linked-list/description/
Your solution

public ListNode reverseList(ListNode head) {
        // write your code here
        ListNode prev =null;
        while(head!=null){
            ListNode temp= head.next;
            head.next = prev;
            prev =head;
            head=temp;
        }
    return prev;
    }

My solution

public ListNode reverseList(ListNode head) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode tail=dummy,next=head;
        ListNode flag=dummy;
        ListNode temp=null;
        while(next!=null){
            temp=next.next;//assign new next in temp
            if(tail.next==next) {
                flag=next;
                next=temp;
                continue;
            }
            next.next=tail.next;
            tail.next=next;//insert
            next=temp;// update next
        }
        flag.next=temp;
        return dummy.next;
    }

Reverse Linked List II

https://leetcode.com/problems/reverse-linked-list-ii/description/

public ListNode reverseBetween(ListNode head, int m, int n) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode tail=dummy;
        while(m>1){
            m--;
            n--;
            tail=tail.next;
        }
        ListNode next=tail.next;
        ListNode flag=tail.next;
        ListNode temp=null;
        while(n>0){
            n--;
            temp=next.next;//store next new node
            if(tail.next==next) {
                flag=next;//store the final tail node
                next=temp;
                continue;
            }
            next.next=tail.next;
            tail.next=next;
            next=temp;
        }
        flag.next=temp;
        return dummy.next;
    }

Reverse Nodes in k-Groups

https://leetcode.com/problems/reverse-nodes-in-k-group/description/
对每k个都标记好head和tail，然后把head后面的元素，一个一个拿下来放到传入到tail的后面

public ListNode reverseKGroup(ListNode head, int k) {
        if(head==null||head.next==null||k<2) return head;
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode prev=dummy,tail=dummy;
        while(true){
            int cnt=k;
            while(cnt!=0&&tail!=null){
                tail=tail.next;
                cnt--;
            }
            if(tail==null) break;
            head=prev.next;

            while(prev.next!=tail){
                ListNode temp=prev.next;//Assign
                prev.next=temp.next;//Delete
                temp.next=tail.next;
                tail.next=temp;//Insert
            }
            prev=head;
            tail=head;
        }
        return dummy.next;
    }

排序

对于链表的排序

http://www.lintcode.com/en/problem/sort-list/
解法1：快速排序

public ListNode part(ListNode head,ListNode tail){
        int key=head.val;
        ListNode slow=head,fast=head.next;
        while(fast!=tail){
            if(fast.val<key){
                slow=slow.next;
                int temp=fast.val;
                fast.val=slow.val;
                slow.val=temp;

            }
            fast=fast.next;
        }
        int temp=head.val;
        head.val=slow.val;
        slow.val=temp;
        return slow;
    }
    public void quick(ListNode head,ListNode tail){
        if(head==tail) return;
        ListNode pivot=part(head, tail);
        quick(head, pivot);
        quick(pivot.next, tail);
    }
    public ListNode sortList(ListNode head) {
        // write your code here
        quick(head, null);
        return head;
    }

解法2：归并排序

public ListNode sortList(ListNode head){
        if(head==null||head.next==null) return head;
        ListNode head1=getMid(head);
        head=sortList(head);
        head1=sortList(head1);
        return merge(head,head1);
    }
    public ListNode getMid(ListNode head){
        ListNode fast=head.next,slow=head.next,prev=head;
        while(fast!=null){
            if(fast==null) break;
            fast=fast.next;
            if(fast==null) break;
            fast=fast.next;
            prev=slow;
            slow=slow.next;
        }
        prev.next=null;//this is very important
        return slow;
    }
    public ListNode merge(ListNode head1,ListNode head2){
        ListNode newNode= new ListNode(-1);
        ListNode tail=newNode;
        while(head1!=null&&head2!=null){
            if(head1.val<=head2.val){
                tail.next=head1;
                head1=head1.next;
            }else{
                tail.next=head2;
                head2=head2.next;
            }
            tail=tail.next;
            tail.next=null;//this is very important
        }
        if(head1!=null) tail.next=head1;
        if(head2!=null) tail.next=head2;
        return newNode.next;
    }
Minininjia
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于java的leetcode刷题与复习指南算法模板代码
03-20
基于java的leetcode刷题与复习指南算法模板代码
常用算法模板——汇总
m0_66689823的博客
10-03 2980
本篇文章主要包含了算法与数据结构的一些常用模板，可适用于算法小白学习，也适用于有一定基础的同学用来复习！！
刷题常用算法模板
li1593891525的博客
02-09 559
刷题常用算法模板
数据结构与算法：408考研算法经典题目大总结（不断更新）
weixin_50690285的博客
08-24 7882
1. 合并两个有序顺序表为一个有序顺序表。2. 删除有序顺序表中所有值重复的元素。3. 顺序表中删除给定值之间的元素。1. 删除线性表中所有值为x的元素。一. 线性表——顺序表部分。
算法刷题知识点总结及相关解题案例
04-14
算法刷题知识点总结，用通俗易懂的文字教你各种算法，并配有简单的算法结题案例，让你少走弯路。 具体包括：二分法、差分法、递归、字典树、动态规划、贪心算法、DFS、BFS等。
算法刷题文档-力扣Java版刷题答案.zip
最新发布
03-22
算法刷题文档通常包含题目描述、输入输出格式、示例输入输出、解题思路、代码实现和注意事项等部分。其中，题目描述会清晰地阐述问题的背景和需求；输入输出格式会说明输入输出的数据类型和格式；示例输入输出则会给...
AlgorithmRecords:我的算法刷题记录和模板
03-10
AlgorithmRecords 我的算法练习。 内容 执照
leetcode刷题模板python-algorithm-pattern-python:算法模式-python
06-30
leetcode刷题模板python Introduction 此项目fork ，原repo用go语言实现，这里准备用python实现，用python的小伙伴可以打卡 算法模板，科学的刷题方式，最快速的刷题路径，让刷题也变得好玩起来, 你值得拥有 :dog_...
算法模板（Java版）——leetcode刷题与复习指南.zip
01-13
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
ACM编程题模板和各种经典算法数据结构实现代码
03-06
ACM编程题模板，其中包含各种算法，来源王道论坛，希望对搞ACM的同学有帮助
海光专用一键刷题模板
03-14
支持自己导入题库进行模拟测试或者答题练习
LeetCode 刷题攻略：配思维导图，100+经典算法题目刷题顺序、经典算法模板-Python开发
05-25
LeetCode 刷题攻略：配思维导图，100+经典算法题目刷题顺序、经典算法模板、共40w字的详细图解，以及难点视频题解。按照刷题攻略上的顺序来刷题，让你在算法学习上不再迷茫！ 目录： 算法面试思维导图 B站算法视频讲解 LeetCode 刷题攻略 算法模板 LeetCode题解 关于作者 算法面试思维导图 B站算法视频讲解 以下为B站「代码随想录」算法讲解视频： 帮你把KMP算法学个通透！（理论篇） 帮你把KMP算法学个通透！（代码篇） 带你学透回溯算法（理论篇） 回溯算法之组合问题（力扣题目：77.组合） 组合问题的剪枝操作（对应力扣题目：77.组合） 组合总和（对应力扣题目：39.组合总和） （持续更新中....） LeetCode 刷题攻略 刷题攻略的背景 很多刚开始刷题的同学都有一个困惑：面对leetcode上近两千道题目，从何刷起。 其实我之前在知乎上回答过这个问题，回答内容大概是按照如下类型来刷数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，
AcWing算法题常用代码模板
Lyf_Ah的博客
11-18 6240
一、基础算法 1、常用代码模板 快速排序算法模板 —— 模板题 AcWing 785. 快速排序 算法步骤： ​ ①确定分界点 ​ ②调整区间 ​ ③递归处理左右两段 Tips： ​ ①如果输入数据量比较大的话，用scanf输入更快，不要使用cin。 ​ ②只要背诵一种万能模板即可避开所有边界问题。 ​ ③考试时一般不会用到快排，面试时喜欢考察。 ​ ④ #include<bits/stdc++.h>包含了目前c++所包含的所有头文件 。 ​ ⑤分治一般用不到，只要掌握快速排序和归并排序就行。
ACM算法模板 · 一些常用的算法模板-模板合集（打比赛专用）
张天枭の博客
11-05 4万+
萌新常用的都在这了，本萌新的模板集。
【LeetCode】刷题模版/套路合集（持续更新）
CherryChenieth的博客
09-06 947
用Java里的优先队列 PriorityQueue的构造器，
【LeetCode】代码模板，刷题必会
热门推荐
负雪明烛
10-02 10万+
目录二分查找排序的写法BFS的写法DFS的写法回溯法树递归迭代前序遍历中序遍历后序遍历构建完全二叉树并查集前缀树图遍历Dijkstra算法Floyd-Warshall算法Bellman-Ford算法最小生成树Kruskal算法Prim算法拓扑排序查找子字符串，双指针模板动态规划状态搜索贪心 本文的目的是收集一些典型的题目，记住其写法，理解其思想，即可做到一通百通。欢迎大家提出宝贵意见！ 二分查找 ...
数据结构算法刷题模板
zhaicheng55的博客
03-10 421
如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值。
基础算法 - 常见算法模板题（最简洁写法）【下】
qq_61386381的博客
08-28 422
双指针 最长连续不重复子序列​编辑 二进制中1的个数 区间和 区间合并
python算法刷题
08-24
当然可以！Python是一种非常适合刷题的编程语言。你可以使用Python来解决...记住，刷题不仅仅是为了解决问题，更重要的是提升你的算法思维和编程能力。多动手实践，多思考优化方案，相信你会不断进步！祝你刷题愉快！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值