LC：字符串转换整数 (atoi) + 外观数列 + 最长公共前缀 + 回文链表

MyDreamingCode

已于 2022-07-16 19:23:21 修改

阅读量89

点赞数

分类专栏：算法 javascript 文章标签：算法 js

于 2022-07-04 22:51:21 首次发布

本文链接：https://blog.csdn.net/qq_61706112/article/details/125610302

版权

javascript 同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

算法

6 篇文章 0 订阅

订阅专栏

1. 请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。

函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。确定最终结果是负数还是正数。如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
返回整数作为最终结果。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var s = "-91283472332";
        var myAtoi = function(s) {
            s = s.trim();
            var sign = 1;
            var index = 0;
            if(s.length<0) return 0 ;
            if(s[index]==='+' || s[index]==='-'){
                if(s[index]==='-')
                    sign = -1;
                index++;
            }
            var res = 0;
            while(index<s.length){
                if(s.charCodeAt(index)-'0'.charCodeAt(0)<0||s.charCodeAt(index)-'0'.charCodeAt(0)>9)
                    break;
                else{
                    res = Number(res * 10) + Number(s[index]);
                }
                index++;
            }
            if((res>(Math.pow(2,31) - 1))&&sign>0)
                return Math.pow(2,31) - 1;
            if((res>Math.pow(2,31))&&sign<0)
                return -Math.pow(2,31);
            return res * sign;
        };
        console.log(myAtoi(s)); //-2147483648
    </script>
</body>
</html>

2. 给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

1. 1

2. 11

3. 21

4. 1211

5. 111221

6. 312211

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        var countAndSay = function(n) {
            if(n==1) return '1';
            var s = countAndSay(n-1);
            var num = 0;
            var str = '';
            var count = 0;
            var flag = 0;
            for(var i=0;i<s.length;i++){
                if(s[i]==s[num]){
                    count++;
                    flag = 0;
                }
                else{
                    flag = 1;
                    str += count + s[num];
                    num = i;
                    i = num - 1;
                    count = 0;
                }
            }
            if(!flag)
                str+= count + s[num];
            return str;
        }
        console.log(countAndSay(6)); //312211
    </script>
</body>
</html>

3. 编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        strs = ["flower","flow","flight"]; 
        var longestCommonPrefix = function(strs) {
            var pre = strs[0];
            var i = 1;
            while(i<strs.length) {
                while(strs[i].indexOf(pre)!=0)
                    pre = pre.slice(0,pre.length-1);
                i++;
            }
            return pre; //fl
        };
    </script>
</body>
</html>

4. 给你一个单链表的头节点head，请你判断该链表是否为回文链表。如果是，返回true；否则，返回false 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *reverseList(struct ListNode* head){
    struct ListNode *p=head;
    struct ListNode *q;
    head=NULL;
    while(p){
        q=p->next;
        p->next=head;
        head=p;
        p=q;
    }
    return head;
}

bool isPalindrome(struct ListNode* head){
    struct ListNode *p=head;
    struct ListNode *q=head;
    int count=0;
    int i=0;
    int j=0;
    while(q){
        count++;
        q=q->next;
    }
    if(count==1)
        return true;
    q=head;
    if(count%2==0){
        while(i<count/2){
            q=q->next;
            i++;
        }
    }else if(count%2!=0){
        while(i<count/2+1){
            q=q->next;
            i++;
        }
    }
    q=reverseList(q);
    while(j<count/2){
        if(p->val!=q->val)
            return false;
        p=p->next;
        q=q->next;
        j++;
    }
    return true;
}