1. 快慢指针

  1. demo 获取字符串中连续字符串的最大长度 


  1. //计算一个字符串,连续出现最大的次数
  2. function twoPointerAlgorithm(str){
  3.   let i,j,max=1;
  4.   if(!str.length){
  5.     return 0;
  6.   }
  7.   for (j=0; j <= str.length; j++) {
  8.     if(str[j]!=str[i]){
  9.       if(j-i>max){
  10.           max=j-i;
  11.       }
  12.       i=j;
  13.     }
  14.   }
  15.   return max;
  16. }
  19. console.log(twoPointerAlgorithm('aaaaabccceddadeeeeeeeeeaaaaaaacd')) //9
  1. demo 获取字符串中连续字符串的最大长度以及当前字符串


  1. function twoPointerAlgorithm(str){
  2.   let i,j,max=1,maxStr='';
  3.   if(!str.length){
  4.     return 0;
  5.   }
  6.   for (j=0; j <= str.length; j++) {
  7.     if(str[j]!=str[i]){
  8.       if(j-i>max){
  9.           max=j-i;
  10.           maxStr=str[i]
  11.       }
  12.       i=j;
  13.     }
  14.   }
  15.   return {max,maxStr};
  16. }
  18. const result=twoPointerAlgorithm('aaaaabcccffffffffffffffffffffffeddadeeeeeeeeeaaaaaaacd');
  19. console.log('最大连续字符串: ',result.maxStr,' ,最大长度: ',result.max)
  1. 快慢指针实现斐波那契数列
  1. /**
  2.  * 
  3.  * @param {Number} n 
  4.  */
  5. function fibonacci(n) {
  6.     if (n === 1 || n === 2) {
  7.         return 1;
  8.     }
  9.     var lastTwo = 1, lastOne = 1;
  10.     i = 3;
  11.     while (i < n) {
  12.         var temp = lastOne;
  13.         lastOne = lastOne + lastTwo;
  14.         lastTwo = temp;
  15.         i++;
  16.     }
  17.     return lastOne + lastTwo;
  18. }
  20. console.log('fibonacci', fibonacci(1))
  21. console.log('fibonacci', fibonacci(2))
  22. console.log('fibonacci', fibonacci(3))
  23. console.log('fibonacci', fibonacci(5))
  24. console.log('fibonacci', fibonacci(7))
  25. console.log('fibonacci', fibonacci(8))
  27. // 1 1 2 3 5 8 13 21

2. 对撞指针

一个字符串的除了有效字符(数字,字母)从开始到结束和从结束到开始是同一个字符串

  1. var validExp = /[\da-zA-Z]/;
  3. function isValidsStr(char) {
  4.     // return char >= '0' && char <= '9 || char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z';
  5.     return !validExp.test(char)
  6. }
  7. // 一个字符串的除了有效字符(数字,字母)从开始到结束和从结束到开始是同一个字符串
  8. function isPalindrome(str) {
  9.     if (str.length === 0) {
  10.         return true;
  11.     }
  12.     let left = 0, right = str.length - 1;
  13.     while (left < right) {
  14.         var leftChar = str[left];
  15.         var rightChar = str[right];
  16.         if (isValidsStr(leftChar)) {
  17.             left++;
  18.         } else if (isValidsStr(rightChar)) {
  19.             right--;
  20.         } else if (leftChar != rightChar) {
  21.             return false;
  22.         } else {
  23.             left++;
  24.             right--;
  25.         }
  26.     }
  27.     return true;
  28. }
  30. const result = isPalindrome('a b,c*d,ef$e  ,dc  b,a');
  31. console.log('是否是回文串', result ? '是' : '不是')

对撞指针实现数组翻转

  1. /**
  2.  * 
  3.  * @param {Array} arr 
  4.  */
  5. function  reverse(arr){
  6.    if(!arr.length){
  7.     return ;
  8.    }
  9.    let i=0,j=arr.length-1;
  10.    while(i<j){
  11.     swap(arr,i,j);
  12.     i++;
  13.     j--;
  14.    }
  15.    return arr;
  16. }
  17. /**
  18.  * 
  19.  * @param {Array} arr 
  20.  * @param {Number} i 
  21.  * @param {Number} j 
  22.  */
  23. function swap(arr,i,j){
  24.   let temp=arr[i];
  25.   arr[i]=arr[j];
  26.   arr[j]=temp;
  27. }
  28. const arrs=[1,4,3,6,8,9,0]
  29. console.log('原数组',arrs);
  30. console.log('排序后的数组',reverse(arrs));