Heap-like data structure allowing peek at largest & smallest
One simple approach is to use a max-heap.  Separately keep track of the minimum element stored in the heap.  Then all operations can be done relatively efficiently:


Load from array can be done in $O(n)$ time, building Build-Heap.
Each of the peek operations takes $O(1)$ time.
Decreasing the maximum element can be done in $O(\lg n)$ time.  You decrease it and fix up the heap property (or extract it and re-insert it). Then, check whether it got reduced below the previous-smallest and if so update the minimum.


This seems likely to be reasonable for many workloads.



Alternatively, you could store the elements as a balanced binary tree with the leaves in sorted order.  Keep track of a pointer to the leftmost leaf and a pointer to the rightmost heap.


To load from array, sort the elements and then create a balanced binary tree; this can be done in $O(n \lg n)$ time.
All of the peek operations take $O(1)$ time.
The decrease operation can be implemented in $O(\lg n)$ time, by deleting the maximum and then inserting it in the new place, using standard data structures for balanced binary trees that support $O(\lg n)$ time insertion and deletion (e.g., AVL trees, red-black trees, etc.)


This too will likely be reasonable for many workloads.