数据结构笔记

1. min/max heap

看到K神马的基本上就是min/max heap.

（1） Find the K closest points to the origin in a 2D plane, given an array containing N points.

    public static List<Point> findKClosest(Point[] p, int k) {
        
        List<Point> res = new ArrayList<Point>();
        Comparator<Point> comparator = new Comparator<Point>(){
            //@Override
            public int compare(Point a, Point b) {
                return (int) ( a.x*a.x + a.y*a.y- b.x*b.x -b.y*b.y);
            }
        };
                
        PriorityQueue<Point> minheap = new PriorityQueue<Point>(comparator);
        for (Point temp : p) {
            minheap.add(temp);
        }
        for (int i = 0; i < k; i++) {
            res.add(minheap.poll());
        }
    
        return res;
    }

如果只能用k个位置保留在有线队列里面的话，那么前k个可以直接加入，后面k个的话，如果比最后一个小，那么把最后1个移除，然后放入当前的点.

public List<Point> findKClosest(Point[] p, int k) {  
    PriorityQueue<Point> pq = new PriorityQueue<>(10, new Comparator<Point>() {  
        @Override  
        public int compare(Point a, Point b) {  
            return (b.x * b.x + b.y * b.y) - (a.x * a.x + a.y * a.y);  
        }  
    });  
       
    for (int i = 0; i < p.length; i++) {  
        if (i < k)  
            pq.offer(p[i]);  
        else {  
            Point tmp = pq.peek();  
            if ((p[i].x * p[i].x + p[i].y * p[i].y) - (tmp.x * tmp.x + tmp.y * tmp.y) < 0) {  
                pq.poll();  
                pq.offer(p[i]);  
            }  
        }  
    }  
       
    List<Point> x = new ArrayList<>();  
    while (!pq.isEmpty())  
        x.add(pq.poll());  
       
    return x;  
}  

 

------------------------我是分割线----------------------------------------

 

 2. 队列 queue

支持操作 o(1) push, o(1) pop, o(1) top

BFS的主要数据结构 多做做bfs题就好了

 

 

 

 

 

 

 

------------------------我是分割线----------------------------------------

 

 3. 栈 stack

支持操作 o(1) push, o(1) pop, o(1) top

非递归实现dfs的重要数据结构

 (1) min stack

public class MinStack {

    /** initialize your data structure here. */
    static Stack<Integer> numStack; 
    static Stack<Integer> minStack;

    public MinStack() {
        numStack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }
    
    public void push(int x) {
        numStack.push(x);
        if (minStack.empty() || x <= minStack.peek()) {
            minStack.push(x);
        }
    }
    
    public void pop() {
        if (numStack.peek().equals(minStack.peek())) {
            //note!!! because Stack contains integer which is an object, is use == will test its pointer!!!
            minStack.pop();
            numStack.pop();

        } else {
            numStack.pop();
        }
    }
    
    public int top() {
        return numStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

(2) implement queue by two stack

class MyQueue {
    private Stack<Integer> stack1 = new Stack<Integer>();
    private Stack<Integer> stack2 = new Stack<Integer>();
    
    // Push element x to the back of queue.
    public void push(int x) {
        if (!stack2.empty()){
            move();
        }
        stack1.push(x);

    }
    private void move() {
        if (!stack2.empty()) {
            while (!stack2.empty()) {
              stack1.push(stack2.pop());
            }
            return;
        } else {
            while (!stack1.empty()) {
              stack2.push(stack1.pop());
            }
            return;
        }
    }

    // Removes the element from in front of queue.
    public void pop() {
        if (!stack1.empty()) {
            move();
        }
        stack2.pop();
    }

    // Get the front element.
    public int peek() {
        if (!stack1.empty()) {
            move();
        }
        return stack2.peek();
    }

    // Return whether the queue is empty.
    public boolean empty() {
        if (!stack1.empty() || !stack2.empty()) {
            return false;
        }
        return true;
    }
}

(3)Largest rectangle in histogram

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

 

The largest rectangle is shown in the shaded area, which has area = 10 unit.

 

For example,
Given heights = [2,1,5,6,2,3],
return 10.

暴力方法： 

for矩阵的起点

 

 

需要用到“单调栈” 

这道题的核心点是：最矮的木头！

1. //for矩阵的最爱的那根木头，也就是矩阵的高度

2.记住，单调栈能够做到找到左边比一个比当前小的点，能找到右边第一个比它小的点

3. 单调栈里实际上存的是下标，在比较增序关系的时候才用值去比较

public class Solution {
    public int largestRectangleArea(int[] heights) {
         if (heights == null || heights.length == 0) {
            return 0;
        }
        int size = heights.length;
        Stack<Integer> stack = new Stack<Integer>();
        int max = 0;
        for (int i = 0; i <= size; i++) {
            int current  = (i == size) ? -1 : heights[i];
            while (!stack.isEmpty() && current < heights[stack.peek()]) {
                int temp = stack.pop();
                int h = heights[temp];
                int wide = stack.isEmpty() ? i : i - stack.peek() - 1;
                max = Math.max(max, h * wide);
            }
            stack.push(i);//千万别忘记了！debug了1年= = 

        }
        return max;
    }
}

 

 

 

 

 

 

 

 

 

 

------------------------我是分割线----------------------------------------