数据结构与算法题
数据结构与算法题
数组
数组中重复的数字
找出数组中重复的数字
#include <iostream>
#include "vector"
#include "set"
using namespace std;
vector<int> duplicate(vector<int> &arr, unsigned long long len);
int main(){
vector<int> arr = {0,1,2,4,4,5};
vector<int> res;
unsigned long long len = arr.size();
res = duplicate(arr, len);
for(int i:res){
cout << i <<" ";
}
return 0;
}
vector<int> duplicate(vector<int> &arr, unsigned long long len){
set<int> setInt;
vector<int> res;
for(int i:arr){
if (setInt.find(i) != setInt.end()){
res.push_back(i);
}
else{
setInt.insert(i);
}
}
return res;
}
二维数组中的查找
在一个按行按列升序的二维数组中，寻找一个整数
#include <iostream>
#include <vector>
using namespace std;
bool Find(vector<vector<int>> &array, int rows, int columns, int number);
int main() {
int r = 0, c = 0;
cout << "输出行数 r:";//规定二维数组行数
cin >> r;
cout << "输入列数 c:";//规定二维数组列数
cin >> c;
vector<vector<int>> array(r, vector<int>(c));//定义二维数组
for (int i = 0; i < r; i++)//输入r*c的二维数组
{
for (int j = 0; j < c; j++) {
cin >> array[i][j];
}
}
int number;
cout << "请输入查找目标：";
cin >> number;
bool res;
res = Find(array, r, c, number);
cout << res << endl;
return 0;
}
bool Find(vector<vector<int>> &array, int rows, int columns, int number){
bool found = false;
if(rows > 0 && columns > 0){
int row = 0;
int column = columns - 1;
while(row < rows && column >= 0){
if(array[row][column] == number){
found = true;
break;
}
else if(array[row][column] > number){
--column;
}
else{
++row;
}
}
}
return found;
}
字符串模拟操作题
反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
思路：左右指针，左指针指向第一个元素，右指针指向最后一个元素；两两互换，依次向右向左移动；直到left<right。
#include <iostream>
#include <string>
using namespace std;
void reverseString(string& s);
int main(){
string s;
cout << "请输入字符串：";
while(cin >> s){
reverseString(s);
cout << "reverseString:";
cout << s << endl;
}
return 0;
}
void reverseString(string& s){
int left = 0,right = s.size()-1;
string tmp;
while(left < right){
tmp = s.at(left);
s.at(left) = s.at(right);
s.at(right) = tmp.front();
left++;
right--;
}
}
反转字符串II
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例 1：
输入：s = "abcdefg", k = 2
输出："bacdfeg"
示例 2：
输入：s = "abcd", k = 2
输出："bacd"
思路：因为目标是反转字符串字串，所以在反转字符串的基础上，多加一层循环，每次移动2*K，并且判断字符串剩余长度。
#include <iostream>
#include <string>
using namespace std;
int reverseKString(string& s,int k);
int main(){
int k;
string s;
cout << "请输入字符串和k：";
while(cin >> s && cin>>k){
reverseKString(s, k);
cout << "reverseKString:";
cout << s << endl;
}
return 0;
}
int reverseKString(string& s,int k){
string tmp;
for(int i = 0;i < s.size();i += (2 * k)){
{
//判断剩余字符长度
//当剩余长度小于k时，全部反转
if(i + k > s.size()){
k = s.size() - i;
}
int left = i,right = i + k - 1;
while(left < right){
tmp = s.at(left);
s.at(left) = s.at(right);
s.at(right) = tmp.front();
left++;
right--;
}
}
}
return 0;
}
替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
思路：两种方法。
方法一：消耗额外的内存空间；
方法二：拓展原字符串，再使用双指针原地替换
注意：由于cin遇到空格会自动截断字符串，所以这里使用getline获取字符串流。
//方法一：使用额外内存空间
#include <iostream>
#include <string>
using namespace std;
string changeString(string& s);
int main(){
string s,res;
cout << "请输入字符串：";
getline(cin,s);//获得字符串流，遇到换行才结束输入
res = changeString(s);
cout << "changeString:";
cout << res << endl;
return 0;
}
string changeString(string& s){
string res;
for(int i = 0;i < s.size();i++){
if(s.at(i) != ' ') {
res.push_back(s.at(i));
}else{
res += "%20";
}
}
return res;
}
//方法二：扩展原字符串，原地替换
#include <iostream>
#include <string>
using namespace std;
void changeString(string& s);
int main(){
string s;
cout << "请输入字符串：";
getline(cin,s);//获得字符串流，遇到换行才结束输入
changeString(s);
cout << "changeString:";
cout << s << endl;
return 0;
}
void changeString(string& s){
int count = 0; // 统计空格的个数
int sOldSize = s.size();
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') {
count++;
}
}
// 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小
s.resize(s.size() + count * 2);
int sNewSize = s.size();
// 从后先前将空格替换为"%20"
for (int right = sNewSize - 1, left = sOldSize - 1; left < right; right--, left--) {
if (s[left] != ' ') {
s[right] = s[left];
} else {
s[right] = '0';
s[right - 1] = '2';
s[right - 2] = '%';
right -= 2;
}
}
// return s;
}
反转单词顺序
https://leetcode.cn/problems/reverse-words-in-a-string/description/
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
示例 1：
输入：s = "the sky is blue"
输出："blue is sky the"
示例 2：
输入：s = " hello world "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：
输入：s = "a good example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
思路：先删除多余空格，整体反转，再单词子串反转
#include <iostream>
#include <string>
using namespace std;
string reverseWords(string s);
void reverse(string& s, int start, int end);
void removeExtraSpaces(string& s);
int main(){
string s;
string res;
cout << "请输入字符串：";
getline(cin,s);//获得字符串流，遇到换行才结束输入
res = reverseWords(s);
cout << "changeString:";
cout << res << endl;
return 0;
}
void reverse(string& s, int start, int end){ //翻转，区间写法：左闭右闭 []
for (int i = start, j = end; i < j; i++, j--) {
swap(s[i], s[j]);
}
}
void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
int slow = 0;
for (int i = 0; i < s.size(); ++i) { //
if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
s[slow++] = s[i++];
}
}
}
s.resize(slow); //slow的大小即为去除多余空格后的大小。
}
string reverseWords(string s) {
removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
reverse(s, 0, s.size() - 1);
int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
for (int i = 0; i <= s.size(); ++i) {
if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
start = i + 1; //更新下一个单词的开始下标start
}
}
return s;
}
左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：
输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例 2：
输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"
#include <iostream>
using namespace std;
string reverseLeftWords_1(const string &s, int k);
string reverseLeftWords_2(const string &s, int k);
int main(){
string s;
int k;
cout << "请输入字符串：";
cin >> s;
cout << "请输入k：";
cin >> k;
string res, res_2;
res = reverseLeftWords_1(s, k);
res_2 = reverseLeftWords_2(s, k);
cout << res << endl;
cout << res_2 << endl;
return 0;
}
string reverseLeftWords_1(const string &s, int k){
string tmp;
for(int i = k;i < s.size();i++)
{
tmp += s.at(i);
}
for(int i = 0;i < k;i++)
{
tmp += s.at(i);
}
return tmp;
}
string reverseLeftWords_2(const string &s, int k){
return s.substr(k) + s.substr(0, k);
}
找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
示例 1：
输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
#include <iostream>
#include "vector"
using namespace std;
int strStr(const string &haystack, const string &needle);
int main(){
string haystack, needle;
cout << "请输入字符串haystack：";
cin >> haystack;
cout << "请输入字符串needle：";
cin >> needle;
int res;
res = strStr(haystack, needle);
cout << res << endl;
return 0;
}
int strStr(const string &haystack, const string &needle){
vector<int> index;
for(int i = 0;i < haystack.size();i++)
{
if(needle == haystack.substr(i, needle.size()))
{
index.push_back(i);
}
}
if(index.empty()) index.push_back(-1);
return index.front();
}
判断字符串s是否由重复子串组成
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例 1:
输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。
示例 2:
输入: s = "aba"
输出: false
示例 3:
输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
判断字符串s是否由重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是由重复子串组成
find查找元素是否存在，存在返回std::string::size_type（string的长度），不存在返回std::string::npos（size_type的最大值，用来表示一个不存在的位置）
#include <iostream>
using namespace std;
bool repeatedSubstringPattern(const string &s);
int main(){
string s;
cout << "请输入字符串s：";
cin >> s;
bool res;
res = repeatedSubstringPattern(s);
cout << res << endl;
return 0;
}
bool repeatedSubstringPattern(const string &s) {
string t = s + s;
t.erase(t.begin()); t.erase(t.end() - 1); // 掐头去尾
if (t.find(s) != std::string::npos) return true; // r
return false;
}
在字符串中找出连续递增最长的子串
输入一个字符串s（长度为n，1<=n<=1000），返回s中最长的连续递增数字子串。若有多个最长的数字子串，则返回第一个出现的子串。
关于连续递增的含义举例："12345"是连续递增，"13579"不是连续递增。
可使用提取子串函数s.substr(pos,n)，其他库函数无法使用
#include <iostream>
#include <string>
using namespace std;
string FindLongestIncreasingDigitsSubstr(const string& s);
int main(){
string s;
while(cin >> s){
if(s.size() > 1000){
cout << "Please input correct string!" << endl;
exit(1);
}
else{
string res;
res = FindLongestIncreasingDigitsSubstr(s);
cout << res << endl;
}
}
return 0;
}
string FindLongestIncreasingDigitsSubstr(const string& s){
string ans, tmp;
int left = 0;
for(int right = 0;right < s.size(); ++right)
{
if(s.at(right) >= '0' && s.at(right) <= '9')//右指针找第一个数字
{
left = right;//左指针保持在第一个数字
while(right < (s.size() - 1) && s.at(right) == s.at(right + 1) - 1)right++;//右指针找连续递增数字
tmp = s.substr(left, right - left + 1);//利用substr函数提取连续递增字符串
}
if((tmp.size() > ans.size()))//判断是否是最长字符串
{
ans = tmp;
tmp.clear();
}
}
return ans;
}
链表
反向打印链表
反向打印链表
先进后出，考虑使用栈实现。除此之外，递归本质上就是一个栈结构，也可用递归实现。
需要注意的是，用递归实现的代码可能由于链表过长导致函数调用栈溢出。
//用栈实现
#include <iostream>
#include <stack>
using namespace std;
struct Node{
int val;
Node* prev;// 上一个节点
Node* next;// 下一个节点
};
class List{
public:
Node * head;
List(){
head = nullptr;
}
void Create(){
Node* p = new Node();
p->val = 0;
p->next = NULL;
head = p;
int n;
cout << "请输入链表的长度：";
cin >> n;
cout << "请输入第 1 个值：";
cin >> p->val;
for(int i = 1;i < n;i++){
Node *q = new Node();
q->next = NULL;
cout << "请输入第 " << i+1 <<" 个值：";
cin >> q->val;
p->next = q; // 连接两个节点
p = q; // 指针指向添加的节点，方便之后添加
}
}
void PrintListReverse_byStack(Node* pHead)
{
std::stack<Node *> stNodes;
Node* cur = pHead;
while(cur != nullptr){
stNodes.push(cur);
cur = cur->next;
}
while(!stNodes.empty()){
cur = stNodes.top();
stNodes.pop();
cout << cur->val << endl;
}
}
void Output(Node* pHead)//输出链表的数据域和指针域
{
if (pHead == NULL) {
cout << "该表为空表" << endl;
}
Node *current = pHead;
while (current != NULL) {
cout << current->val << endl;
current = current->next;
}
}
~List(){
}
};
int main() {
List A;
A.Create();
// A.Output(A.head);
A.PrintListReverse_byStack(A.head);
return 0;
}
//用递归实现
void PrintListReverse_byRecursive(Node* pHead)
{
if(pHead != nullptr){
if(pHead->next != nullptr){
PrintListReverse_byRecursive(pHead->next);
}
cout << pHead->val << endl;
}
}
树
二叉树最小字典序
给定一颗根结点为 root 的二叉树，树中的每一个结点都有一个 [0, 25] 范围内的值，分别代表字母 'a' 到 'z'。
返回 按字典序最小 的字符串，该字符串从这棵树的一个叶结点开始，到根结点结束。
注：字符串中任何较短的前缀在 字典序上 都是 较小 的：
例如，在字典序上 "ab" 比 "aba" 要小。叶结点是指没有子结点的结点。
节点的叶节点是没有子节点的节点。
class Solution:
string ans = "~"; // 最大的ASCII码
public:
void dfs(TreeNode* root, string s)
if (!root) return;
if (!root->left && !root->right) // 叶子节点
ans = min(ans, char(root->val+'a')+s); // +a：0->a、倒序保存：root->val + s、最小字典序：字典序以叶子节点为主
dfs(root->left, char(root->val+'a')+s);
dfs(root->right, char(root->val+'a')+s);
string smallestFromLeaf(TreeNode* root)
dfs(root,"");
return ans;
;
