1 -10000 之间的对称数（回文）

题目：打印 1-10000 之间的对称数（回文）

思路：

• 思路1:使用数组反转
  • 数字转换为字符串
  • 字符串转换为数组 reverse,再join 生成字符串
  • 比较前后字符串　　
• 思路2:使用字符串头尾比较
  • 数字转换为字符串
  • 字符串头尾比较　　
• 思路3: 生成反转数　
  • 通过 % 和 Math.floor 将数字生成一个反转数
  • 比较前后的数字

性能分析：

• 思路1：比较慢
  • 时间复杂度O(n)　
  • 但数组 reverse需要时间，数组和字符串转换需要时间
  • 所以整体上需要耗费大量的时间　　　
• 思路2:比较快
  • 时间复杂度O(n)
  • 比思路1要快很多　　
• 思路3：最快　
  • 时间复杂度O(n)
  • 数字操作最快　

代码实现：

• 思路1

  /**
   * 查询 1-max 的所有对称数 -- 数组反转
   * @param max 
   * @returns 
   */
  export function findPalindromNumbers1(max: number): number[]{
      const res:number[] = []
      if(max < 1 ) return res
      for(let i = 1 ; i <= max; i++){
          const s = i.toString()
          if(s === s.split('').reverse().join('')){
              res.push(i)
          }
      }
      return res
  }

• 思路2：

  /**
   * 查询 1-max 的所有对称数 -- 字符串头尾比较
   * @param max 
   * @returns 
   */
  export function findPalindromNumbers2(max: number): number[]{
      const res:number[] = []
      if(max < 1 ) return res
      // O(n)
      for(let i = 1 ; i <= max; i++){
          const s = i.toString()
          const length = s.length
          let startIndex = 0
          let endIndex = length -1
          let flag = true
          // 此处虽然是循环，但循环次数是字符串的长度，
          while(startIndex <= endIndex){
              if(s[startIndex] !== s[endIndex]){
                  flag = false
                  break
              }
              startIndex++
              endIndex--
          }
          flag && res.push(i)
      }
      return res
  }

• 思路3　　

  /**
   * 查询 1-max 的所有对称数 -- 生成反转数对比
   * @param max 
   * @returns 
   */
  export function findPalindromNumbers3(max: number): number[]{
      const res:number[] = []
      if(max < 1 ) return res
      // O(n)
      for(let i = 1 ; i <= max; i++){
         let temp = i
         let rev = 0 // 存储反转数
  
          while(temp > 0) {
              rev = rev * 10 + temp % 10
              temp = Math.floor(temp/10)
          }
          if( i === rev){
              res.push(i)
          }
      }
      return res
  }

测试用例：

/**
 * @description 对称数（回文数）测试
 */

import {findPalindromNumbers1,findPalindromNumbers2,findPalindromNumbers3} from './palindrome-number'

describe('对称数（回文数）测试',()=>{
    it('正常数', ()=>{
        expect(findPalindromNumbers1(100)).toEqual([1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99])
        expect(findPalindromNumbers2(100)).toEqual([1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99])
        expect(findPalindromNumbers3(100)).toEqual([1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99])
    })
    it('负数情况', ()=>{
        expect(findPalindromNumbers1(-100)).toEqual([])
        expect(findPalindromNumbers2(-100)).toEqual([])
        expect(findPalindromNumbers3(-100)).toEqual([])
    })
})