连续子数组的最大和、回文数索引、把数组排成最小的数、两个链表的第一个公共结点、二叉树的深度

小朱同学..

已于 2022-11-29 10:30:03 修改

阅读量147

点赞数 3

分类专栏：刷题专栏文章标签：算法数据结构 leetcode c++ 动态规划

于 2022-11-28 13:38:10 首次发布

本文链接：https://blog.csdn.net/C_Trip/article/details/128075303

版权

刷题专栏专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

1、连续子数组的最大和
2、回文数索引
3、把数组排成最小的数
4、两个链表的第一个公共结点
5、二叉树的深度

1、连续子数组的最大和

本题考点： 动归问题牛客链接

题目描述：
输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，子数组最小长度为1。求所有子数组的和的最大值。
数据范围:
1 <= n <= 2 * 10^5
−100<=a[i]<=100
要求:时间复杂度为 O(n)，空间复杂度为 O(n)
进阶:时间复杂度为 O(n)，空间复杂度为 O(1)

解题思路：
在这里插入图片描述
代码：

class Solution {
public:
	/方法一：
    int FindGreatestSumOfSubArray(vector<int> array) {
        vector<int> sum(array.size());
        sum[0] = array[0];

        int max_sum = sum[0];
        for(int i = 1; i < array.size(); i++)
        {
            sum[i] = max(sum[i - 1] + array[i], array[i]);
            if(max_sum < sum[i])
                max_sum = sum[i];
        }

        return max_sum;
    }
	
	/方法二
    int FindGreatestSumOfSubArray(vector<int> array) {
        int max_sum = array[0];

        int total = array[0]; // 当前累计和

        for(int i = 1; i < array.size(); i++)
        {
            if(total < 0)
            {
                total = array[i];
            }
            else
            {
                total += array[i];
            }

            if(max_sum < total)
                max_sum = total;
        }

        return max_sum;
    }
};

2、回文数索引

本题考点： 字符串操作牛客链接

题目描述：
给定一个仅由小写字母组成的字符串。现在请找出一个位置，删掉那个字母之后，字符串变成回文。请放心总会有一个合法的解。如果给定的字符串已经是一个回文串，那么输出-1。

输入描述：
第一行包含T，测试数据的组数。后面跟有T行，每行包含一个字符串。
输出描述：
如果可以删去一个字母使它变成回文串，则输出任意一个满足条件的删去字母的位置（下标从0开始）。例如：bcc我们可以删掉位置0的b字符。

解题思路：

可以从两侧进行统计，如果不同，则删除任意一个，在判定是否是回文，如果是，下标就是删除数据的下标，如果不是，就是另一个元素的下标

代码：

#include <iostream>
#include <string>
using namespace std;

/判断是否是回文结构(两个功能,判断并带下标返回,默认写的是不带)
bool isPalindrom(string& str, int* begin = nullptr, int* end = nullptr)
{
    int left = 0, right = str.size() - 1;
    bool flag = true;
    while(left < right)
    {
        if(str[left] != str[right])
        {
            flag = false;
            break;
        }
        
        left++;
        right--;
    }
    if(begin) *begin = left;
    if(end) *end = right;
    return flag;
}

int main()
{
    int n = 0;
    cin >> n;
    string str;
    while(n--)
    {
        cin >> str;
        int begin = 0, end = 0;
        if(isPalindrom(str, &begin, &end))
        {
            cout << -1 << endl;
        }
        else
        {
            str.erase(end, 1);  /试着删一个,在进行判断
            if(isPalindrom(str))
                cout << end << endl;
            else
                cout << begin << endl;
        }
    }
    return 0;
}

3、把数组排成最小的数

本题考点： 排序算法的特殊理解牛客链接

题目描述：
输入一个非负整数数组numbers，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
例如输入数组[3，32，321]，则打印出这三个数字能排成的最小数字为321323。
1.输出结果可能非常大，所以你需要返回一个字符串而不是整数
2.拼接起来的数字可能会有前导 0，最后结果不需要去掉前导 0

数据范围:
0<=len(numbers)<=100

解题思路：
这道题很有意思，核心理解是我们对于排序算法的理解，通常我们所理解的排序是比较大小的
如：升序排序的序列意思是：序列中任何一个数字，都比前面的小，比后面的大
我们把说法换一下，对于本题，我们要的有效序列是：序列中任何一个元素y，和它前的任何一个元素x进行有序组合形成xy，比和他后面的任何一个元素z进行有效序列组合yz，满足条件xy < yz（采用字典序列排序）如{32，31}，有效组合是3132，所以我们拍完序列之后序列变成{31, 32}。故我们可以重载sort的仿函数来求解(利用字符串比较特性)。

代码：

class Solution {
public:

    static bool cmp(int a, int b)
    {
        string sa = to_string(a);
        string sb = to_string(b);
        
        string A = sa + sb;
        string B = sb + sa;

        return A < B;
    }
    string PrintMinNumber(vector<int> numbers) {
        if(numbers.size() == 0)
            return "";

        string retStr;
        sort(numbers.begin(), numbers.end(), cmp);
        for(int i = 0; i < numbers.size(); i++)
        {
            retStr += to_string(numbers[i]);
        }
        return retStr;
    }
};

4、两个链表的第一个公共结点

本题考点： 单链表理解牛客链接

题目描述：
输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

数据范围：0n≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)

例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：
解题思路：

先计算出两个链表的长度，让长的那个链表先走差距步，然后两个链表同时走，第一个相同的节点就是第一个公共节点。

代码：

class Solution {
public:
	ListNode* ListLenth(ListNode* list, int& length)
	{
		while(list)
		{
			length++;
			list = list->next;
		}
		return list;
	}

    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == nullptr || pHead2 == nullptr)
			return nullptr;
		
		int length1 = 0, length2 = 0;
		ListNode* end1 = ListLenth(pHead1, length1);
		ListNode* end2 = ListLenth(pHead2, length2);
		
		if(end1 != end2)  /尾节点不相等说明根本就没有交点
			return nullptr;

		int n = abs(length1 - length2);
		if(length1 > length2)
		{
			while(n--)
			{
				pHead1 = pHead1->next;
			}
		}
		else
		{
			while(n--)
			{
				pHead2 = pHead2->next;
			}
		}

		while(pHead1 && pHead2)
		{
			if(pHead1 == pHead2)
				return pHead1;

			pHead1 = pHead1->next;
			pHead2 = pHead2->next;
		}

		return nullptr;
    }
};

5、二叉树的深度

本题考点： 二叉树的理解牛客链接

题目描述：
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度，根节点的深度视为 1 。

数据范围：节点的数量满足0≤n≤100 ，节点上的值满足 0≤val≤100
进阶：空间复杂度 O(1) ，时间复杂度 O(n)

解题思路：

可以使用递归方式
可以层序遍历，统计层数，也就是深度or高度

代码：


/方法一：
class Solution {
public:
    /第一种写法
    int TreeDepth(TreeNode* pRoot) {
		if(pRoot == nullptr)
			return 0;
		
		return 1 + max(TreeDepth(pRoot->left), TreeDepth(pRoot->right));
    }
	
	/第二种写法
	void _TreeDepth(TreeNode* pRoot, int depth, int& maxDepth)
	{
		if(pRoot == nullptr)
		{
			if(depth > maxDepth)
				maxDepth = depth;
			return;
		}
		
		_TreeDepth(pRoot->left, depth + 1, maxDepth);
		_TreeDepth(pRoot->right, depth + 1, maxDepth);

	}
	int TreeDepth(TreeNode* pRoot) {
		if(pRoot == nullptr)
			return 0;
		
		int depth = 0, maxDepth = 0;
		_TreeDepth(pRoot, depth, maxDepth);
		return maxDepth;
    }
};


/方法二：
class Solution {
public:

	int TreeDepth(TreeNode* pRoot) {
		if(pRoot == nullptr)
			return 0;
		queue<TreeNode* > qe;
		qe.push(pRoot);
		int depth = 0;
		while(!qe.empty())
		{

			int size = qe.size();
			depth++;

			for(int i = 0; i < size; i++) //把一层数据出完
			{
				TreeNode* front = qe.front();
				qe.pop();
				if(front->left)
					qe.push(front->left);
				if(front->right)
					qe.push(front->right);
			}

		}
		return depth;
    }
};