算法刷题1

链表：

1.24t:

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

使用递归的方法：

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null){
            return list2;
        }else if(list2 == null){
            return list1;
        }else if(list1.val < list2.val){
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }else {
            list2.next = mergeTwoLists(list1,list2.next);
            return list2;
        }
    }

想到递归的方法每次返回各链表最小的元素并指向下一个。调用自己直到list1 == null || list2 == null;

2.83t：

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode cur = head;
        while(cur.next != null){
            if(cur.val == cur.next.val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return head;
    }
}

只需删除多余部分用给的链表即可，当节点的值与下一个节点的值相同时，跳过相同的一个节点。

3.141t（寻找环）

给你一个链表的头节点 head ，判断链表中是否有环。

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while(slow != fast){
            if(fast == null||fast.next == null){
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}

当我们需要遍历所有元素并且判断是否出现过，想到使用哈希表。//定义两个一个快一个慢，快的移动两次，慢的移动一次如果快的追上慢的则存在环。

4.160t

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
       if(headA == null||headB == null){
        return null;
       }
       ListNode pA = headA, pB = headB;
       while(pA != pB){
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
       }
       return pA;
    }
}

使用两个指针，一个从遍历A开始一个从遍历B开始，遍历后交换遍历，当走到相同的点时此时会同时到达，同时到达的点只有最后和两个相同的节点的开始。

数组：

1.删除有序数组中的重复项。

使用创建hash表的方式

哈希表的创建：注意new时HashMap全大写，为一个类，类的命名首字母大写。注意泛型。

哈希表中查询包含元素方法：名.containsKey(),不要忘记s。

创建一个下标，下标用来改变nums中的元素。当遍历他时出现重复的就跳过，出现不相同的将他付给index下标下，index++实现快慢指针的方法。

2.搜索插入位置（二分法）

创建左右两边下标，在l<=r期间一直循环，同时在其中定义中间下标，每次用来比较nums[mid]与target的值，小于则在右边，将l 赋值为mid+1（比较过中间值mid可跳过），大于则在左边，将r赋值为mid-1.如果存在这个数那么一定在l上，如果不存在那么他的大小的值应该也放在l下标上。返回l。

3.加一

一个数组代表一个数，一个位置代表从高到低的权。给这个数加上一，那么就有可能存在进位。只需要找到第一个不为9的位置加一即可。如果循环完还没返回那么整个数全为9，定义一个长度比原数组大一的数组，第一位放1即可。

3.移除元素（快慢指针）

用快指针faster来比较是否等于val，用slow来记录未删除的数据，以及出现val值后删除这个元素。

4.合并有序数组

1.通过两个指针 复制到新数组中，最后传给nums1。

2.逆向双指针

从后往前遍历，找最大的直接放在nums1中。

5.字母异位词分组

新方法：

字符串中.toCharArray()转化为字符数组

Arrays.sort(数组)。将数组从小到大排序

创建哈希表用于存储排序后的key以及字符串它本身，用数组存放。循环中取出字符串遍历，将它转化为字符数字来排序，之后转化为字符串用于存放。

队列（queue）

1.用队列实现栈。

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<Integer>();
        queue2 = new LinkedList<Integer>();
    }
    
    public void push(int x) {
        queue2.offer(x);
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp;
        temp = queue2;
        queue2 = queue1;
        queue1 = temp;
    }
    
    public int pop() {
        return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

利用两个队列实现栈的出入方式，第一个队列用来接受，第二个用来存储，1队列接受后，将二队列中的元素放入一种，实现刚来的就在头元素，立马可以出，再将一二队列调换位置实现再次接收。

2.使用栈实现队列

class MyQueue {
    Deque<Integer> inStack;
    Deque<Integer> outStack;

    public MyQueue() {
        inStack = new ArrayDeque<Integer>();
        outStack = new ArrayDeque<Integer>();
    }

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.pop();
    }

    public int peek() {
        if(outStack.isEmpty()){
            in2out();
        }
        return outStack.peek();
    }

    public boolean empty() {
        return inStack.isEmpty()&&outStack.isEmpty();
    }

    private void in2out(){
     while(!inStack.isEmpty()){
        outStack.push(inStack.pop());
     }   
    }
}

用Deque来创建栈，使用栈来实现队列的方法，那么将两个栈分开，一个作为输入一个作为输出，当需要输出时那么如果输出的栈不为空则输出即可，为空则将输入的元素全部压入输出栈中，此时最先进的会变为输出栈中最先出的，就能实现先进先出。

3.字符串中第一个唯一字符

注：hash.put(ch,hash.getOrDefault(ch,0)+1;若没有这个则是0，有则在其val的基础上加1。

4.无法吃午餐的学生数量

遍历完后size依然相等则意味着没有人吃，那么直接返回。

5.买票需要的时间

便利数组，比所找元素小的肯定全都会买完，比他大的假设全在他前面那么需要他本身大小的时间，但会有位置在他后面的那么只要依次减去一次即可。

栈（stack）

1.有效的括号

通过哈希表来存储右边的括号，以及左边的括号为Value.遍历字符串，如果哈希表中不包含那么他为左边括号，则进入栈中，包含进行下一步判断。如果栈为空或者栈的头元素不等于哈希表得到的value，此时代表括号类型不一致。因为栈为后进先出与括号的使用原则类似，返回false即可。不满足的话就说明此时括号类型一致，取出栈中括号即可。最后遍历完后返回栈是否为空的判断，如果完成了那么应该是为空 的刚好返回true。同时我们在这之前先判断一下是否为偶数，括号成对使用必须为偶数。

2.下一个更大元素（更大元素用单调栈）

从右到左遍历nums2，同时记录每个元素更大元素的值到HashMap中，使用单调栈快速计算更大元素。

3.棒球比赛（可能使用多个元素，使用数组模拟栈）

注：

for(数据类型 变量名 ： 数组或集合）遍历数组或集合中每一个元素，并取出在“变量名”上。

Integer.parseInt(String s) 将字符串转变为十进制数。（String s,int redix）,redix 代表进制数

4.比较含退格的字符串

1.创建一个方法，用于遍历字符串后还原字符串，接着比较字符串是否相等。利用栈，遇到'#'就出栈一个，注意可能#在最前面，因此需判断此时栈是否为空。最后将栈中的字符串起来返回即可。

2.利用双指针遍历，从后往前。

5.删除最外层的括号

左括号入，右括号出，当栈为空的时候要么准备放（要么准备弹出‘）’，此时为第一个完整的括号，不放在res里面。

6.删除字符串中的所有相邻的重复项。

利用StringBuffer来模拟栈。

StringBuffer与String 区别：

StringBuffer是线程安全的可变的字符串序列；

StringBuffer可以提前给出一个缓冲区，可以进行字符串的拼接，不会开辟新的空间。

热题100：

hash:

1.128.最长连续数列

set:只存在value，当有相同的value时不添加。

将每个数放入哈希表中。遍历数组，当前数num不存在num-1时则进行内部循环判断，存在大一的数则currentStreak+1,longestStreak取currentStreak 与 longestStreak 中最大一方。防止有多个连续数列。最后返回longestStreak即可。

2.283移动零

3.11.盛水最多的容器

双指针，移动短板，有可能让面积变大。但移动长版一定变小。记录下最大面积最后返回。

4.三数之和

先进行排序。后使用双指针，当下标为k的值大于0以后说明不会出现和为0的数则退出。同时当k>0 nums[k] ==nums[k-1]此时为重复的数则跳过。接着内层循环i<j,当和sum小于0则说明移动i 同时跳过重复的i 当sum大于0则移动j 同时跳过重复的元素 。sum等于0则 存入链表中 并且移动i,j 。最终返回res结果链表。

滑动窗口：

1.无重复字符串的最长子串

左指针和右指针代表一个窗口，左指针移动则移除前一个元素，右指针的后面一个元素不重复则放入。

2.找到字符串中所有的字母异位词

利用数组记录字母，出现字母则在响应位置上++，每次有pLen长度的字母数，形成窗口。判定是否相同，若不同则将窗口第一个字母位置--，后新增字母位置++。存在则在链表中加入当前窗口的下标。遍历完成后返回链表。

子串

1.和为K的子数组

利用前缀和的方式去寻找，用hash表记录前缀和。若存在pre-k则说明有子串和为k，count加入其的出现个数。

普通数组

1.最大子数组和

2.合并区间

`Arrays.sort` 是 Java 中的一个方法，用于对数组进行排序。这个方法定义在 `java.util.Arrays` 类中，提供了多种重载版本来满足不同的排序需求。以下是一些常见的用法：

1. **基本类型数组排序**：
   对于原始数据类型（如 int、long、double 等），`Arrays.sort` 提供了直接排序的能力。例如：
   ```java
   int[] array = {5, 3, 9, 1};
   Arrays.sort(array); // 排序后的数组为 {1, 3, 5, 9}
   ```

2. **对象数组排序**：
   当需要对对象数组进行排序时，可以指定一个比较器（Comparator）。比较器是一个实现了 `Comparator` 接口的对象，它定义了排序的逻辑：
   ```java
   Integer[] numbers = {5, 3, 9, 1};
   Arrays.sort(numbers, new Comparator<Integer>() {
       public int compare(Integer a, Integer b) {
           return a.compareTo(b);
       }
   });
   ```

3. **自定义排序**：
   对于自定义对象的数组，可以通过实现 `Comparable` 接口来定义自然排序的规则，或者通过传递 `Comparator` 来定义自定义排序规则：
   ```java
   class Person implements Comparable<Person> {
       String name;
       int age;

       // 自然排序根据年龄
       public int compareTo(Person other) {
           return this.age - other.age;
       }
   }

   Person[] people = ...;
   Arrays.sort(people); // 根据年龄自然排序
   ```

4. **从数组的一部分进行排序**：
   `Arrays.sort` 还可以对数组的一部分进行排序，接受三个参数：数组、开始位置和结束位置（不包括结束位置）：
   ```java
   int[] array = {1, 2, 3, 4, 5};
   Arrays.sort(array, 1, 4); // 只排序从索引1到3的部分，结果为 {1, 2, 3, 4, 5}
   ```

5. **并行排序**：
   `Arrays` 类还提供了一个 `parallelSort` 方法，用于并行排序，适用于大数据量的排序，可以利用多核处理器提高排序效率：
   ```java
   int[] largeArray = ...;
   Arrays.parallelSort(largeArray);
   ```

`Arrays.sort` 方法在内部使用双路快速排序算法（Dual-Pivot Quicksort）对原始数据类型的数组进行排序，对于对象数组，则使用 TimSort 算法（一种优化的归并排序）。这些算法都保证了排序的稳定性和效率。

3.轮转数组

利用翻转。