July算法习题 - 字符串1

1

July 程序员编程艺术:面试和算法心得题目及习题

旋转字符串

题目描述

给定一个字符串,要求把字符串前面的若干个字符移动到字符串的尾部,如把字符串 “abcdef” 前面的 2 个字符'a'和'b'移动到字符串的尾部,使得原字符串变成字符串 “cdefab”。请写一个函数完成此功能,要求对长度为 n 的字符串操作的时间复杂度为 O(n),空间复杂度为 O(1)。

解题思路:三步反转法

对于这个问题,换一个角度思考一下。

将一个字符串分成 X 和 Y 两个部分,在每部分字符串上定义反转操作,如 X^T,即把 X 的所有字符反转(如,X="abc",那么 X^T="cba"),那么就得到下面的结论:(X^TY^T)^T=YX,显然就解决了字符串的反转问题。

例如,字符串 abcdef ,若要让 def 翻转到 abc 的前头,只要按照下述 3 个步骤操作即可:

  1. 首先将原字符串分为两个部分,即 X:abc,Y:def;
  2. 将 X 反转,X->X^T,即得:abc->cba;将 Y 反转,Y->Y^T,即得:def->fed。
  3. 反转上述步骤得到的结果字符串 X^TY^T,即反转字符串 cbafed 的两部分(cba 和 fed)给予反转,cbafed 得到 defabc,形式化表示为 (X^TY^T)^T=YX,这就实现了整个反转。
java
public class RotateString { public void solution(char[]s , int k){ reverse(s,0,k-1); reverse(s,k,s.length-1); reverse(s,0,s.length-1); } private void reverse(char[]s, int start, int end){ while(start <= end) { char temp; temp = s[end]; s[end] = s[start]; s[start] = temp; start++; end--; } }

这就是把字符串分为两个部分,先各自反转再整体反转的方法,时间复杂度为 O(n),空间复杂度为 O(1),达到了题目的要求。

习题

1、链表翻转

给出一个链表和一个数 k,比如,链表为 1→2→3→4→5→6,k=2,则翻转后 2→1→6→5→4→3,若 k=3,翻转后 3→2→1→6→5→4,若 k=4,翻转后 4→3→2→1→6→5,用程序实现。

有介绍链表完全反转

这道题是基于链表反转,链表分成两部分:AB, 先反转A,然后再反转B,把AB相连即可。如图

clipboard.png

这里需要注意的是指针要记录链接位置,不要断链。

    // S = AB S' =ATBT
    public Node solution(Node phead, int k){
        Node p = phead;
        int i = 1; // A 部分反转次数
        int j = 1; // B部分反转次数
        if(p!=null){
            // A 部分反转
            Node q = p.next;
            p.next = null;
            while(q != null && i< k ){              
                Node r = q.next;
                q.next = p;
                p = q;
                q = r;
                i++;
            } // A部分反转结束,p指向结果的头指针,q指向B部分的第一个元素

            // B 部分反转
            Node qnext = q.next;
            q.next = null;
            while(qnext != null && j< n-k){             
                Node r = qnext.next;
                qnext.next = q;
                q = qnext;
                qnext = r;
                j++;
            }// B部分反转结束,q指向结果的头指针
            //连接AB两部分
            phead.next = q;
        }

        return p;
    }

2、编写程序

在原字符串中把字符串尾部的 m 个字符移动到字符串的头部,要求:长度为 n 的字符串操作时间复杂度为 O(n),空间复杂度为 O(1)。 例如,原字符串为 ”Ilovebaofeng”,m=7,输出结果为:”baofengIlove”。

同1

3、单词翻转

输入一个英文句子,翻转句子中单词的顺序,但单词内字符的顺序不变,句子中单词以空格符隔开。为简单起见,标点符号和普通字母一样处理。例如,输入 “I am a student.”,则输出 “student. a am I”。

    public void solution(char[]s){
        int start = 0;
        for(int i=0;i<s.length;i++){
            //每次交换只交换空格之间的单词,这样就能保持空格的位置不动了
            if(s[i]==' '){
            reverse(s,start,i-1);
            start = i+1;
            }
            else if(i==s.length-1){
            reverse(s,start,i);
            }
        }
        reverse(s,0,s.length-1);
    }

字符串包含

给定两个分别由字母组成的字符串 A 和字符串 B,字符串 B 的长度比字符串 A 短。请问,如何最快地判断字符串 B 中所有字母是否都在字符串 A 里?

为了简单起见,我们规定输入的字符串只包含大写英文字母,请实现函数 bool StringContains(string &A, string &B)

比如,如果是下面两个字符串:

String 1:ABCD
String 2:BAD

答案是 true,即 String2 里的字母在 String1 里也都有,或者说 String2 是 String1 的真子集。

如果是下面两个字符串:

String 1:ABCD
String 2:BCE

答案是 false,因为字符串 String2 里的 E 字母不在字符串 String1 里。

同时,如果 string1:ABCD,string 2:AA,同样返回 true。

解题思路

可以构建一个hash表,26位的数组,可以先把长字符串 a 中的所有字符都放入一个 Hashtable 里,比如a 放入 hash[0], d放入 hash3. 然后轮询短字符串 b,看短字符串 b 的每个字符是否都在 Hashtable 里,如果都存在,说明长字符串 a 包含短字符串 b,否则,说明不包含。

这样时间复杂度O(n+m),空间复杂度O(n)

还有一个更简单的方法,时间复杂度O(n+m),空间复杂度O(1)

用到了|& 操作,补充下:

0001 | 0010 = 0011
0010 & 0001 = 0000
0111 & 0100 =  0100
    boolean solution(String a, String b){
        int hash = 0;
        // 对字符串A,用位运算计算一个签名
        for(int i=0;i<a.length();i++){
            System.out.println(1<<(a.charAt(i)- 'A')
                    );
            hash = hash | (1<<(a.charAt(i)- 'A'));
        }

        for(int i=0;i<b.length();i++){
            if((hash & (1<<(b.charAt(i)- 'A'))) ==0){
                return false;
            }
        }
        return true;
    }

变位词

编程珠玑关于变位词

如果两个字符串的字符一样,但是顺序不一样,被认为是兄弟字符串,比如 bad 和 adb 即为兄弟字符串,现提供一个字符串,如何在字典中迅速找到它的兄弟字符串,请描述数据结构和查询过程。

解题思路:使用散列表 (Hash), 判断字符出现次数.

哈希表

(1)先创建hashmap,key是字符串的字符,value:统计字符串1中出现的次数;
(2)将哈希表扫描第二个字符串时,扫描到每个字符时候,为哈希表减去1,
(3)如果最后哈希表所有的值都为0,则为变位词,否则不是变位词

public static boolean checkBrother_2(char[] s1, char[] s2){
    HashMap<Character, Integer> recordTable = new HashMap<Character, Integer>();
    for(char s: s1){
        if(!recordTable.containsKey(s))
            recordTable.put(s, 1);
        else{
            recordTable.put(s, recordTable.get(s) + 1);
        }
    }

    for(char s : s2){
        recordTable.put(s, recordTable.get(s) - 1);
    }

    int count = 0;
    Collection c = recordTable.values();
    Iterator iter = c.iterator();

    while(iter.hasNext()){
        count += Math.abs((Integer) iter.next());
    }

    if(count == 0)
        return true;
    else
        return false;
}

你可能感兴趣的

载入中...