谢邀。

这个其实很简单的，以空间换时间，先翻转，然后连拼3个，再计算之前的最大值所在的位置，进行新数组的切割。

最大的性能消耗在getmax上。

var test = [
  [1, 0, 4, 3, 2],
  [0, 4, 3, 2, 1],
  [4, 3, 2, 1, 0],
  [3, 2, 1, 0, 4]
];

test.forEach(arr => console.log(reversal(arr)));

// 反转
function reversal(arr) {
  let len = arr.length;
  // get max
  let max = arr[0];
  let index = 0;
  arr.forEach((v, i) => {
    if (v <= max) return;
    max = v;
    index = i;
  });

  // strat re
  let tmp = arr.reverse().concat(arr, arr);
  let newIndex = len - 1 - index + len;

  return tmp.slice(newIndex - index, newIndex + len - index);
}

这样就可以了
var arr = [3, 2, 1, 0, 4];
var max = arr[0]; //最大值
for(var i=1;i<arr.length;i++){

if(max<arr[i])max=arr[i];
}
var index = arr.indexOf(max);//最大值下标
arr.splice(index,1);//删除最大值
arr.reverse();//倒叙数组 也可按照你自己的排序规则自己排序
arr.splice(index,max,max);//指定位置添加元素
console.log(arr);

第一个方法

<script>

var arr = [1, 0, 4, 3, 2];


//var arr = [2, 3, 4, 0, 1];
console.log(arr);
var index=get_index(4,arr);
arr.splice(index,1);

arr.reverse();

arr.splice(index,0,4);

console.log(arr);
function get_index(val,arr){

    for(var i=0;i<arr.length;i++){
        if(arr[i]==val){   
               return i;
        }
    }
}
</script>

//PHP

$arr = array(0, 4, 3, 2, 1);
$b = array_shift($arr);
$c = array_chunk($arr,2);
asort($c['0']);
asort($c['1']);
print_r(array_merge($c['0'],(array)$b,$c['1']));

var array = [10, 20, 45, 56, 15];
var maxIndex = array.reduce((iMax, x, i, arr) => x > array[iMax] ? i: iMax, 0 );
var removedItem = array.splice(maxIndex , 1);
var reversedArray = array.reverse();
reversedArray.splice(maxIndex, 0, removedItem[0]);
console.log(reversedArray); // [15, 45, 20, 56, 10]

1 reduce获取到最大值的index

2 splice将最大值从原数组中移除

3 reverse将数组翻转

4 将最大值放回原位置

第二个例子没看懂，如果最大值不在数组的中央应该按照什么规则反转？

Java8可以这么做

public static Integer[] reverseByMax(int[] array) {
        int maxIndex = IntStream.range(0, array.length)
                .reduce((a, b) -> array[a] > array[b] ? a : b)
                .getAsInt() * 2 + 1;
        Integer[] front = IntStream.range(0, maxIndex)
                .boxed()
                .map(i -> array[maxIndex - i - 1])
                .toArray(Integer[]::new);
        Integer[] back = IntStream.range(maxIndex, array.length)
                .boxed()
                .map(i -> array[array.length - i - 1 + maxIndex])
                .toArray(Integer[]::new);
        return Stream.of(front, back).flatMap(Stream::of).toArray(Integer[]::new);
    }

谢邀，我来晚了。问题已解决，我就赞一下吧

谢邀。之前没看到。顺手赞个。