数据结构训练基础

数据结构基础训练

---

数组与字符串

数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

字符串实际上是使用 null 字符 \0 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

---

一、学习重点

声明数组、初始化数组、访问数组元素

C++ 中的 String 类
（动态规划、中心扩散法）

二、学习心得

1.合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

链接：link.
来源：力扣（LeetCode）

class Solution{
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals)
    {
        vector<vector<int>> A;
        sort(intervals.begin(), intervals.end());
        for(int i = 0; i < intervals.size(); i++)
        {
            int L = intervals[i][0], R = intervals[i][1];
            if((!A.size()) || (A.back()[1] < L)) A.push_back({L, R});
            else A.back()[1] = max(A.back()[1], R);
        }
        return A;
    }
};

学到了vector这种结构，
能用push_back就不要用insert，能用pop_back就不要用erase，
时间复杂度后者是O(n)，前者是O(n)。

2.对角线遍历

给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。

链接：link.
来源：力扣（LeetCode）

class Solution {
public:
    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        if(matrix.empty())
            return ans;
        int row = matrix.size(), col = matrix[0].size(), c = 0, r = 0;
        for(int i = 0; i < row+col-1; i++)
        {
            if(i % 2)
            {
                c = (i < col) ? i : col-1;
                r = i - c;
                while(c >= 0 && r < row)
                    ans.push_back(matrix[r++][c--]);
            }
            else
            {
                r = (i < row) ? i : row-1;
                c = i - r;
                while(c < col && r >= 0)
                    ans.push_back(matrix[r--][c++]);
            }
        }
        return ans;
    }
};

二维数组的对角线遍历，要画图。
有两个特点:
1.第一个是对角线上的数据（x,y）对应 x+y 的值都是一致的。
2.当 x+y 为奇数时对角线上的数据正序输出，为偶数时倒叙输出

3.最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

链接：link.
来源：力扣（LeetCode）

class Solution {
public:
    string longestPalindrome(string s) {
        int p[1000][1000];
        int x=s.size();
        int a=1;
        int k1=0;
        if(x==1) return s;
        if(x==2)
        {
            if(s[0]==s[1]) return s;
            else return s.substr(0,1);
        }
        for(int i=0;i<x;i++)
        {
            p[i][i]=1;
            if(i<x-1)
            {
                if(s[i]==s[i+1]) p[i][i+1]=1;
                else p[i][i+1]=0;
            }
        }
        for(int l=3;l<=x;l++)
            for(int i=0;i+l-1<x;i++)
            {
                if(s[i]==s[i+l-1]&&p[i+1][i+l-2]==1) p[i][i+l-1]=1;
                else p[i][i+l-1]=0;
            }
        for(int i=0;i<x;i++)
            for(int j=i;j<x;j++)
                if(p[i][j]==1&&j-i+1>a)
                {
                    a=j-i+1;
                    k1=i;
                }
        return s.substr(k1,a);
    }
};

1、动态规划：
从长度length为1，到长度s.size()进行遍历，每个长度都从i = 0开始遍历，
结尾j = i + length - 1
if length == 1， dp[i][j] == 1
else if length == 2, dp[i][j] = (s[i] == s[j])
else dp[i][j] = (s[i] == s[j] && dp[i+1][j-1])

2、中心扩散法：
从前面的判断可以知道，dp[i][j] -> dp[i - 1][j + 1] -> dp[i - 2][j + 2] -> … -> 某个边界结束，
得到边界条件为 length == 1 或者 length == 2，我们以这个边界作为中心，进行循环扩散，直到两边的值不相同为止，然后返回这个边界下标，用于给外面判断最长字串，在得到中心扩散方法后，遍历字符串，以索尼i为基准的两个边界进行扩散，然后计算出最大的字串索引，遍历完成，直接返回最长子串。

---