编程笔记一

最新推荐文章于 2024-08-14 08:34:35 发布

AraSauHan

最新推荐文章于 2024-08-14 08:34:35 发布

阅读量116

点赞数

文章标签：字符串

本文链接：https://blog.csdn.net/qq_42018838/article/details/103611488

版权

本文探讨了编程中的三个经典问题：有序二维数组查找、替换字符串空格和从尾到头打印链表。针对每个问题，分别提供了暴力求解和优化算法，并分析了它们的时间和空间复杂度。优化后的解法利用了矩阵特性、后向插入和堆栈，显著提高了效率。

摘要由CSDN通过智能技术生成

编程笔记一

1.有序二维数组查找
2.替换空格
3.从尾到头打印链表

1.有序二维数组查找

题目：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M

解法一（暴力求解）：

基于顺序查找算法（属于无序查找算法），对数组进行顺序搜索。

时间复杂度： $O (n * m)$ （n行m列矩阵）
空间复杂度： $O (1)$

C++实现

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int row = array.size();
        int column = array[0].size();
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < column; j++)
            {
                if (array[i][j] == target)
                {
                    return true;
                }
            }
        }
        return false;
    }
};

运行时间：11ms
占用内存：1504k

Python实现

class Solution:

    # array 二维列表
    def Find(self, target, array):
        for i in array:
            for j in i:
                if j == target:
                    return True
        return False

运行时间：415ms
占用内存：5700k

解法二（矩阵特性）：

题目中的矩阵特性：矩阵行递增，列递增。因此，可以通过选择极限位置（矩阵左下角：列MAX，行MIN，或者矩阵右上角：列MIN，行MAX），因此只需要target与matrix[i][j]比较即可。
极限位置以矩阵左下角（列MAX，行MIN）例：

$a r r a y [i] [j] < t a r g e t$ ，判断 $a r r a y [i] [j + 1]$ 和 $t a r g e t$ 的关系；
$a r r a y [i] [j] > t a r g e t$ ，判断 $a r r a y [i - 1] [j]$ 和 $t a r g e t$ 的关系；
$a r r a y [i] [j] = t a r g e t$ ，返回true
$i < 0 ∣ ∣ j > = c o l u m n$ ，返回false

时间复杂度： $O (n + m)$
空间复杂度： $O (1)$

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int row = array.size();
        int column = array[0].size();
        int i = row - 1;
        int j = 0;
        while(i >= 0 && j < column)
        {
            if (array[i][j] == target)
                return true;
            if(array[i][j] < target)
                j++;
            else
                i--;
        }
        return false;
    }
};

运行时间：11ms
占用内存：1344k

2.替换空格

题目：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M

解法一（后向前插）：

class Solution {
public:
void replaceSpace(char *str, int length)
{
	int oldLen = 0;
	int newLen = 0;
	int spaceNum = 0;
	int i = 0;
	int j = 0;
	while (str[i] != '\0')
	{
		oldLen++;
		if (str[i] == ' ')
		{
			spaceNum++;
		}
		i++;
	}

	newLen = oldLen + spaceNum * 2;
	while (oldLen >= 0 && newLen > oldLen)
	{
		if (str[oldLen] == ' ')
		{
			str[newLen--] = '0';
			str[newLen--] = '2';
			str[newLen--] = '%';
		}
		else {
			str[newLen] = str[oldLen];
			newLen--;
		}
		oldLen--;
	}
}
};

运行时间：4ms
占用内存：612k

3.从尾到头打印链表

题目：输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M

解法一（基于reverse函数）：

class Solution {
public:
	vector<int> printListFromTailToHead(ListNode* head) {
		vector<int> arr;
		ListNode *p = head;
		while (p != NULL)
		{
			arr.push_back(p->val);
			p = p->next;
		}
		reverse(arr.begin(), arr.end());

		return arr;
	}
};

运行时间：4ms
占用内存：480k

解法二（基于stack）：
利用stack的FIFO的特性

class Solution {
public:
	vector<int> printListFromTailToHead(ListNode* head) {
		vector<int> arr;
		stack<int> stk;
		ListNode *p = head;
		while (p != NULL)
		{
			stk.push(p->val);
			p = p->next;
		}
		
		while (!stk.empty())
		{
			arr.push_back(stk.top());
			stk.pop();
		}
		return arr;
	}
};