三、字符串与矩阵

最新推荐文章于 2023-02-20 19:10:03 发布

小幸运安然

最新推荐文章于 2023-02-20 19:10:03 发布

阅读量1.2k

点赞数

分类专栏：数据结构与算法文章标签： BF算法 KMP算法对称矩阵与三角矩阵对角矩阵与稀疏矩阵

余笙

本文链接：https://blog.csdn.net/qq_42200163/article/details/117476415

版权

数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、字符串

1、字符串定义

字符串string（简称串）：是由零个或多个字符组成的有限序列。一般记为 $S="a_1a_2...a_n"(n>=0)$ ，其中，S是串名，双引号是定界符（避免字符串与变量名或数的常量混淆），双引号包裹的内容就是串值。长度为0的串称为空串，记作""，空串不包含任何字符。由一个或多个空格组成的串称为空格串，其长度就是串中包含的空格数。

子串：字符串中任意个连续的字符组成的子序列称之为该串的子串。包含子串的串相应地称为主串。某个字符在串中的序号称为该字符在串中的位置。子串在主串中的位置以子串的第一个字符在主串中的位置来表示。当两个串的长度相等且每个对应位置上的字符都相等时，称这两个串是相等的。

2、字符串的存储结构

字符串是数据元素为单个字符的线性表，一般采用顺序存储结构（因为链式存储结构的空间利用率低），用一组地址值连续的存储单元存储串中的字符序列（如：数组）。

字符串长度表示三种方式：

定义一个变量来表示串的长度。

用数组索引为0的位置来存放串的长度，串值从索引为1的位置开始存放。

在串末尾存储一个不会在串中出现的特殊字符作为字符串的终结符“\0”，这种方式不能直接得到串的长度，而是通过判断当前字符是否为“\0”来确定串是否结束，从而求得串的长度。

3、字符串的匹配模式

给定两个字符串S=" $s_1s_2...s_n$ “和T=” $t_1t_2...tn$ "，在主串S中寻找子串T的过程就称之为字符串的模式匹配（pattern matching），T称为模式（pattern）。如果匹配成功，则返回T在S中的位置；匹配失败返回-1。

4、模式匹配BF算法

BF（Brute-Force）算法的基本思想就是暴力匹配，即从主串S的第一个字符开始和模式T的第一个字符进行比较。若相等，则继续比较两者后续的字符串；否则，从主串S的下一个字符开始和模式T的第一个字符进行比较。重复上述过程，直至S或T中的所有字符串比较完毕。若T中的字符全部比较完毕，则证明匹配成功，返回本趟匹配的开始位置；否则就证明匹配失败，返回-1即可。

回溯到主串下一个字符索引位置的计算公式：x = x - y + 1

算法实现：

/**
 * BF算法实现
 */
public class BfAlgorithm {
    /**
     * 返回BF匹配的索引位置
     * @param lead 主串
     * @param child 子串
     * @return
     */
    public static int bfSearch(String lead,String child) {
        //定义一个指针，指向主串的第一个字符位置
        int x = 0;
        //定义一个指针，指向子串的第一个字符位置
        int y = 0;
        //循环遍历匹配
        while (x < lead.length() && y < child.length()) {
            //判断同一位置上的子串是否相等
            if (lead.charAt(x) == child.charAt(y)) {
                //继续匹配下一个字符
                x ++;
                y ++;
            } else {
                //不匹配就从主串下一个字符位置开始从新与子串匹配
                x = x - y + 1;
                y = 0;
            }
        }
        //判断模式串是否遍历完成，遍历完成则匹配成功，返回匹配位置
        if (y == child.length()) {
            return x - y;
        } else {
            //不匹配返回-1
            return -1;
        }
    }
}

@Test
public void test1() {
    String lead = "absabcabcd";
    String child1 = "abcde";
    String child2 = "abc";
    int index1 = BfAlgorithm.bfSearch(lead, child1);
    int index2 = BfAlgorithm.bfSearch(lead, child2);
    System.out.println(index1);
    System.out.println(index2);
}
/** 运行结果 */
-1
3

5、BF算法的时间复杂度

假设主串S的长度为n，子串T的长度为m，在匹配成功的情况下，考虑最坏的时间复杂度，每次匹配失败都发生在子串T的最后一个字符。

主串S=“AAAAAAAAAAAAB”，子串T=“AAAB”，那么前n-m次不成功的匹配了 $(n - m) * m$ 次，最后又比较了子串长度的次数即m次，则总共匹配了 $(n - m) * m + m$ 次，若m<n，则BF算法的时间复杂度为：O(n*m)。

6、KMP算法概述

KMP算法是一种改进的字符串匹配算法。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数，从而达到快速匹配的目的。具体实现方式为，主串的指针不回溯，通过修改模式串的指针的指向，从而让模式串尽量的移动到有效的位置，这样就提高了字符串的匹配效率。需要借助next数组来确定每次模式串指针的指向。

next数组的作用：当主串指针x和模式串指针y指向的字符不同时，那么就让模式串指针指向next[y]对应的位置的字符与x指针位置字符进行对比。

7、next数组的推导过程

首先了解几个概念：

前缀：指的是除最后一个字符之外，剩余字符组成的字符串称之为前缀。如，字符串ABABA的前缀是ABAB。

后缀：指的是除第一个字符之外，剩余字符组成的字符串称之为后缀。如，ABABC的后缀就是BABC。

前缀组合：指的是除最后一个字符之外，一个字符串的全部头部组合称之为前缀组合。如，字符串ABAB的前缀组合有A、AB、ABA。

后缀组合：指的是除第一个字符之外，一个字符串的全部尾部组合称之为后缀组合。如，字符串ABAB的后缀组合有BAB、AB、B。

next数组保存就是已匹配过模式串前缀的“最长可匹配前缀子串”和“最长可匹配后缀子串”的最长的共有元素的长度。例如，主串索引x=5对应的字符和模式串索引y=4对应的字符不等，此时已匹配模式串的字符串是ABABC，字符串ABABC的前缀就为ABAB，则对应的最长可匹配前缀子串和最长可匹配后缀子串就是AB，也就是ABAB的最长共有元素长度就是2，也就是next[4]存放的元素值为2。

推导过程：

特殊说明一下，当索引为8的时候，字符串前缀为ABABCABA，此时它的前缀组合和后缀组合如下：

前缀组合有：A、AB、ABA、ABAB、ABABC、ABABCA、ABABCAB

后缀组合有：A、BA、ABA、CABA、BCABA、ABCABA、BABCABA

此时，前缀和后缀共有的元素有A，ABA，当时最长的共有元素为ABA，因此最长共有元素长度就为3。

8、匹配流程分析

1、x和y指针分别指向主串和模式串的第一个字符，但是两个字符不相等，那么y=next[0]=-1，此时需要将x与y指针都向后面移动一位，即x=1,y=0，继续匹配。

2、此时发现x、y指针指向的字符匹配成功，则x、y指针分别向后移动一位，即x=2,y=1，直到x=5,y=4时字符匹配失败，那么x=5,y=next[4]=2，继续匹配。

3、此时发现x、y指针指向的字符匹配成功，则x、y指针分别向后移动一位，即x=6,y=3，此时发现字符匹配失败，x指针不变，x=6,y=next[3]=1，继续匹配。

4、此时发现x、y指针指向的字符匹配失败，x指针不变，x=6,y=next[1]=0，继续匹配。

5、此时发现x、y指针指向的字符匹配失败，发现y=next[0]=-1，此时需要将x与y指针都向后面移动一位，即x=7,y=0，继续匹配。

6、此时发现x、y指针指向的字符匹配成功，则x、y指针向后移动一位，经过几次比较，发现后面几次都匹配成功，最后一次匹配成功的指针位置为x=16,y=9，这时x、y仍继续向后移动一位即x=17,y=10，发现模式串已经遍历完成（都匹配成功），此时返回匹配的位置即x-y=7。

算法实现：

/**
 * KMP算法实现
 */
public class KmpAlgorithm {
    public static void main(String[] args) {
        String str = "BABABACABABCABAABD";
        String sub = "ABABCABAAB";
        int[] next = getNext(sub);
        System.out.println(Arrays.toString(next));
        System.out.println(kmpSearch(str,sub));
    }

    /**
     * 计算next数组的值
     * @param child 模式串
     * @return
     */
    public static int[] getNext(String child) {
        //定义一个next数组
        int [] next = new int[child.length()];
        //设置第一个元素为-1
        next[0] = -1;
        //索引值
        int y = 0;
        //对应的最长共有元素长度
        int len = -1;
        while (y < child.length() - 1) {
            //len = -1，处于起始位置||判断len和y指向模式串中的字符匹配成功
            if (len == -1 || child.charAt(len) == child.charAt(y)) {
                //如果len和y指向的字符相等，那么就执行next[y] = next[len]
                if (child.charAt(++ len) == child.charAt(++ y)) {
                    next[y] = next[len];
                } else {
                    next[y] = len;
                }
            } else {
                //字符匹配失败，len回退。直到找到和y指针相同的字符，停止回退。
                len = next[len];
            }
        }
        return next;
    }

    /**
     * kmp算法实现
     * @param lead 主串
     * @param child 模式串
     * @return
     */
    public static int kmpSearch(String lead,String child) {
        //计算next数组
        int[] next = getNext(child);
        //定义一个指针，指向主串第一个字符
        int x = 0;
        //定义一个指针，指向模式串第一个字符
        int y = 0;
        //循环匹配
        while (x < lead.length() && y < child.length()) {
            //判断下标所对应的字符是否相等，y=-1，表示第一个字符不匹配
            if (y == -1 || lead.charAt(x) == child.charAt(y)) {
                x ++;
                y ++;
            } else {
                //匹配失败，y会退到特定位置next[y]
                y = next[y];
            }
        }
        if(y == child.length()) {
            //子串遍历完成,返回匹配成功时 i 的起始位置。
            return x - y;
        }else {
            // 没找到
            return -1;
        }
    }
}

二、矩阵

1、对称矩阵

对称矩阵（Symmetric Matrices）是指以主对主对角线为对称轴，各元素对应相等的矩阵。假设对称矩阵是n阶矩阵，则必有arr[i][j] = arr[j][i]的特点。

2、对称矩阵的压缩存储原理

对称矩阵关于主对角线对称，因此只需要存储下三角形部分（包含对角线）即可。对于一个n阶对称矩阵，原来需要n * n个存储单元，现在只需要n * (n + 1) / 2个存储单元，节约了大约一半的存储空间，当n较大时，这是可观的一部分存储资源。

由于下三角形共有n * (n + 1) / 2个元素，因此可以将这些元素按行存储到一个一维数组中即可。如下所示，将下三角形中的元素arr[i][j]（i>=j）就存储到了一维数组。当i>=j时，此时一维数组中下标k和i、j的关系为k = i * (i + 1) / 2 + j。例如对称矩阵中arr[4][3]对应在一维数组中的索引就为13。当i<j时，此时一维数组中下标k和i、j的关系为k = j * (j + 1) / 2 + i。例如，对称矩阵中元素arr[3][4]对应一维数组中的索引为13。

算法实现：

/**
 * 对称矩阵
 */
public class SymmetricMatrix {
    public static void main(String[] args) {
        int [][] matrix = {
                {3,6,4,7,8},
                {6,2,8,4,2},
                {4,8,1,6,9},
                {7,4,6,0,5},
                {8,2,9,5,7}
        };
        //压缩后的矩阵为
        int[] compress = compress(5, matrix);
        System.out.println(Arrays.toString(compress));
        //解压
        int[][] decompression = decompression(5, compress);
        for (int i = 0; i < 5; i++) {
            System.out.println(Arrays.toString(decompression[i]));
        }
    }

    /**
     * 实现对称矩阵的压缩存储
     * @param order 对称矩阵的阶数
     * @param matrix 需要压缩的对称矩阵
     * @return 返回一维数组
     */
    public static int[] compress(int order, int [][] matrix) {
        //初始化一维数组，用于保存压缩后的元素
        int [] arr = new int[order * (order + 1) / 2];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j <= i; j++) {
                //保存元素到数组
                arr[i * (i + 1) / 2 + j] = matrix[i][j];
            }
        }
        //返回一维数组
        return arr;
    }

    /**
     * 实现矩阵解压缩
     * @param order 矩阵的阶数
     * @param arr 压缩后的矩阵
     * @return 返回解压后的矩阵
     */
    public static int[][] decompression(int order, int[] arr) {
        //初始化矩阵
        int [][] matrix = new int[order][order];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                //解压操作
                if (i >= j) {
                    matrix[i][j] = arr[i * (i + 1) / 2 + j];
                } else {
                    matrix[i][j] = arr[j * (j + 1) /2 + i];
                }
            }
        }
        //返回矩阵
        return matrix;
    }
}

3、三角矩阵

以主对角线划分三角矩阵有下三角矩阵和上三角矩阵。

下三角矩阵：主对角线以上部分均为同一个常数。

上三角矩阵：主对角线以下部分均为同一个常数。

4、三角矩阵的压缩存储原理

下三角矩阵的压缩存储于对称矩阵类似，不同之处仅在于除了要存储下三角形以及主对角线中的元素之外，还要存储主对角线上方的常数。因为是同一个常数，所以只存储一个即可。对于一个n阶下三角矩阵，则一共存储了n * (n + 1) / 2 + 1个元素。然后，将下三角形以及主对角线中的元素按行存储进一维数组中，最后再存储主对角线上方的常数。

上三角矩阵的压缩存储于下三角矩阵类似，依旧是按行存储上三角形以及主对角线中的元素，最后存储主对角线下方的常数。

算法实现：

/**
 * 下三角矩阵
 */
public class TriangleMatrix {
    public static void main(String[] args) {
        int [][] triangle = {
                {3,7,7,7,7},
                {6,2,7,7,7},
                {4,8,1,7,7},
                {7,4,6,0,7},
                {8,2,9,5,8}
        };
        int[] compress = compress(5, triangle);
        System.out.println("-------------压缩后的矩阵-------------");
        System.out.println(Arrays.toString(compress));
        System.out.println("-------------解压缩后的矩阵-------------");
        int[][] decompression = decompression(5, compress);
        for (int i = 0; i < 5; i++) {
            System.out.println(Arrays.toString(decompression[i]));
        }
    }

    /**
     * 实现下三角矩阵的压缩存储
     * @param order 下三角矩阵的阶数
     * @param triangle 需要压缩的下三角矩阵
     * @return 返回一维数组
     */
    public static int[] compress(int order, int [][] triangle) {
        //初始化一维数组，用于保存压缩后的元素
        int [] arr = new int[order * (order + 1) / 2 + 1];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j <= i; j++) {
                //保存元素到数组
                arr[i * (i + 1) / 2 + j] = triangle[i][j];
            }
        }
        //存储主对角线上面的常数
        arr[order * (order + 1) / 2] = triangle[0][1];
        //返回一维数组
        return arr;
    }

    /**
     * 实现矩阵解压缩
     * @param order 矩阵的阶数
     * @param arr 压缩后的矩阵
     * @return 返回解压后的矩阵
     */
    public static int[][] decompression(int order, int[] arr) {
        //初始化矩阵
        int [][] triangle = new int[order][order];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                //解压操作
                if (i >= j) {
                    triangle[i][j] = arr[i * (i + 1) / 2 + j];
                } else {
                    triangle[i][j] = arr[order * (order + 1) / 2];
                }
            }
        }
        //返回矩阵
        return triangle;
    }
}

5、对角矩阵

在对角矩阵中，所有非零元素都集中在以主对角线为中心的带状区域，除了主对角线和若干条次对角线的元素之外，其余位置的元素都为零。假设对角矩阵是n阶矩阵，变量i（0 <= i <= n-1）和j（0 <= j <= n-1）代表就是矩阵中的索引，则满足|i - j| <= 1的元素就是带状区域的元素。

6、对角矩阵的压缩存储原理

对角矩阵的压缩存储就是将带状区域的元素逐行存储到一维数组中，也就是把|i - j| <= 1位置的元素存入到一维数组中。假设在一个n阶对角矩阵中，每一行带状区域的元素最多为3个，则带状区域一共有(3 - 1) * 2 + (n -2) * 3个元素，然后将其按行存入一维数组中。

在一维数组中下标k和i、j的关系为k = 2 * i + j，对称矩阵中元素arr[]4[3]对应一维数组中的索引为11。

算法实现：

/**
 * 对角矩阵
 */
public class DiagonalMatrix {
    public static void main(String[] args) {
        int [][] diagonal = {
                {3,6,0,0,0},
                {6,2,7,0,0},
                {0,8,1,7,0},
                {0,0,6,0,7},
                {0,0,0,5,8}
        };
        int[] compress = compress(5, diagonal);
        System.out.println("-------------压缩后的矩阵-------------");
        System.out.println(Arrays.toString(compress));
        System.out.println("-------------解压缩后的矩阵-------------");
        int[][] decompression = decompression(5, compress);
        for (int i = 0; i < 5; i++) {
            System.out.println(Arrays.toString(decompression[i]));
        }
    }

    /**
     * 实现对角矩阵的压缩存储
     * @param order 对角矩阵的阶数
     * @param diagonal 需要压缩的对角矩阵
     * @return 返回一维数组
     */
    public static int[] compress(int order, int [][] diagonal) {
        //初始化一维数组，用于保存压缩后的元素
        int [] arr = new int[(3 - 1) * 2 + (order -2) * 3];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                //判断元素是不是在带状区域中
                if (Math.abs(i - j) <= 1) {
                    //保存元素到数组
                    arr[2 * i + j] = diagonal[i][j];
                }
            }
        }
        //返回一维数组
        return arr;
    }

    /**
     * 实现矩阵解压缩
     * @param order 矩阵的阶数
     * @param arr 压缩后的矩阵
     * @return 返回解压后的矩阵
     */
    public static int[][] decompression(int order, int[] arr) {
        //初始化矩阵
        int [][] diagonal = new int[order][order];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                //解压操作
                if (Math.abs(i - j) <= 1) {
                    //保存元素到数组
                    diagonal[i][j] = arr[2 * i + j];
                }
            }
        }
        //返回矩阵
        return diagonal;
    }
}

7、稀疏矩阵

稀疏（sparse）矩阵（稀疏数组）是一个十分有效的存储结构，在特定场景下能够节省存储空间，可以看作普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组。

意义：一个二维数组中有大量位置是空着的，或者为同一值的数组时，这样存储会浪费很多内存空间，这时可以采用稀疏数组来存储数据，可以节省存储空间以避免资源不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率。

8、稀疏矩阵结构

稀疏矩阵包括两部分：

第一部分是稀疏数组的第一行数据，记录了原数组的总行数、总列数、总有效数据的数量。

第二部分是稀疏数组除第一行以外的数据，记录了原二维数组的行、列、有效值。

9、稀疏矩阵实现压缩存储

public class SparseArray {
    public static void main(String[] args) {
        //定义棋盘，创建一个二维数组，0表示没有棋子，1表示黑子，2表示白子
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        System.out.println("===========原始二维数组===========");
        print(chessArr1);
        //将二维数组转为稀疏数组，遍历数组获取有效数据个数
        int num = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    num ++;
                }
            }
        }
        //创建稀疏数组
        int[][] sparseArr = new int[num + 1][3];
        //稀疏数组初始化
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = num;
        //用于记录第几个有效数据
        int count = 0;
        //遍历二维数组，出现有效数据就存放稀疏数组中
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        System.out.println("===========转换成的稀疏数组===========");
        print(sparseArr);

        //根据稀疏数组初始化原始数组，第一行数据存放的是数组信息
        int [][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        //从数组下标为1开始写入数据
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        System.out.println("===========还原后的二维数组===========");
        print(chessArr2);
    }

    private static void print(int[][] array) {
        Arrays.stream(array).forEach(rows ->{
            Arrays.stream(rows).forEach(cols -> {
                System.out.format("%d ",cols);
            });
            System.out.println();
        });
    }
}
/** 运行结果 */
===========原始二维数组===========
0 0 0 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 
0 0 0 2 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
===========转换成的稀疏数组===========
11 11 2 
1 2 1 
2 3 2 
===========还原后的二维数组===========
0 0 0 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 
0 0 0 2 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0

小幸运安然

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
三、字符串与矩阵

一、字符串1、字符串定义字符串string（简称串）：是由零个或多个字符组成的有限序列。一般记为S="a1a2...an"(n>=0)S="a_1a_2...a_n"(n>=0)S="a1a2...an"(n>=0)，其中，S是串名，双引号是定界符（避免字符串与变量名或数的常量混淆），双引号包裹的内容就是串值。长度为0的串称为空串，记作""，空串不包含任何字符。由一个或多个空格组成的串称为空格串，其长度就是串中包含的空格数。子串：字符串中任意个连续的字符组成的子序列称之为该串
复制链接

扫一扫