Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

For example, 
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

class Solution {
public:
    int max_element_p(vector<int>& height){
        int max = 0;
        int max_index ;
        for(int i=0 ;i < height.size();i++){
            if(height[i] > max){
                max = height[i];
                max_index = i;
            }
        }
        return max_index;
    }

    int find_max_right(int i,vector<int>& height){
        int res = 0;
        int len = height.size();
        int k = i+1;
        while(k <= len-1){
            if(height[k] > height[i] && height[k] > res){
                 res = height[k];
            }
            k++;
        }
        return res;
    }

    int find_max_left(int i,vector<int>& height){
        int res = 0;
        int len = height.size();
        int k = i-1;
        while(k >= 0){
            if(height[k] > height[i] && height[k] > res)
                res = height[k];
            k--;
        }
        return res;
    }

    int trap(vector<int>& height) {

        int mid = max_element_p(height);
        int len = height.size();

        if(len < 2) return 0;

        int left_sum =0;
        int right_sum =0;

        //left to mid
        for(int i=1;i < mid ;i++){
            int v = find_max_left(i,height);
            if(v != 0)
                left_sum += v-height[i]; 
        }

        //right to mid
        for(int j = len -2;j > mid ;j--){
            int v = find_max_right(j,height); 
            if(v != 0)
                right_sum += v - height[j];
        }
        // sum
        return left_sum + right_sum;
    }
};

java

public int trap(int[] height) {
    int lo = 0, hi = height.length - 1;
    int total = 0, level = 0;
    while (lo < hi) {
        if (height[lo] > height[hi]) {
            level = height[hi] > level ? height[hi] : level;
            total += Math.max(level - height[hi], 0);
            hi--;
        } else {
            level = height[lo] > level ? height[lo] : level;
            total += Math.max(level - height[lo], 0);
            lo++;
        }
    }
    return total;
}