算法题总结

记住每个数据结构有哪些属性，面向对象。数据结构原理都是数组和链表。
实现过程：0.选好例子或者大量例子，代入法1定义变量和指针2.考虑循环的开始结束3.考虑分不同情况，分解出递推公式或者画图像推理。翻译对象，积累图像和对应的实现控制。
1.审题边画好图，标记好图中特殊变量和各种容器图
（用于遍历和接受结果，map、数组、栈、链表、树的图像；定义题中特殊对象为变量，如最小值，要细化多new，不然会分不清，以及扫描指针（i，node）标志性的数组、链表图。）
map+链表；链表+数组（动态改变大小，大小可以控制），队列+栈（倒序）
2.直接代入第一种成功情况的具体数据去一步步推算画图，把每一步写成代码，保证这种图推算能成功；再想出第n种情况去跑，加代码，最后考虑失败情况，代码就会完美。
把题目中的操作、动作转化为代码（转换为相邻相减小于m）。 维护指针等等。题目里面定义好的m和输入描述对应上，通过例子来读懂思路。
有序：必用折半法（不能用链表，只能顺序表）
倒序：用递归或者栈,链表的话用 头插法。
递归：递归调用就相当于扫描，结束条件就是扫描的结束条件，处理过程相当于扫描的循环体。
对称：用栈和链表结合，一个当扫描容器一个操作，必须考虑总数的奇偶的情况，可以直接用数组和一个指针来构建，也可以直接用包装好的类
时间最优：牺牲空间，顺序表作为辅助空间的优点就是不用遍历，能一次就取出值，时间为0。
两链表比大小：就用常规指针扫描比较。链表删除找前驱节点。
指针：越多越方便,多定义
图：遍历可用迭代和容器，深度遍历的辅助容器是栈，广度遍历的辅助容器是队列。
对应关系用map，倒序用栈，顺序用队列数组链表都一样。要把集合工具用熟练，很多题是直接用工具，不用实现。
菜鸟教程集合
java实现八大排序算法

例一：

括号配对：直接用stack，pop、add等方法要清楚 ，s.toCharArray();等方法。因为栈是用数组或者链表实现的，所以只能直接用，不能现场重新创建。
class Solution {
	public boolean isValid(String s) {
		if (s.length() < 2) {
			return false;
		}
		char[] chars = s.toCharArray();
		Stack<Character> stack = new Stack<>();
		for (int i = 0; i < chars.length; i++) {
			if (chars[i] == '(' || chars[i] == '[' || chars[i] == '{') {
				stack.add(chars[i]);
			} else {
				if (stack.isEmpty())
					return false;
				char c = stack.pop();
				if ((chars[i] == ')' && c != '(') || (chars[i] == ']' && c != '[') || (chars[i] == '}' && c != '{'))
					return false;
			}
		}
		return stack.isEmpty();//by huangbo1221
	}
}

 

例二：


借助小栗子理解题目的定义，尤其定义很多的时候。先在脑海里有了解决问题的策略和思路，理论上能实现。

易错代码：

package com.prig.base.controller;

import java.util.Scanner;

//简单的统计问题，喜好值用数组fav装起来，例子用map装起来，结果用数组装起来
class Main {
    public  static void  main(String[] args){
        Scanner s=new Scanner(System.in);
//用户个数
        int people_num=s.nextInt();
        int[] fav=new int[people_num];
//喜好
        for(int i=0;i<people_num;i++){
            fav[i]=s.nextInt();
        }
//测试例子
        System.out.println("输入测试例子数");
        int examp_num=s.nextInt();
        int[][] examp=new int[examp_num][3];
        for(int i=0;i<examp_num;i++){
            for(int j=0;j<3;j++){
                examp[i][j]=s.nextInt();
            }
        }
//查询结果
        int[] result=new int[3];
        for(int i=0;i<examp_num;i++){
            int count=0;
            for(int m=fav[examp[i][0]-1];m<fav[examp[i][1]-1];m++){//少1
                if(examp[i][2]==(fav[m])){
                    count++;
                }
            }
            result[i]=count;
        }
        //输出
        for(int i=0;i<examp_num;i++){
            System.out.println(result[i]);
        }
    }
}

改正代码：
细化定义，一边遍历一边操作

package com.prig.base.controller;

import java.util.*;

public class test {//没括号
    public static void main(String [] args) {//背
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] fav = new int[n];
        //输入喜好
        for (int i = 0; i < n; i++) {
            fav[i] = scan.nextInt();
        }
        Map<Integer, List<Integer>> map = new HashMap<>();
                //改变喜好的数据结构，对应关系用map
        for (int i = 0; i < n; i++) {
            int key = fav[i];//喜好值
            int value = i + 1;//用户编号
            if (!map.containsKey(key)) {
                List<Integer> list = new LinkedList<>();
                list.add(value);
                map.put(key, list);
            } else {
                List<Integer> list = map.get(key);
                list.add(value);
            }
        }
        int m = scan.nextInt();
        //输入例子，一边输入，一边比较
        Queue<Integer> queue = new LinkedList<>();//队列保存结果
        for (int i = 0; i < m; i++) {
            int lo = scan.nextInt();//细化定义
            int hi = scan.nextInt();
            int des = scan.nextInt();
            List<Integer> list = map.get(des);
            int count = 0;
            if (list != null) {
                for (Integer integer : list) {
                    if (integer >= lo && integer <= hi) {
                        count++;
                    }
                }
            }

            queue.add(count);

        }
        for (Integer integer : queue) {
            System.out.println(integer);
        }

    }
}

修改Bug后的代码：用数组实现，双重循环

package com.prig.base.controller;

import java.util.ArrayList;
import java.util.Scanner;

//简单的统计问题，喜好值用数组fav装起来，例子用map装起来，结果用数组装起来
class Main {
    public  static void  main(String[] args){
        Scanner s=new Scanner(System.in);
//用户个数
        int people_num=s.nextInt();
        int[] fav=new int[people_num];
//喜好
        for(int i=0;i<people_num;i++){
            fav[i]=s.nextInt();
        }
//测试例子
        System.out.println("输入测试例子数");
        //Arraylist list=new Arraylist
        int examp_num=s.nextInt();
        int[] result=new int[people_num];
        for(int i=0;i<examp_num;i++){//一边遍历一边操作，定义细化
                int la=s.nextInt();//用户上限
                int lb=s.nextInt();//用户下限
                int lc=s.nextInt();//用户值
                int count=0;
                for(int m=la-1;m<lb-1;m++){//少1，分清楚概念m代表用户编号，搞清楚每个概念
                    if(lc==(fav[m])){
                        count++;
                    }
                }
                result[i]=count;
        }

        //输出
        for(int i=0;i<examp_num;i++){
            System.out.println(result[i]);
        }
    }
}

例三：题目里面定义好的m和输入描述对应上，通过例子来读懂思路。

思路：颜色为key，map保存对应颜色在第几个里面，相邻则不符合，转换为相邻相减小于m。map+list（为value）实现。

package com.prig.base.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
class BraceletsTest {
    public static void main(String [] args) {
        // 首先输入和定义
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();    //n个串珠
        int m = sc.nextInt();    //手串上的任意一种颜色（不包含无色），在任意连续的m个串珠里至多出现一次
        int c = sc.nextInt();    //颜色一共有c种
        int count = 0;
        Map<Integer,List<Integer>> map = new HashMap<>();
        for(int i=0;i < n;i++) {
            int num = sc.nextInt();//输入颜色数，转化成循环
            for(int j=0;j < num;j++) {//输入各种颜色
                int key = sc.nextInt();
                if(!map.containsKey(key)) {
                    List<Integer> list = new ArrayList<>();
                    list.add(i);
                    map.put(key, list);
                }
                else {
                    List<Integer> list = map.get(key);
                    list.add(i);
                }
            }
        }
        for(int i=1;i <= c;i++) {
            boolean flag = false;
            List<Integer> list = map.get(i);
            if(list.size() == 1) {
                continue;
            }
            else {
                for(int j=0;j < list.size()-1;j++) {
                    if(list.get(j+1) - list.get(j) < m) {//关键判断句
                        count++;
                        flag = true;
                        break;
                    }
                }
                if(!flag) {
                    if((n-list.get(list.size()-1)+list.get(0)) < m){
                        count++;
                    }
                }
            }
        }

        System.out.println(count);
    }

}

例四：

思路：随便加一个数字使得够数，1选雀头，多种情况的雀头2.去掉雀头，因为有顺序，不是刻子就当成顺子，三个三个去掉看最后返回的是不是0。经常删除所以用arraylist.一定要把现有的工具都用熟，并且能实现它。

例五：
如果规则太麻烦就自己制定一个规则。
math.max方法

例六：有多种对应关系必须用map，map优势在于索引可以自己定义，而其他容器的索引必须是数字，多借助工具类的方法。

问题：给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

https://leetcode-cn.com/problems/majority-element/


/**
 * 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
 *
 * 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
 *
 * 1. Map大法好，遍历直接存储出现的次数，找到最大的即可
 * 2. 使用单个变量来记录，剩下的一定是"多数"的元素
 *   （从第一个数开始count=1，遇到相同的就加1，遇到不同的就减1，减到0就重新换个数开始计数，总能找到最多的那个）
 */
public class LeetCode169 {
    public int majorityElement(int[] nums) {
        HashMap<Integer, Integer> keyVal = new HashMap<>();
        for (int num : nums) {
            if (keyVal.containsKey(num)) {
                keyVal.put(num, keyVal.get(num) + 1);
            } else {
                keyVal.put(num, 1);
            }
        }
        int max = Integer.MIN_VALUE;
        int key = 0;
        for (Map.Entry<Integer, Integer> entry : keyVal.entrySet()) {
            if (entry.getValue() > max) {
                max = entry.getValue();
                key = entry.getKey();
            }
        }
        return key;
    }


//    public int majorityElement(int[] nums) {
//        int cand_num = nums[0];
//        int count = 1;
//        for (int i = 1; i < nums.length; ++i) {
//            if (cand_num == nums[i]){
//                ++count;
//            } else if (--count == 0) {
//                cand_num = nums[i];
//                count = 1;
//            }
//        }
//        return cand_num;
//    }

}

例7：迭代

问题：翻转一棵二叉树。

https://leetcode-cn.com/problems/invert-binary-tree/

/**
 * 反转二叉树
 */
public class LeetCode226 {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);

        root.left = right;
        root.right = left;
        return root;
    }

}