算法入门 1-5 例

反转一个3位整数

function reverseInteger (num) {
  let h = parseInt(num / 100);
  let t = parseInt(num % 100 / 10);
  let z = parseInt(num % 10);

  return (100 * z + t * 10 + h)
}

console.log(reverseInteger(123));

合并排序数组

合并两个升序的整数数组A和B，形成一个新的数组，数组也要有序

function mergeSortedArray(arrA, arrB) {
   let i = 0;
   let j = 0;
   const C = [];

   while(i < arrA.length && j < arrB.length) {
     if (arrA[i] < arrB[j]) {
       C.push(arrA[i]);
       i += 1;
     } else {
       C.push(arrB[j]);
       j += 1
     }
   }

   while (i < arrA.length) {
      C.push(arrA[i]);
      i+=1;
   }

   while (j < arrB.length) {
       C.push(arrB[j]);
       j+=1;
   }

   return C;
}

console.log(mergeSortedArray([1,4], [1,2,3]));

旋转字符串

给定一个字符串(以数组形式),和一个偏移量，根据偏移量原地从左向右旋转字符串，偏移量是取余数字

offset = offset % s.length;。

function rotateString(s, offset) {
  if (s.length > 0) {
    offset = offset % s.length;
  } 
  const temp = s.concat(s).splice(s.length - offset, 2 * s.length - offset);
  for (let i = 0; i < s.length; i += 1) {
    s[i] = temp[i]
  }

  return s;
}

console.log(rotateString(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3))

相对排名

根据N名运动员得分，找到前三名，分别获得金牌，银牌，铜牌，N是正整数，所有运动员的成绩都独一无二，接收 [5,3,4,2,1]，要求输出 ["金牌", "银牌", "铜牌", 4, 5]

function findRelativeRanks(nums) {
  const _nums = nums.map(item => item);
  const arr = _nums.sort((a,b) => a - b);

  if (arr[0]) {
      arr[0] = "金牌"
  }

  if (arr[1]) {
      arr[1] = "银牌"
  }

  if (arr[2]) {
      arr[2] = "铜牌"
  }

  return arr;
}

var nums = [5,3,4,2,1];

console.log(findRelativeRanks(nums), nums);

二分查找

给定一个升序的整数数组和一个要查找的目标整数，查找到target第一次出现的下标，如果target不存在与数组中，返回-1。

function binarySearch(arr, target) {
  const search = function(nums, start, end, target) {
      console.log(start, end, target)
      if (start > end) {
          return -1;
      }
      if (end - start === 1) {
          if (nums[start] === target) {
              return start;
          } else if (nums[end] === target) {
              return end;
          } else {
              return -1;
          }
      }
      const mid = parseInt((start + end) / 2);
      console.log(mid);

      if (nums[mid] > target) {
          return search(nums, start, mid, target);
      } else if (nums[mid] === target) {
          return mid;
      } else if (nums[mid] < target) {
          return search(nums, mid, end, target);
      }
  }
  return search(arr, 0, arr.length - 1, target);
}

binarySearch([1,2,3,4,5], 5)