一些代码模版

代码模版

二叉搜索树转双向链表

利用非递归的中序遍历

public Node treeToDoublyList(Node root) {
        if(root==null)return root;
        Stack<Node> sta=new Stack<>();
        Node cur=root;
        Node pre=null;
        Node head=null;
        while(cur!=null||!sta.isEmpty()){
            //左孩子节点全部入栈；
            while(cur!=null){
                sta.push(cur);
                cur=cur.left;
            }
            cur=sta.pop();
            if(pre==null){
                head=cur;
                pre=cur;
            }else{
                pre.right=cur;
                cur.left=pre;
                pre=cur;
            }
            //对右孩子执行相同对操作，这里不能判断有右孩子了再指向右孩子，这样程序会死循环；
            cur=cur.right;
        }
        pre.right=head;
        head.left=pre;
        return head;
    }

下一个排列

实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须 原地 修改，只允许使用额外常数空间。

例如：[1,2,3]->[1,3,2]；[3,2,1]->[1,2,3]
如何寻找下一个排列：记数组为nums，从后往前找，找到第一个比前一个大的数，记为i，i-1；寻找len～i中第一个比nums[i-1]大的数，与nums[i-1]交换后，再将nums[i~len-1]安从小到大排序，得到的数为下一个排列；如果找不到符合的i，则该数为从大到小排序的数组，下一个排列就是将该数组从小到大排列后的数组。

class Solution {
    public void nextPermutation(int[] nums) {
        int len=nums.length;
        for(int i=len-1;i>0;i--){
            if(nums[i]>nums[i-1]){
                for(int j=len-1;j>=i;j--){
                    if(nums[j]>nums[i-1]){
                        int tmp=nums[j];
                        nums[j]=nums[i-1];
                        nums[i-1]=tmp;
                        Arrays.sort(nums,i,len);
                        return;
                    }
                }
            }
        }
        Arrays.sort(nums);
        return;
    }
}

快排

public class QuickSort {
    public void partition(int l,int r,int[] arr){
        if(l>=r) return;
        int tmp=arr[l];
        int i=l,j=r;
        while(i<j){
            //快排要防止下标越界while循环中要加入限制；
            while (j>i&&arr[j]>tmp)j--;
            arr[i]=arr[j];
            while(j>i&&arr[i]<=tmp)i++;
            arr[j]=arr[i];
        }
        arr[i]=tmp;
        partition(l,i-1,arr);
        partition(i+1,r,arr);
    }
    public void sort(int[] arr){
        int len=arr.length;
        partition(0,len-1,arr);
    }

    public static void main(String[] args) {
        QuickSort quickSort = new QuickSort();
        int[] arr={1,3,1,3,4,23,12,-1,34,-34};
        quickSort.sort(arr);
        for (int a: arr){
            System.out.printf("%d ",a);
        }
        System.out.println();
    }
}

PriorityQueue

大顶堆

private static final int DEFAULT_INITIAL_CAPACITY = 11;
PriorityQueue<Integer> maxHeap=new PriorityQueue<Integer>(DEFAULT_INITIAL_CAPACITY, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {                
            return o2-o1;
        }
    });
    // 或者new PriorityQueue<>((x, y) -> (y - x)); 

滑动窗口代码模版

def findSubArray(nums):
    N = len(nums) # 数组/字符串长度
    left, right = 0, 0 # 双指针，表示当前遍历的区间[left, right]，闭区间
    sums = 0 # 用于统计 子数组/子区间 是否有效，根据题目可能会改成求和/计数
    res = 0 # 保存最大的满足题目要求的 子数组/子串 长度
    while right < N: # 当右边的指针没有搜索到 数组/字符串 的结尾
        sums += nums[right] # 增加当前右边指针的数字/字符的求和/计数
        while 区间[left, right]不符合题意：# 此时需要一直移动左指针，直至找到一个符合题意的区间
            sums -= nums[left] # 移动左指针前需要从counter中减少left位置字符的求和/计数
            left += 1 # 真正的移动左指针，注意不能跟上面一行代码写反
        # 到 while 结束时，我们找到了一个符合题意要求的 子数组/子串
        res = max(res, right - left + 1) # 需要更新结果
        right += 1 # 移动右指针，去探索新的区间
    return res

滑动窗口中用到了左右两个指针，它们移动的思路是：以右指针作为驱动，拖着左指针向前走。右指针每次只移动一步，而左指针在内部 while 循环中每次可能移动多步。右指针是主动前移，探索未知的新区域；左指针是被迫移动，负责寻找满足题意的区间。