Daily-Interview-Question
Daily-Interview-Question copied to clipboard
Advanced-Frontend
第 77 题：旋转数组算法题
因为步数有可能大于数组长度，所以要先取余
function rotate(arr, k) {
const len = arr.length
const step = k % len
return arr.slice(-step).concat(arr.slice(0, len - step))
}
// rotate([1, 2, 3, 4, 5, 6], 7) => [6, 1, 2, 3, 4, 5]
var arr = [-1, -100, 3, 99];
var k = 5;
for (let i = 0; i < k; i++) {
let val = arr.pop();
arr.unshift(val);
}
console.log(arr);
var rotate = function(nums, k) {
for(var i = 0;i<k;i++){
nums.unshift(nums.pop())
}
return nums;
}
/* 第 77 题：旋转数组算法题
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
输入: [1, 2, 3, 4, 5, 6, 7] 和 k = 3
输出: [5, 6, 7, 1, 2, 3, 4]
解释:
向右旋转 1 步: [7, 1, 2, 3, 4, 5, 6]
向右旋转 2 步: [6, 7, 1, 2, 3, 4, 5]
向右旋转 3 步: [5, 6, 7, 1, 2, 3, 4] */
const rotateAry = (ary, k) => {
let len = ary.length
let rotateNum = k % len
if (rotateNum === 0) {
return ary
}
let tmpAry = new Array(len)
ary.forEach((el, index) => {
if ((index + rotateNum) >= len) {
tmpAry[index + rotateNum - len] = el
} else {
tmpAry[index + rotateNum] = el
}
})
return tmpAry
}
console.log(rotateAry([1, 2, 3, 4, 5, 6, 7], 3))
这么一对比我的写法好low啊= =
用splice就好了嘛 就不用考虑步数超出数组长度 一行代码解决问题
function rotateArr(arr, k) { return [...arr.splice(k+1), ...arr]; }
你这个是不是有点问题，你把key换成1试一试
问题转化为：数组的末尾k个元素移动到数组前面 末尾元素：arr.splice(-k%arr.length)的返回值 剩余元素：arr
const moveArr = (arr,k)=>arr.splice(-k%arr.length).concat(arr)
test: moveArr([1,2,3,4,5,6,7],0) => [1,2,3,4,5,6,7] moveArr([1,2,3,4,5,6,7],5) => [3,4 5,6,7,1,2] moveArr([1,2,3,4,5,6,7],8) => [7,1,2,3,4,5,6]
找到一个合适的位置剪掉，unshift到原来的数组， 题目的意思应该是要改变原来的数组，所以直接对原数组开刀。
Array.prototype.rotate = function rotateArr(k = 0) {
const len = this.length;
if(!len) {
return this;
}
k = k % len;
if(k <= 0) {
return this;
}
const cut = this.splice(len - k);
return this.unshift(...cut);
}
let a = [1, 2, 3, 4, 5, 6];
a.rotate(3);
function rotateArr(arr, k) { return [...arr.splice(k+1), ...arr]; }
拷贝下数组, 防止修改入参
function rotateArr(arr, k) {
const _tmp = JSON.parse(JSON.stringify(arr));
return [..._tmp.splice(k + 1), ..._tmp];
}
function rotateStep(arr: any[]) {
arr.unshift(arr.pop());
}
function rotateTimes(arr: any[], k: number) {
for(let i=0; i<k; i++) {
rotateStep(arr);
}
}
const arr = [1, 2, 3, 4, 5, 6, 7, 8];
rotateTimes(arr, 1);
console.log(`arr ${JSON.stringify(arr)}`);
var a = [1,2,3,4,5,6,7]; var move = function(arr,k) { const len = arr.length const step = k % len return arr.slice(len-step).concat(arr.slice(0, len - step)) } console.log(move(a,3))
用splice就好了嘛 就不用考虑步数超出数组长度 一行代码解决问题
function rotateArr(arr, k) { return [...arr.splice(k+1), ...arr]; }
你这个是不是有点问题，你把key换成1试一试
把 k+1 改成 -k 就好了
function rotate(arr, k) {
if (!Array.isArray(arr) || !arr.length) {
console.error('参数 arr 必须为长度大于 0 的数组');
return [];
}
if (!Number.isInteger(k) || k <= 0) {
console.error('参数 k 必须为非负整数');
return [];
}
const _tmp = JSON.parse(JSON.stringify(arr));
return [..._tmp.splice(-k % _tmp.length), ..._tmp];
}
// test
const arr = [1, 2, 3, 4, 5, 6, 7];
console.log(rotate(arr, 0)); // [1, 2, 3, 4, 5, 6, 7]
console.log(arr); // [1, 2, 3, 4, 5, 6, 7], 纯函数,不改变原数组
console.log(rotate(arr, 'aaa')); // []
console.log(rotate(arr, 2)); // [ 6, 7, 1, 2, 3, 4, 5 ]
const changeArr = (arr,k) => {
const len = arr.length;
return arr.reduce((acc,curr,idx,origin) => {
const temp = idx+k <= len-1 ? idx+k : idx+k-len;
acc[temp] = curr;
return acc
},[])
}
let rotArr = (arr,k) => { let len = arr.length return [...arr,..arr].slice(k,len+k) }
leetcode 第77题 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。 要求使用空间复杂度为 O(1) 的原地算法。
/**
* @param {number[]} nums
* @param {number} k
* @return {void} Do not return anything, modify nums in-place instead.
*/
var rotate = function (nums, k) {
nums.unshift(...nums.splice(nums.length - k, k))
return nums
};
let arr = [1, 2, 3, 4, 5, 6, 7];
let rotate = (arr,k)=>[...arr.slice(-k),...arr.slice(0,-k)]
找到一个合适的位置剪掉，unshift到原来的数组， 题目的意思应该是要改变原来的数组，所以直接对原数组开刀。
Array.prototype.rotate = function rotateArr(k = 0) { const len = this.length; if(!len) { return this; } k = k % len; if(k <= 0) { return this; } const cut = this.splice(len - k); return this.unshift(...cut); } let a = [1, 2, 3, 4, 5, 6]; a.rotate(3);
这操作。。。 之前了解到的一个建议是尽量避免在原型链上添加方法。
let arr1 = [1, 2, 3, 4, 5]
function func(arr, num) {
if (num % arr.length === 0) return arr
return arr.splice(arr.length - (num%arr.length)).concat(arr)
}
let rotateRight = (arr, k) => [...arr.slice(arr.length - k), ...arr.slice(0, arr.length - k)];
function rotateArray(array, step) {
// 旋转长度超过数组长度，只需要旋转余数就行了
step = step % array.length;
// splice 方法同时会将原数组截断
var rotateArray = array.splice(array.length - step);
// 重新拼接
return rotateArray.concat(array);
}
rotateArray([1, 2, 3, 4, 5], 6);
编程式实现，见笑了
function rotateArr(arr, k) {
let len = arr.length;
let result = [];
k = k > len ? k % len : k;
for (let i = len - 1; i >= 0; i--) {
if (len - i <= k) {
result.unshift(arr[i]);
} else {
result[i + k] = arr[i];
}
}
return result;
}
因为步数有可能大于数组长度，所以要先取余
function rotate(arr, k) { const len = arr.length const step = k % len return arr.slice(-step).concat(arr.slice(0, len - step)) } // rotate([1, 2, 3, 4, 5, 6], 7) => [6, 1, 2, 3, 4, 5]
当 k = 0 或 k = arr.length 时，返回结果有误：
rotate([1, 2, 3, 4, 5, 6], 6); // [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
/**
* solution1
* 最短路径逐个转移
*/
var rotate = function (nums, k) {
const len = nums.length;
let c = k % len;
if (c > len / 2) {
c = len - c;
while (c > 0) {
nums.push(nums.shift());
c--;
}
}
else {
while (c > 0) {
nums.unshift(nums.pop());
c--;
}
}
};
/**
* solution2
* 妙用API一次性转移
*/
var rotate = function (nums, k) {
nums.unshift(...nums.splice(- (k % nums.length)));
};
/**
* solution3
* 三次翻转
*/
var rotate = function (nums, k) {
k %= nums.length;
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);
};
function reverse(nums, start, end) {
while (start < end) {
let temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start++;
end--;
}
}
用splice就好了嘛 就不用考虑步数超出数组长度 一行代码解决问题
function rotateArr(arr, k) { return [...arr.splice(k+1), ...arr]; }
@zpzxgcr 仔细看题目的example老哥
输入: [1, 2, 3, 4, 5, 6, 7] 和 k = 3
输出: [5, 6, 7, 1, 2, 3, 4]
解释:
向右旋转 1 步: [7, 1, 2, 3, 4, 5, 6]
向右旋转 2 步: [6, 7, 1, 2, 3, 4, 5]
向右旋转 3 步: [5, 6, 7, 1, 2, 3, 4]
var rotate = function(nums, k) { for(var i = 0;i<k;i++){ nums.unshift(nums.pop()) } return nums; }
@zxcweb k = 10000000000
function rotateArr(arr, k) { return [...arr.splice(k+1), ...arr]; }拷贝下数组, 防止修改入参
function rotateArr(arr, k) { const _tmp = JSON.parse(JSON.stringify(arr)); return [..._tmp.splice(k + 1), ..._tmp]; }
@ChasLui 这样拷贝数组的操作我头一次见。
const _tmp = [...arr];
function f(arr,k){arr.unshift(...arr.splice(-k)); console.log(arr) }
var rotate = function (nums, k) { nums.unshift(...nums.splice(nums.length - k, k)) return nums };
function rotateArr(arr,k){ return[...arr.splice(-k), ...arr] }
@kungithub @kingstone3 @yupeilin123 @i-lijin 都试试下面这个case
f([1,2],13);
> [1, 2]
function f(arr,k){arr.unshift(...arr.splice(-k)); console.log(arr) } var rotate = function (nums, k) { nums.unshift(...nums.splice(nums.length - k, k)) return nums }; function rotateArr(arr,k){ return[...arr.splice(-k), ...arr] }
@kungithub @kingstone3 @yupeilin123 @i-lijin 都试试下面这个case
f([1,2],13); > [1, 2]
function rotateArr(arr, k) {
return [...arr.splice(-(k % arr.length)), ...arr];
}
function rotateArr(arr, k) { return [...arr.splice(k+1), ...arr]; }拷贝下数组, 防止修改入参
function rotateArr(arr, k) { const _tmp = JSON.parse(JSON.stringify(arr)); return [..._tmp.splice(k + 1), ..._tmp]; }@ChasLui 这样拷贝数组的操作我头一次见。
const _tmp = [...arr];
@LiuMengzhou ... 是 rest/spread 运算符:
- 作为 rest 的情况: 函数声明中作为剩余参数，例如 functuin foo(...args) {} 解构赋值中收集剩余元素: let [a, ...arr] = [1, 2, 3, 4] 或 let {a, ...obj} = {a: 1, b:2, c:3}
- 作为 spread 的情况: 数组: let arr = [1, ...[2, 3]] 对象: let obj = {a: 1, ...otherObj}
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Rest_parameters https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Spread_syntax
@kingstone3 老哥可以的～还引经据典。这些我都会。你看看他的回答
const _tmp = JSON.parse(JSON.stringify(arr)); // 那位老哥写的
const _tmp = [...arr]; // 我写的
function rotateArr (arr, step) {
if (arr.length <= 0) {
return arr
}
let count = step % arr.length
return arr.splice(-count).concat(arr)
}
function Test(a, k){ k = k % a.length; do{ TransformUnit(a); k--; }while(k>0) return a; }
function TransformUnit(a){ var first = a[0]; for(var i=0; i<a.length - 1; i++){ a[i] = a[i+1]; } a[a.length - 1] = first; return a; } console.error(Test([1,2,3,4,5,6,7], 7));
const moveArr = (arr, k) => {
const arrLeft = arr.splice(arr.length - k, k);
return arrLeft.concat(arr);
};
moveArr([1, 2, 3, 4, 5, 6, 7], 1); // [7, 1, 2, 3, 4, 5, 6]
moveArr([-1, -100, 3, 99], 2); // [3, 99, -1, -100]
var arr = [-1, -100, 3, 99]; var k = 5; for (let i = 0; i < k; i++) { let val = arr.pop(); arr.unshift(val); } console.log(arr);
如果移动步数大于数组长度的话可能会重复
let rotArr = (arr,k) => { let len = arr.length return [...arr,..arr].slice(k,len+k) }
这里应该是return [...arr,...arr].slice(len-k%len, len * 2 - k%len)吧
var arr = [1,2,3,4,5,6,7,8,9];
function arrMoveStep(arr, k) {
const len = arr.length;
let copyArr = JSON.parse(JSON.stringify(arr))
return [...copyArr.splice(len - (k % len) , len),...copyArr]
}
console.log(arr)//[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
console.log(arrMoveStep(arr, 14))//[ 5, 6, 7, 8, 9, 1, 2, 3, 4 ]
console.log(arrMoveStep(arr, 7))//[ 3, 4, 5, 6, 7, 8, 9, 1, 2 ]
function rotate(arr, k) {
arr.unshift(...arr.splice(arr.length - k, k));
return arr;
}
const rotate = (arr, step) => {
let len = arr.length;
return arr.reduce((acc, v, i) => {
return i + step >= len
? ((acc[i + step - len] = v), acc)
: ((acc[i + step] = v), acc);
}, []);
};
rotate([-1, -100, 3, 99] , 2); // [3, 99, -1, -100]
function rotateArr( arr, k ) { for( let i = 0; i < k; i++) { arr.unshift( arr.pop() ) } return arr; }
// the first solution，利用映射
const rotateArray0 = (arr, size) => arr.map((item, index) => arr[ (index - size + arr.length ) % arr.length]);
console.log(rotateArray0([1, 2, 3, 4, 5, 6], 3));
// the second solution 利用splice
const rotateArray = (arr, size) => [...arr.splice(size % arr.length), ...arr];
console.log(rotateArray([1, 2, 3, 4, 5, 6], 3));
// splice const rotateArray = (arr, k) => arr.splice(arr.length - k).concat(arr);
const arr = [1, 2, 3, 4, 5, 6, 7];
const k = 3;
console.log(
Array.from({length:arr.length},(x,i)=>arr[(i+k+arr.length%2)%arr.length])
)
var arr = [1, 2, 3, 4, 5, 6, 7];
function reverse(arr,k){
k = k % arr.length;
while(k--){
arr.unshift(arr.pop());
}
}
reverse(arr,3);
console.log(arr);
function rotate(arr,k){ while(k){ arr.unshift(arr.pop()); k--; } return arr; }
function move (attr,num) {
let oldAttr=[];
if(Array.isArray(attr) && typeof(num)==='number'&&num>-1){
attr.map((v,i)=>{
if(i+num>=attr.length) num-=attr.length
oldAttr.splice(i+num, 0, v);
})
return oldAttr
}else{
throw new Error('请输入数组及大于-1的数字')
}
}
function rotateArr(arr, k) {
const temp = [];
for(let i=0; i<k; i++) {
temp.push(arr.pop());
}
return [...temp, ...arr]
}
leetcode原题，以下是参考答案：
var rotate = function(nums, k) {
// 就像扩容一样操作
k = k % nums.length;
const n = nums.length;
for (let i = nums.length - 1; i >= 0; i--) {
nums[i + k] = nums[i];
}
for (let i = 0; i < k; i++) {
nums[i] = nums[n + i];
}
nums.length = n;
};
如果你对数据结构和算法感兴趣，欢迎关注我的leetcode题解
function rotate (arr, k) {
for (let index = 0; index < k; index++) {
const item = arr.pop()
arr.unshift(item)
}
return arr
}
console.log(rotate([1, 2, 3, 4, 5, 6, 7], 3))
function rotate(arr, k) {
if (!arr) throw Error('requires an array')
if (!k || k < 0) return arr
let n = k % arr.length
let stack = [].concat(arr)
let index = 1
while (n) {
stack.unshift(stack.pop())
n--
console.log(`向右旋转 ${index++} 步`, stack);
}
return stack
}
console.log(rotate([1, 2, 3, 4, 5, 6, 7], 3))
console.log(rotate([-1, -100, 3, 99], 2))
console.log(rotate([1, 2], 13))
console.log(rotate([1, 2], -1))
console.log(rotate([1, 2, 3, 4, 5, 6, 7]))
console.log(rotate([]))
function move(arr, step) {
let length = arr.length;
let hash = arr.reduce((hash, value, key) => {
hash[key] = value;
return hash;
}, {});
let newHash = Object.keys(hash).reduce((newHash, key) => {
key = Number(key);
let newKey = key + step > length - 1 ? key + step - length : key + step;
newHash[newKey] = hash[key];
return newHash;
}, {})
return Array.from({...newHash, length})
}
用了一个很蠢的方式
const rightMove = (arr: Array<number>, step: number) => {
while (step > 0) {
arr.unshift(arr.pop());
step--;
}
return arr;
};
console.log(leftMove([1, 2, 3, 4, 5, 6, 7], 3));
console.log(leftMove([-1, -100, 3, 99], 2));
let arr = [1, 2, 3, 5, 4, -12, -23, 56];
function rotateArr(arr, k) {
if (k <= 0) {
return arr;
}
for (let i = 1; i <= k; i++) {
const last = arr[arr.length - 1];
arr.pop();
arr.unshift(last)
}
return arr
}
rotateArr(arr, 3)
function rotate(arr, k) { let list = arr.slice(0); list.reduce((target, cur, curIndex, arr)) { target[(curIndex + k) % arr.length] = cur; return target; }, arr) ; }
因为步数有可能大于数组长度，所以要先取余
function rotate（arr，k）{ const len = arr。length const step = k ％ len return arr。切片（-步骤）。concat（arr。切片（0，len - step）） } // rotate（[1,2,3,4,5,6]，7）=> [6,1,2,3,4,5]
let arrd= [1, 2, 3, 4, 5, 6, 7]; function rotate(arr, k) { const len = arr.length const step = k % len console.log(step); return arr.slice(-step).concat(arr.slice(0, len - step)) } console.log(rotate(arrd,7)); //[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7] 当k等于数组长度就尴尬了 改成 const step = k % len||len;
let arr = [-1, -100, 3, 99];
let k = 2;
let test = (array, key) => [...array.splice(-key), ...array];
console.log(test([...arr], k));
/**
- 旋转数组
- 给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数 */
const reverseArr = (arr, k) => { if (arr.length < k) return const newarr = arr.splice(arr.length - k, k) console.log([...newarr, ...arr]) } reverseArr([1, 2, 3, 4, 5, 6, 7], 3)
上面大部分答案是splice截取再添加，我这里提供另外一种算法：
- 只是将原数组index移动key个位置即可，超出数组长度，依次添加在数组头部，相当于固定位数的链表循环
function transformArr(arr, key){
let resArr = [];
arr.forEach((item, i) => {
resArr[i] = i - key >= 0 ? arr[i - key] : arr[arr.length - key + i]
});
return resArr;
}
var arr=[1,2,3,4,5,6,7];
var k=3;
var length=arr.length;
var moveCount=Math.abs(k%length);
console.log(moveCount)
if(moveCount>0){
for(let i=0;i<moveCount;i++){
let v=arr.splice(length-1,1);
console.log(v)
arr.unshift(...v)
}
}
console.log(arr);
leetcode初级算法数组原题 原地修改,可以这样: 1.reverse原数组 [ 1,2,3,4,5,6,7 ]===>[ 7,6,5,4,3,2,1 ] 2.reverse前k项 (k=2) [ 7,6,5,4,3,2,1 ]===>[ 6,7,5,4,3,2,1 ] 3.reverse剩余项 [ 6,7,5,4,3,2,1 ]===>[ 6,7,1,2,3,4,5]
let arr = [1, 2, 3, 4, 5, 6, 7]; function handleArr(arr,k){ while(k--){ arr.unshift(arr.pop()) } return arr } let newArr = handleArr(arr,2) console.log(newArr)
function turnArr(arr,num){ let arrlen = arr.length; if(arrlen < num) return -1; var newArr = []; for(var i=0;i<arrlen;i++){ if((i+num)<arrlen){ newArr[i+num] = arr[i] }else{ var xiabiao = (i+num)%arrlen newArr[xiabiao] = arr[i] } } return newArr }
function circleArr(arr,step){
const storeArr = []
storeArr[0] = arr.splice(-1 * step)
storeArr[1] = arr
return storeArr.flat(1)
}
arr.map((a, index) => arr[(index - k % arr.length + arr.length) % arr.length])
let arr = [1, 2, 3, 4, "5", "6"];
const step = 2 % arr.length; // 避免步长超过数组大小
let sliceArr = arr.slice(0, arr.length - step);
let spliceArr = [].splice.bind(sliceArr, 0, 0);
spliceArr.apply(this, arr.slice(-step));
console.log(sliceArr); // [ '5', '6', 1, 2, 3, 4 ]
function fn(arr, k){ const r = k % arr.length return arr.concat(arr.splice(0, r+1)) }
function rotateArr(arr, k) { let temp=arr.splice(-k); temp.push(...arr); return temp; }
function rotate(arr, k) {
Array.from({ length: k }).map(() => arr.unshift(arr.pop()));
return arr;
}
rotate(arr, k);
in-place 的解法来一波，不包含unshift/pop等数组的操作，先计算每一项在移动之后应该在的位置，然后依次赋值
let arr = [1,2,3,4,5];
function rotate (array, k){
a = [...array];
k = k % 5;
for(let i=0;i<a.length;i++){
array[i] = a[(i+a.length-k)%a.length];
}
}
rotate(arr, 1);
咋一看是对的。。实际上是错的。
function rotate(arr, num) {
return arr.splice(arr.length - num).concat(...arr)
}
看了大家的回答才知道，因为移动的距离是可能大于数组的长度的。。。。
function rotate(arr, num) {
return arr.splice(arr.length - (num % arr.length) ).concat(...arr)
}
上面还有位大兄弟的做法很赞，每次pop然后unshift到最前面。仍然需要求余数！！！！！！！
function rotate(arr, num) {
for (let i = 0, j = num % arr.length; i < j; i++) {
arr.unshift(arr.pop())
}
return arr
}
function fn(arr,k){
let temp = arr.splice(arr.length - k,arr.length)
let result = [...temp,...arr]
return result
}
fn(arr,2)
小白问一下代码怎么高亮啊
function rotate(a, k) {
k %= a.length;
let pre = a.splice(0, k + 1);
return a.concat(pre);
}
一行代码解决：
function rotate(arr, k) {
return [...arr.splice(arr.length-k, k), ...arr]
}
function rotate(arr, k) { return arr.splice(arr.length - k).concat(arr) }
function rotate(arr, step) {
var _arr = arr.slice()
while (step--) {
_arr.unshift(_arr.pop())
}
return _arr
}
let arr =[1, 2, 3, 4, 5, 6, 7]; function reverse(arr,k) { while (k) { arr = [arr.pop()].concat(arr); k--; } return arr; }
reverse(arr,3);
function rotate(arr, k) {
const len = arr.length
const step = k % len
return [...arr.slice(-step),...arr.slice(0, len - step)] ;
}
// rotate([1, 2, 3, 4, 5, 6], 7)
// [6, 1, 2, 3, 4, 5]
来一个普普通通的
let As = [1, 2, 3, 4, 5, 6, 7]
let k = 3
let newArry = []
let oldArry = []
for (let i = 1; i < (As.length - k); i++) {
newArry.push(As[i + k])
}
for (let i = 0; i <= k; i++) {
oldArry.push(As[i])
}
console.log([...newArry, ...oldArry])
var arr = [1, 2, 3, 4, 5, 6, 7]; var k = 3; rotate(arr,k)
function rotate(arr,k){ for (var i = 0; i < k; i++) { if(k>arr .length) return for (var j = 0; j < arr.length; j++) { if (j == arr.length - 1) { var tempItem = arr.splice(j, 1); arr.unshift(tempItem[0]); } } } } console.log(arr);
const arr = [1, 2, 3, 4, 5, 6, 7] function rotate(arr, k) { while (k) { k-- && arr.unshift(arr.pop()) } console.log(arr) } rotate(arr, 8) 这样不就好了？
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
示例 1：
输入: [1, 2, 3, 4, 5, 6, 7] 和 k = 3
输出: [5, 6, 7, 1, 2, 3, 4]
解释:
向右旋转 1 步: [7, 1, 2, 3, 4, 5, 6]
向右旋转 2 步: [6, 7, 1, 2, 3, 4, 5]
向右旋转 3 步: [5, 6, 7, 1, 2, 3, 4]
示例 2：
输入: [-1, -100, 3, 99] 和 k = 2
输出: [3, 99, -1, -100]
解释:
向右旋转 1 步: [99, -1, -100, 3]
向右旋转 2 步: [3, 99, -1, -100]
let rotateArr = (arr, num) => { const len = arr.length; const step = num % len; for (let index = 0; index < step; index++) { let item = arr.pop(); arr.unshift(item); return arr; } }; rotateArr([5, 4, 3, 3, 2, 1], 6);
function rotateArray(arr, k) {
let front = arr.slice(0, arr.length - k)
let rear = arr.slice(arr.length - k, arr.length)
let result = rear.concat(front)
return result
}
// let arr = [1, 2, 3, 4, 5, 6, 7]
let arr = [-1, -100, 3, 99]
console.log(rotateArray(arr, 2))
看看大佬的 看看我的.... 流下了没有技术的眼泪 ....
function reversalArr(arr, frequency) {
const newReversalArr = arr
for (let index = 0; index < frequency; index++) {
var first = newReversalArr.splice(newReversalArr.length - 1,1)
newReversalArr.unshift(...first)
}
return newReversalArr
}
var rotate = function(nums, k) {
for (let i = 0; i < k; i++) {
nums.unshift(nums.pop())
}
}
function moveArr(arr,k) {
const start = arr.length - k
return [...arr.slice(start), ...arr.slice(0,start)]
}
function moveK(arr, k){
const p = arr.slice(arr.length - k);
arr.length = arr.length - k;
arr.unshift(...p);
return arr;
};
moveK([1, 2, 3, 4, 5, 6, 7], 3); // [5, 6, 7, 1, 2, 3, 4]
function rotate (arr, k) {
return arr.concat(arr.splice(0, arr.length - k % arr.length))
}
rotate([1, 2, 3, 4, 5, 6, 7], 3) // [5, 6, 7, 1, 2, 3, 4]
个人觉得这道题考察的是： 基于传统数组的定义，如何以最小时间复杂度来实现该算法， 而不是直接调用各种Array的方法~，
下边是我的实现；
function transArray(arr, k) {
k = k % arr.length;
if (k === 0) {
return;
}
const tmpArr = Array.from({length: k});
const len = arr.length;
for(let ind =1; ind <= len; ind++){
if(ind<=k){
tmpArr[k-ind] = arr[len-ind]
} else {
arr[len-ind+k] = arr[len-ind]
}
}
for(let ind =0; ind < k; ind++){
arr[ind] = tmpArr[ind]
}
}
const arr = [1,2,3,4,5,6,7,8,9,10]
transArray(arr, 3);
console.log(arr);
//[8, 9, 10, 1, 2, 3, 4, 5, 6, 7]
const rA = (arr, k) => {
let ln = arr.length;
let k1 = k % ln;
return arr.slice(ln - k1).concat(arr.slice(0, ln - k1));
};
rA([1, 2, 3, 4, 5, 6, 7], 3) // [5, 6, 7, 1, 2, 3, 4]
//第二种
const rA = (arr, k) => {
let ln = arr.length;
let k1 = k % ln;
Array.from({length:k1}).map( ()=> {arr.unshift(arr.pop())});
return arr
};
array.splice(index,howmany,item1,.....,itemX)
index：从何处添加/删除元素。 howmany：删除多少个元素。 item1~X：添加的元素1~X。
splice函数返回被删除元素的数组，会改变原数组，最好先拷贝下来。
var arr = [1, 2, 3, 4, 5, 6, 7];
function test(arr, index) {
var _copy = [...arr]
return index > arr.length || index < 0 ? arr : _copy.splice(arr.length - index).concat(_copy)
};
function round(arr=[],n){
let cut = arr.splice(arr.length-n,n)
let result = cut.concat(arr)
return result
}
round([1, 2, 3, 4, 5, 6, 7],3)
/**
* @param {Array} arr - 数组
* @param {number} step - 向右旋转的步数
* */
const arr = [1, 2, 3, 4, 5, 6, 7];
const step = 3;
const autoReserver = (arr, step) => {
for (let i = 0; i < step; i++) {
arr.unshift(arr.pop());
}
return arr;
};
console.log(autoReserver(arr, step));
