數據結構丨數組和字符串
數組簡介
數組簡介
數組是一種基本的數據結構，用於按順序存儲元素的集合。可是元素能夠隨機存取，由於數組中的每一個元素均可以經過數組索引來識別。html
數組能夠有一個或多個維度。這裏咱們從一維數組開始，它也被稱爲線性數組。這裏有一個例子：java
在上面的例子中，數組 A 中有 6 個元素。也就是說，A 的長度是 6 。咱們可使用 A[0] 來表示數組中的第一個元素。所以，A[0] = 6 。相似地，A[1] = 3，A[2] = 8，依此類推。ios
數組中的操做c++
讓咱們來看看數組的用法：git
#include <iostream>
int main() {
// 1. Initialize
int a0[5];
int a1[5] = {1, 2, 3}; // other element will be set as the default value
// 2. Get Length
int size = sizeof(a1) / sizeof(*a1);
cout << "The size of a1 is: " << size << endl;
// 3. Access Element
cout << "The first element is: " << a1[0] << endl;
// 4. Iterate all Elements
cout << "[Version 1] The contents of a1 are:";
for (int i = 0; i < size; ++i) {
cout << " " << a1[i];
}
cout << endl;
cout << "[Version 2] The contents of a1 are:";
for (int& item: a1) {
cout << " " << item;
}
cout << endl;
// 5. Modify Element
a1[0] = 4;
// 6. Sort
sort(a1, a1 + size);
}
動態數組
正如咱們在上一篇文章中提到的，數組具備固定的容量，咱們須要在初始化時指定數組的大小。有時它會很是不方便並可能形成浪費。面試
所以，大多數編程語言都提供內置的動態數組，它仍然是一個隨機存取的列表數據結構，但大小是可變的。例如，在 C++ 中的 vector，以及在 Java 中的 ArrayList。算法
動態數組中的操做編程
讓咱們來看看動態數組的用法：api
#include <iostream>
int main() {
// 1. initialize
vector<int> v0;
vector<int> v1(5, 0);
// 2. make a copy
vector<int> v2(v1.begin(), v1.end());
vector<int> v3(v2);
// 2. cast an array to a vector
int a[5] = {0, 1, 2, 3, 4};
vector<int> v4(a, *(&a + 1));
// 3. get length
cout << "The size of v4 is: " << v4.size() << endl;
// 4. access element
cout << "The first element in v4 is: " << v4[0] << endl;
// 5. iterate the vector
cout << "[Version 1] The contents of v4 are:";
for (int i = 0; i < v4.size(); ++i) {
cout << " " << v4[i];
}
cout << endl;
cout << "[Version 2] The contents of v4 are:";
for (int& item : v4) {
cout << " " << item;
}
cout << endl;
cout << "[Version 3] The contents of v4 are:";
for (auto item = v4.begin(); item != v4.end(); ++item) {
cout << " " << *item;
}
cout << endl;
// 6. modify element
v4[0] = 5;
// 7. sort
sort(v4.begin(), v4.end());
// 8. add new element at the end of the vector
v4.push_back(-1);
// 9. delete the last element
v4.pop_back();
}
尋找數組的中心索引
給定一個整數類型的數組 nums，請編寫一個可以返回數組**「中心索引」**的方法。數組
咱們是這樣定義數組中心索引的：數組中心索引的左側全部元素相加的和等於右側全部元素相加的和。
若是數組不存在中心索引，那麼咱們應該返回 -1。若是數組有多箇中心索引，那麼咱們應該返回最靠近左邊的那一個。
示例 1:
輸入: nums = [1, 7, 3, 6, 5, 6] 輸出: 3 解釋: 索引3 (nums[3] = 6) 的左側數之和(1 + 7 + 3 = 11)，與右側數之和(5 + 6 = 11)相等。 同時, 3 也是第一個符合要求的中心索引。
示例 2:
輸入: nums = [1, 2, 3] 輸出: -1 解釋: 數組中不存在知足此條件的中心索引。
說明:
nums的長度範圍爲[0, 10000]。- 任何一個
nums[i]將會是一個範圍在[-1000, 1000]的整數。
class Solution{
public:
int pivotIndex(vector<int>& nums){
if(nums.size() == 0)
return -1;
int sum = accumulate(nums.begin(), nums.end(), 0);
int leftSum = 0;
for(int i=0; i<nums.size(); i++)
if(leftSum == sum-leftSum-nums[i])
return i;
else
leftSum += nums[i];
return -1;
}
};
至少是其餘數字兩倍的最大數
在一個給定的數組nums中，老是存在一個最大元素 。
查找數組中的最大元素是否至少是數組中每一個其餘數字的兩倍。
若是是，則返回最大元素的索引，不然返回-1。
示例 1:
輸入: nums = [3, 6, 1, 0] 輸出: 1 解釋: 6是最大的整數, 對於數組中的其餘整數, 6大於數組中其餘元素的兩倍。6的索引是1, 因此咱們返回1.
示例 2:
輸入: nums = [1, 2, 3, 4] 輸出: -1 解釋: 4沒有超過3的兩倍大, 因此咱們返回 -1.
提示:
nums的長度範圍在[1, 50].- 每一個
nums[i]的整數範圍在[0, 99].
#include <iostream>
#include <vector>
using namespace std;
/// Linear Scan
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution{
public:
int dominantIndex(vector<int>& nums){
int maxNum = *max_element(nums.begin(), nums.end());
int res = -1;
for(int i = 0; i< nums.size(); i++)
if(nums[i] != maxNum){
if(maxNum < 2*nums[i])
return -1;
}
else
res = i;
return res;
}
};
加一
給定一個由整數組成的非空數組所表示的非負整數，在該數的基礎上加一。
最高位數字存放在數組的首位， 數組中每一個元素只存儲一個數字。
你能夠假設除了整數 0 以外，這個整數不會以零開頭。
示例 1:
輸入: [1,2,3] 輸出: [1,2,4] 解釋: 輸入數組表示數字 123。
示例 2:
輸入: [4,3,2,1] 輸出: [4,3,2,2] 解釋: 輸入數組表示數字 4321。
#include <iostream>
#include <vector>
using namespace std;
/// Ad Hoc
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution{
public:
vector<int> plusOne(vector<int>& digits){
digits[digits.size() -1] ++;
for(int i=digits.size()-1; i>=1; i--)
if(digits[i] == 10){
digits[i] = 0;
digits[i-1] ++;
}
if(digits[0] == 10){
digits[0] = 0;
digits.insert(digits.begin(), 1);
}
return digits;
}
}
二維數組簡介
二維數組簡介
相似於一維數組，二維數組也是由元素的序列組成。可是這些元素能夠排列在矩形網格中而不是直線上。
示例
#include <iostream>
template <size_t n, size_t m>
void printArray(int (&a)[n][m]) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
int main() {
cout << "Example I:" << endl;
int a[2][5];
printArray(a);
cout << "Example II:" << endl;
int b[2][5] = {{1, 2, 3}};
printArray(b);
cout << "Example III:"<< endl;
int c[][5] = {1, 2, 3, 4, 5, 6, 7};
printArray(c);
cout << "Example IV:" << endl;
int d[][5] = {{1, 2, 3, 4}, {5, 6}, {7}};
printArray(d);
}
原理
在一些語言中，多維數組其實是在內部做爲一維數組實現的，而在其餘一些語言中，實際上根本沒有多維數組。
1. C++ 將二維數組存儲爲一維數組。
下圖顯示了大小爲 M * N 的數組 A 的實際結構：
2. 在Java中，二維數組其實是包含着 M 個元素的一維數組，每一個元素都是包含有 N 個整數的數組。
下圖顯示了 Java 中二維數組 A 的實際結構：
動態二維數組
與一維動態數組相似，咱們也能夠定義動態二維數組。 實際上，它能夠只是一個嵌套的動態數組。 你能夠本身嘗試一下。
對角線遍歷
給定一個含有 M x N 個元素的矩陣（M 行，N 列），請以對角線遍歷的順序返回這個矩陣中的全部元素，對角線遍歷以下圖所示。
示例:
輸入: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 輸出: [1,2,4,7,5,3,6,8,9]
解釋：
說明：
- 給定矩陣中的元素總數不會超過 100000 。
#include <iostream>
#include <vector>
using namespace std;
/// Simulation
/// Time Complexity: O(n * m)
/// Space Complexity: O(1)
class Solution
{
private:
int n, m;
public:
vector<int> findDiagonalOrder(vector<vector<int>> &matrix)
{
vector<int> res;
n = matrix.size();
if (n == 0)
return res;
m = matrix[0].size();
int x = 0, y = 0;
int nextX, nextY;
bool up = true;
while (true)
{
res.push_back(matrix[x][y]);
if (up)
nextX = x - 1, nextY = y + 1;
else
nextX = x + 1, nextY = y - 1;
if(inArea(nextX, nextY))
x = nextX, y = nextY;
else if(up){
if(inArea(x, y+1))
y++;
else
x++;
up = false;
}
else{
if(inArea(x+1, y))
x++;
else
y++;
up = true;
}
if(!inArea(x, y))
break;
}
return res;
}
private:
bool inArea(int x, int y){
return x>=0 && x<n && y >=0 && y<m;
}
};
void print_vec(const vector<int>& vec){
for(int e: vec)
cout << e << " ";
cout << endl;
}
int main(){
vector<vector<int>> matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}};
print_vec(Solution().findDiagonalOrder(matrix));
return 0;
}
螺旋矩陣
給定一個包含 m x n 個元素的矩陣（m 行, n 列），請按照順時針螺旋順序，返回矩陣中的全部元素。
示例 1:
輸入: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 輸出: [1,2,3,6,9,8,7,4,5]
示例 2:
輸入: [ [1, 2, 3, 4], [5, 6, 7, 8], [9,10,11,12] ] 輸出: [1,2,3,4,8,12,11,10,9,5,6,7]
/// Source : https://leetcode.com/problems/spiral-matrix/description/
/// Author : liuyubobobo
/// Time : 2018-04-24
#include <iostream>
#include <vector>
using namespace std;
/// Simulation
/// Time Complexity: O(n^2)
/// Space Complexity: O(n^2)
class Solution {
private:
int d[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int N, M;
public:
vector<int> spiralOrder(vector<vector<int>>& matrix) {
N = matrix.size();
if(N == 0)
return {};
M = matrix[0].size();
if(M == 0)
return {};
vector<vector<bool>> visited(N, vector<bool>(M, false));
int curd = 0, curx = 0, cury = 0;
vector<int> res;
while(res.size() < N * M){
if(!visited[curx][cury]) {
res.push_back(matrix[curx][cury]);
visited[curx][cury] = true;
}
int nextx = curx + d[curd][0];
int nexty = cury + d[curd][1];
if(inArea(nextx, nexty) && !visited[nextx][nexty]){
curx = nextx;
cury = nexty;
}
else
curd = (curd + 1) % 4;
}
return res;
}
private:
bool inArea(int x, int y){
return x >= 0 && x < N && y >= 0 && y < M;
}
};
void print_vec(const vector<int>& vec){
for(int e: vec)
cout << e << " ";
cout << endl;
}
int main() {
vector<vector<int>> matrix1 = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
print_vec(Solution().spiralOrder(matrix1));
return 0;
}
楊輝三角
給定一個非負整數 *numRows，*生成楊輝三角的前 numRows 行。
在楊輝三角中，每一個數是它左上方和右上方的數的和。
示例:
輸入: 5
輸出:
[
[1],
[1,1],
[1,2,1],
[1,3,3,1],
[1,4,6,4,1]
]
#include <iostream>
#include <vector>
using namespace std;
/// Simulation (Dynamic Programming)
/// Time Complexity: O(n^2)
/// Space Complexity: O(1)
class Solution{
public:
vector<vector<int>> generate(int numRows){
vector<vector<int>> res;
if(numRows <= 0)
return res;
res.push_back({1});
for(int i=1; i<numRows; i++){
vector<int> row;
row.push_back(1);
for(int j=1; j<i; j++)
row.push_back(res[i-1][j-1]+res[i-1][j]);
row.push_back(1);
res.push_back(row);
}
return res;
}
};
字符串簡介
字符串簡介
字符串其實是一個 unicode 字符數組。你能夠執行幾乎全部咱們在數組中使用的操做，本身試試看吧。
然而，兩者之間仍是存在一些區別。在這篇文章中，咱們將介紹一些在處理字符串時應該注意的問題。這些特性在不一樣的語言之間可能有很大不一樣。
比較函數
字符串有它本身的比較函數（咱們將在下面的代碼中向你展現比較函數的用法）。
然而，存在這樣一個問題：
咱們能夠用 「==」 來比較兩個字符串嗎？
這取決於下面這個問題的答案：
咱們使用的語言是否支持
運算符重載？
- 若是答案是
yes（例如 C++）。咱們可使用「==」 來比較兩個字符串。 - 若是答案是
no（例如 Java），咱們可能沒法使用「==」 來比較兩個字符串。當咱們使用 「==」 時，它實際上會比較這兩個對象是不是同一個對象。
讓咱們運行下面的例子並比較結果：
#include <iostream>
int main() {
string s1 = "Hello World";
cout << "s1 is \"Hello World\"" << endl;
string s2 = s1;
cout << "s2 is initialized by s1" << endl;
string s3(s1);
cout << "s3 is initialized by s1" << endl;
// compare by '=='
cout << "Compared by '==':" << endl;
cout << "s1 and \"Hello World\": " << (s1 == "Hello World") << endl;
cout << "s1 and s2: " << (s1 == s2) << endl;
cout << "s1 and s3: " << (s1 == s3) << endl;
// compare by 'compare'
cout << "Compared by 'compare':" << endl;
cout << "s1 and \"Hello World\": " << !s1.compare("Hello World") << endl;
cout << "s1 and s2: " << !s1.compare(s2) << endl;
cout << "s1 and s3: " << !s1.compare(s3) << endl;
}
是否可變
不可變意味着一旦字符串被初始化，你就沒法改變它的內容。
- 在某些語言（如 C ++）中，字符串是
可變的。 也就是說，你能夠像在數組中那樣修改字符串。 - 在其餘一些語言（如 Java）中，字符串是不可變的。 此特性將帶來一些問題。 咱們將在下一篇文章中闡明問題和解決方案。
你能夠經過測試修改操做來肯定你喜歡的語言中的字符串是否可變。這裏有一個示例：
#include <iostream>
int main() {
string s1 = "Hello World";
s1[5] = ',';
cout << s1 << endl;
}
額外操做
與數組相比，咱們能夠對字符串執行一些額外的操做。這裏有一些例子：
#include <iostream>
int main() {
string s1 = "Hello World";
// 1. concatenate
s1 += "!";
cout << s1 << endl;
// 2. find
cout << "The position of first 'o' is: " << s1.find('o') << endl;
cout << "The position of last 'o' is: " << s1.rfind('o') << endl;
// 3. get substr
cout << s1.substr(6, 5) << endl;
}
你應該瞭解這些內置操做的時間複雜度。
例如，若是字符串的長度是 N，那麼查找操做和子字符串操做的時間複雜度是 O(N)。
此外，在字符串不可變的語言中，你應該額外當心鏈接操做（咱們將在下一篇文章中解釋這一點）。
在計算解決方案的時間複雜度時，不要忘記考慮內置操做的時間複雜度。
不可變字符串 —— 問題和解決方案
在上一篇文章中，您應該已經知道您喜歡的語言中的字符串是否爲不可變的。若是字符串是不可變的，則會帶來一些問題。但願咱們也能在最後提供解決方案。
修改操做
顯然，不可變字符串沒法被修改。哪怕你只是想修改其中的一個字符，也必須建立一個新的字符串。
當心Java中的字符串
你應該很是當心字符串鏈接。讓咱們來看一個在 for 循環中重複進行字符串鏈接的例子：
#include <iostream>
int main() {
string s = "";
int n = 10000;
for (int i = 0; i < n; i++) {
s += "hello";
}
}
請注意對於 Java 來講字符串鏈接有多慢？ 另外一方面，在 C++ 中沒有明顯的性能影響。
在 Java 中，因爲字符串是不可變的，所以在鏈接時首先爲新字符串分配足夠的空間，複製舊字符串中的內容並附加到新字符串。
所以，總時間複雜度將是：
5 + 5 × 2 + 5 × 3 + … + 5 × n = 5 × (1 + 2 + 3 + … + n) = 5 × n × (n + 1) / 2,
也就是 O(n2)。
解決方案
若是你但願你的字符串是可變的，這裏有一些替代方案：
1. 若是你確實但願你的字符串是可變的，則能夠將其轉換爲字符數組。
// "static void main" must be defined in a public class.
public class Main {
public static void main(String[] args) {
String s = "Hello World";
char[] str = s.toCharArray();
str[5] = ',';
System.out.println(str);
}
}
2. 若是你常常必須鏈接字符串，最好使用一些其餘的數據結構，如 StringBuilder 。 如下代碼以 O(n) 的複雜度運行。
// "static void main" must be defined in a public class.
public class Main {
public static void main(String[] args) {
int n = 10000;
StringBuilder str = new StringBuilder();
for (int i = 0; i < n; i++) {
str.append("hello");
}
String s = str.toString();
}
}
二進制求和
給定兩個二進制字符串，返回他們的和（用二進制表示）。
輸入爲非空字符串且只包含數字 1 和 0。
示例 1:
輸入: a = "11", b = "1" 輸出: "100"
示例 2:
輸入: a = "1010", b = "1011" 輸出: "10101"
/// Source : https://leetcode.com/problems/add-binary/description/
/// Author : liuyubobobo
/// Time : 2018-06-03
#include <iostream>
using namespace std;
/// Simulation
/// Time Complexity: O(max(len(a), len(b)))
/// Space Complexity: O(1)
class Solution {
public:
string addBinary(string a, string b) {
string res = a.size() > b.size() ? a : b;
string adder = a.size() > b.size() ? b : a;
int index = res.size() - 1;
for(int i = adder.size() - 1 ; i >= 0 ; i --){
res[index] += adder[i] - '0';
index --;
}
for(int i = res.size() - 1 ; i > 0 ; i --)
if(res[i] > '1'){
res[i - 1] += 1;
res[i] = '0' + (res[i] - '0') % 2;
}
if(res[0] > '1'){
res[0] = '0' + (res[0] - '0') % 2;
res = '1' + res;
}
return res;
}
};
int main() {
cout << Solution().addBinary("11", "1") << endl;
cout << Solution().addBinary("1010", "1011") << endl;
return 0;
}
實現strStr()
實現 strStr() 函數。
給定一個 haystack 字符串和一個 needle 字符串，在 haystack 字符串中找出 needle 字符串出現的第一個位置 (從0開始)。若是不存在，則返回 -1。
示例 1:
輸入: haystack = "hello", needle = "ll" 輸出: 2
示例 2:
輸入: haystack = "aaaaa", needle = "bba" 輸出: -1
說明:
當 needle 是空字符串時，咱們應當返回什麼值呢？這是一個在面試中很好的問題。
對於本題而言，當 needle 是空字符串時咱們應當返回 0 。這與C語言的 strstr() 以及 Java的 indexOf() 定義相符。
#include <iostream>
using namespace std;
class Solution
{
public:
int strStr(string haystack, string needle)
{
if (needle.size() > haystack.size())
return -1;
for(int i = 0 ; i <= haystack.size() - needle.size() ; i ++){
int j = 0;
for(j = 0 ; j < needle.size() ; j ++)
if(needle[j] != haystack[j + i])
break;
if(j == needle.size())
return i;
}
return -1;
}
};
int main() {
cout << Solution().strStr("hello", "ll") << endl;
cout << Solution().strStr("aaaaa", "bba") << endl;
return 0;
}
最長公共前綴
編寫一個函數來查找字符串數組中的最長公共前綴。
若是不存在公共前綴，返回空字符串 ""。
示例 1:
輸入: ["flower","flow","flight"] 輸出: "fl"
示例 2:
輸入: ["dog","racecar","car"] 輸出: "" 解釋: 輸入不存在公共前綴。
說明:
全部輸入只包含小寫字母 a-z 。
#include <iostream>
using namespace std;
/// Vertical Scan
/// Time Complexity: O(len(strs) * max len of string)
/// Space Complexity: O(1)
class Solution{
public:
string longestCommonPrefix(vector<string>& strs){
string res = "";
if(strs.size()==0)
return res;
for(int i=0; i<strs[0].size(); i++){
char c = strs[0][[i];
for(int j=1; j<strs.size(); j++)
if(i >= strs[j].size() || strs[j][i] != c)
return res;
res += c;
}
return res;
}
};
int main() {
vector<string> strs1 = {"flower","flow","flight"};
cout << Solution().longestCommonPrefix(strs1) << endl;
vector<string> strs2 = {"dog","racecar","car"};
cout << Solution().longestCommonPrefix(strs2) << endl;
return 0;
}
雙指針技巧
雙指針技巧 —— 情景一
在前一章中，咱們經過迭代數組來解決一些問題。一般，咱們只使用從第一個元素開始並在最後一個元素結束的一個指針來進行迭代。 可是，有時候，咱們可能須要同時使用兩個指針來進行迭代。
示例
讓咱們從一個經典問題開始：
反轉數組中的元素。
其思想是將第一個元素與末尾進行交換，再向前移動到下一個元素，並不斷地交換，直到它到達中間位置。
咱們能夠同時使用兩個指針來完成迭代：一個從第一個元素開始，另外一個從最後一個元素開始。持續交換它們所指向的元素，直到這兩個指針相遇。
如下代碼能夠供你參考：
void reverse(int *v, int N) {
int i = 0;
int j = N - 1;
while (i < j) {
swap(v[i], v[j]);
i++;
j--;
}
}
總結
總之，使用雙指針技巧的典型場景之一是你想要
從兩端向中間迭代數組。
這時你可使用雙指針技巧：
一個指針從始端開始，而另外一個指針從末端開始。
值得注意的是，這種技巧常常在排序數組中使用。
反轉字符串
編寫一個函數，其做用是將輸入的字符串反轉過來。輸入字符串以字符數組 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"]
#include <iostream>
#include <vector>
using namespace std;
/// Two Pointers
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution{
public:
void reverseString(vector<char>& s){
int i=0, j=s.size()-1;
while(i<j){
swap(s[i], s[j]);
i ++;
j --;
}
}
};
數組拆分I
給定長度爲 2n 的數組, 你的任務是將這些數分紅 n 對, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得從1 到 n 的 min(ai, bi) 總和最大。
示例 1:
輸入: [1,4,3,2] 輸出: 4 解釋: n 等於 2, 最大總和爲 4 = min(1, 2) + min(3, 4).
提示:
- n 是正整數,範圍在 [1, 10000].
- 數組中的元素範圍在 [-10000, 10000].
#include <iostream>
#include <vector>
using namespace std;
/// Sort
/// Time Complexity: O(nlogn)
/// Space Complexity: O(1)
class Solution {
public:
int arrayPairSum(vector<int>& nums){
sort(nums.begin(), nums.end());
int sum = 0;
for(int i=0; i<nums.size(); i+=2)
sum+=nums[i];
return sum;
}
};
兩數之和 II - 輸入有序數組
給定一個已按照升序排列 的有序數組，找到兩個數使得它們相加之和等於目標數。
函數應該返回這兩個下標值 index1 和 index2，其中 index1 必須小於 index2*。*
說明:
- 返回的下標值（index1 和 index2）不是從零開始的。
- 你能夠假設每一個輸入只對應惟一的答案，並且你不能夠重複使用相同的元素。
示例:
輸入: numbers = [2, 7, 11, 15], target = 9 輸出: [1,2] 解釋: 2 與 7 之和等於目標數 9 。所以 index1 = 1, index2 = 2 。
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
// Two Pointers
// Time Complexity: O(n)
// Space Complexity: O(1)
class Solution {
public:
vector<int> twoSum(vector<int>& numbers, int target) {
assert(numbers.size() >= 2);
// assert(isSorted(numbers));
int l = 0, r = numbers.size() - 1;
while(l < r){
if(numbers[l] + numbers[r] == target){
int res[2] = {l+1, r+1};
return vector<int>(res, res+2);
}
else if(numbers[l] + numbers[r] < target)
l ++;
else // numbers[l] + numbers[r] > target
r --;
}
throw invalid_argument("the input has no solution");
}
private:
bool isSorted(const vector<int>& numbers){
for(int i = 1 ; i < numbers.size() ; i ++)
if(numbers[i] < numbers[i-1])
return false;
return true;
}
};
void printVec(const vector<int>& vec){
for(int e: vec)
cout << e << " ";
cout << endl;
}
int main() {
int nums[] = {2, 7, 11, 15};
vector<int> vec(nums, nums + sizeof(nums) / sizeof(int));
int target = 9;
printVec(Solution().twoSum(vec, target));
return 0;
}
雙指針技巧 —— 情景二
有時，咱們可使用兩個不一樣步的指針來解決問題。
示例
讓咱們從另外一個經典問題開始：
給定一個數組和一個值，原地刪除該值的全部實例並返回新的長度。
若是咱們沒有空間複雜度上的限制，那就更容易了。咱們能夠初始化一個新的數組來存儲答案。若是元素不等於給定的目標值，則迭代原始數組並將元素添加到新的數組中。
實際上，它至關於使用了兩個指針，一個用於原始數組的迭代，另外一個老是指向新數組的最後一個位置。
從新考慮空間限制
如今讓咱們從新考慮空間受到限制的狀況。
咱們能夠採用相似的策略，咱們繼續使用兩個指針：一個仍然用於迭代，而第二個指針老是指向下一次添加的位置。
如下代碼能夠供你參考：
int removeElement(vector<int>& nums, int val) {
int k = 0;
for (int i = 0; i < nums.size(); ++i) {
if (nums[i] != val) {
nums[k] = nums[i];
++k;
}
}
return k;
}
在上面的例子中，咱們使用兩個指針，一個快指針 i 和一個慢指針 k 。i 每次移動一步，而 k 只在添加新的被須要的值時才移動一步。
總結
這是你須要使用雙指針技巧的一種很是常見的狀況：
同時有一個慢指針和一個快指針。
解決這類問題的關鍵是
肯定兩個指針的移動策略。
與前一個場景相似，你有時可能須要在使用雙指針技巧以前對數組進行排序，也可能須要運用貪心想法來決定你的運動策略。
移除元素
給定一個數組 nums 和一個值 val，你須要原地移除全部數值等於 val 的元素，返回移除後數組的新長度。
不要使用額外的數組空間，你必須在原地修改輸入數組並在使用 O(1) 額外空間的條件下完成。
元素的順序能夠改變。你不須要考慮數組中超出新長度後面的元素。
示例 1:
給定 nums = [3,2,2,3], val = 3, 函數應該返回新的長度 2, 而且 nums 中的前兩個元素均爲 2。 你不須要考慮數組中超出新長度後面的元素。
示例 2:
給定 nums = [0,1,2,2,3,0,4,2], val = 2, 函數應該返回新的長度 5, 而且 nums 中的前五個元素爲 0, 1, 3, 0, 4。 注意這五個元素可爲任意順序。 你不須要考慮數組中超出新長度後面的元素。
說明:
爲何返回數值是整數，但輸出的答案是數組呢?
請注意，輸入數組是以**「引用」**方式傳遞的，這意味着在函數裏修改輸入數組對於調用者是可見的。
你能夠想象內部操做以下:
// nums 是以「引用」方式傳遞的。也就是說，不對實參做任何拷貝
int len = removeElement(nums, val);
// 在函數裏修改輸入數組對於調用者是可見的。
// 根據你的函數返回的長度, 它會打印出數組中該長度範圍內的全部元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
#include <iostream>
#include <vector>
#include <cassert>
#include <stdexcept>
using namespace std;
/// Two Pointers
///Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int newl = 0;
for( int i = 0 ; i < nums.size() ; i ++ )
if( nums[i] != val )
nums[newl++] = nums[i];
return newl;
}
};
int main() {
vector<int> nums = {3, 2, 2, 3};
int val = 3;
cout << Solution().removeElement(nums, val) << endl;
return 0;
}
最大連續1的個數
給定一個二進制數組， 計算其中最大連續1的個數。
示例 1:
輸入: [1,1,0,1,1,1] 輸出: 3 解釋: 開頭的兩位和最後的三位都是連續1，因此最大連續1的個數是 3.
注意：
- 輸入的數組只包含
0和1。 - 輸入數組的長度是正整數，且不超過 10,000。
#include <iostream>
#include <vector>
using namespace std;
/// Ad-Hoc
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution{
public:
int findMaxConsecutiveOnes(vector<int>& nums){
int res = 0;
int start = firstOne(nums, 0);
for(int i=start+1; i<= nums.size(); ){
if(i == nums.size() || nums[i] != 1){
res = max(res, i-start);
start = firstOne(nums, i);
i = start + 1;
}
else
i++;
}
return res;
}
private:
int firstOne(const vector<int>& nums, int startIndex){
for(int i=startIndex; i<nums.size(); i++)
if(nums[i]==1)
return i;
return nums.size();
}
};
int main() {
vector<int> nums = {1, 1, 0, 1, 1, 1};
cout << Solution().findMaxConsecutiveOnes(nums) << endl;
return 0;
}
長度最小的子數組
給定一個含有 n 個正整數的數組和一個正整數 **s ，找出該數組中知足其和 ≥ s 的長度最小的連續子數組。**若是不存在符合條件的連續子數組，返回 0。
示例:
輸入: s = 7, nums = [2,3,1,2,4,3] 輸出: 2 解釋: 子數組 [4,3] 是該條件下的長度最小的連續子數組。
進階:
若是你已經完成了O(n) 時間複雜度的解法, 請嘗試 O(n log n) 時間複雜度的解法。
#include <iostream>
#include <cassert>
#include <vector>
#include <algorithm>
using namespace std;
class Solution{
public:
int minSubArrayLen(int s, vector<int>& nums){
if (nums.size() == 0) return 0;
int i=0, j=0, sum=0, min=INT_MAX;
while(j<nums.size()){
sum += nums[j++];
while(sum >= s){
min = (min < j-i)? min : (j-i);
sum -= nums[i++];
}
}
return min == INT_MAX? 0:min;
}
};
小結
數組相關的技術
你可能想要了解更多與數組相關的數據結構或技術。咱們不會深刻研究這張卡片中的大多數概念，而是在本文中提供相應卡片的連接。
- 這裏有一些其餘相似於數組的數據結構，但具備一些不一樣的屬性：
-
正如咱們所提到的，咱們能夠調用內置函數來對數組進行排序。可是，理解一些普遍使用的排序算法的原理及其複雜度是頗有用的。
-
二分查找也是一種重要的技術，用於在排序數組中搜索特定的元素。
-
咱們在這一章中引入了雙指針技巧。想要靈活運用該技技巧是不容易的。這一技巧也能夠用來解決：
- 鏈表中的慢指針和快指針問題
- 滑動窗口問題
- 雙指針技巧有時與貪心算法有關，它能夠幫助咱們設計指針的移動策略。 在不久的未來，咱們會提供更多的卡片來介紹上面提到的這些技術，並更新連接。
旋轉數組
給定一個數組，將數組中的元素向右移動 k 個位置，其中 k 是非負數。
示例 1:
輸入: [1,2,3,4,5,6,7] 和 k = 3 輸出: [5,6,7,1,2,3,4] 解釋: 向右旋轉 1 步: [7,1,2,3,4,5,6] 向右旋轉 2 步: [6,7,1,2,3,4,5] 向右旋轉 3 步: [5,6,7,1,2,3,4]
示例 2:
輸入: [-1,-100,3,99] 和 k = 2 輸出: [3,99,-1,-100] 解釋: 向右旋轉 1 步: [99,-1,-100,3] 向右旋轉 2 步: [3,99,-1,-100]
說明:
- 儘量想出更多的解決方案，至少有三種不一樣的方法能夠解決這個問題。
- 要求使用空間複雜度爲 O(1) 的原地算法。
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
/// Using Queue
/// Time Complexity: O(n^2)
/// Space Complexity: O(n)
class SolutionA {
public:
void rotate(vector<int>& nums, int k) {
queue<int> q;
while(k -- && !nums.empty())
q.push(nums.back()), nums.pop_back();
for(int i = 0 ; i <= k ; i ++) //if k >= nums.size()
q.push(q.front()), q.pop();
while(!q.empty())
nums.insert(nums.begin(), q.front()), q.pop();
return;
}
};
/// Cyclic Replacements
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class SolutonB{
public:
void rotate(vector<int>& nums, int k){
int start = 0, cur = 0, t = nums[cur];
for(int i=0; i<nums.size(); i++){
int next = (cur + k) % nums.size();
int t2 = nums[next];
nums[next] = t;
t = t2;
cur = next;
if(cur == start)
start++, cur=start, t=nums[cur];
}
}
};
/// Using Reverse
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class SolutionC {
public:
void rotate(vector<int>& nums, int k) {
k %= nums.size();
reverse(nums, 0, nums.size() - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.size() - 1);
}
private:
void reverse(vector<int>& nums, int start, int end){
for(int i = start, j = end; i < j; i ++, j --)
swap(nums[i], nums[j]);
}
};
void print_vec(const vector<int>& vec){
for(int e: vec)
cout << e << " ";
cout << endl;
}
int main() {
vector<int> nums1 = {1, 2, 3, 4, 5, 6, 7};
SolutionC().rotate(nums1, 3);
print_vec(nums1);
vector<int> nums2 = {1, 2};
SolutionC().rotate(nums2, 3);
print_vec(nums2);
return 0;
}
楊輝三角 II
給定一個非負索引 k，其中 k ≤ 33，返回楊輝三角的第 k 行。
在楊輝三角中，每一個數是它左上方和右上方的數的和。
示例:
輸入: 3 輸出: [1,3,3,1]
進階：
你能夠優化你的算法到 O(k) 空間複雜度嗎？
#include <iostream>
#include <vector>
using namespace std;
/// Simulate Pascal Triangle
///
/// Time Complexity: O(rowIndex^2)
/// Space Complexity: O(rowIndex^2)
class SolutionA{
public:
vector<int> getRow(int rowIndex){
vector<vector<int>> res(rowIndex+1, vector<int>(rowIndex+1, 1));
for(int i=2; i<=rowIndex; i++)
for(int j=1; j<i; j++)
res[i][j] = res[i-1][j-1] + res[i-1][j];
return res[rowIndex];
}
};
/// Simulate Pascal Triangle
///
/// Time Complexity: O(rowIndex^2)
/// Space Complexity: O(rowIndex)
class SolutionB{
public:
vector<int> getRow(int rowIndex){
vector<int> up(rowIndex+1, 1);
vector<int> down(rowIndex+1, 1);
for(int i=2; i<=rowIndex; i++){
for(int j=1; j<i; j++)
down[j] = up[j-1] + up[j];
up = down;
}
return down;
}
};
void print_vec(const vector<int>& vec){
for(int e: vec)
cout << e << " ";
cout << endl;
}
int main() {
print_vec(SolutionB().getRow(3));
return 0;
}
翻轉字符串裏的單詞
給定一個字符串，逐個翻轉字符串中的每一個單詞。
示例 1：
輸入: "the sky is blue" 輸出: "blue is sky the"
示例 2：
輸入: " hello world! " 輸出: "world! hello" 解釋: 輸入字符串能夠在前面或者後面包含多餘的空格，可是反轉後的·字符不能包括。
示例 3：
輸入: "a good example" 輸出: "example good a" 解釋: 若是兩個單詞間有多餘的空格，將反轉後單詞間的空格減小到只含一個。
說明：
- 無空格字符構成一個單詞。
- 輸入字符串能夠在前面或者後面包含多餘的空格，可是反轉後的字符不能包括。
- 若是兩個單詞間有多餘的空格，將反轉後單詞間的空格減小到只含一個。
進階：
請選用 C 語言的用戶嘗試使用 O(1) 額外空間複雜度的原地解法。
#include <iostream>
#include <vector>
using namespace std;
/// Reverse then reverse:)
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution
{
public:
string reverseWords(string s)
{
int start = nextNonSpace(s, 0);
s = s.substr(start);
start = 0;
for (int i = start + 1; i <= s.size();)
if (i == s.size() || s[i] == ' ')
{
start = nextNonSpace(s, i);
if (start != s.size())
s = s.substr(0, i) + " " + s.substr(start); //除去字符串中多餘的空格。
else
{
s = s.substr(0, i);
break;
}
start = i + 1;
i = start + 1;
}
else
i++;
reverse(s, 0, s.size() - 1);
start = 0;
for (int i = start + 1; i <= s.size();)
if (i == s.size() || s[i] == ' ')
{
reverse(s, start, i - 1);
start = i + 1;
i = start + 1;
}
else
i++;
return s;
}
private:
int nextNonSpace(const string &s, int start)
{
int i = start;
for (; i < s.size(); i++)
if (s[i] != ' ')
return i;
return i;
}
void reverse(string &s, int start, int end)
{
int i = start, j = end;
while (i < j)
swap(s[i++], s[j--]);
}
};
int main() {
string s1 = "the sky is blue";
Solution().reverseWords(s1);
cout << s1 << endl;
string s2 = "";
Solution().reverseWords(s2);
cout << s2 << endl;
string s3 = " 1 ";
Solution().reverseWords(s3);
cout << s3 << endl;
string s4 = " a b ";
Solution().reverseWords(s4);
cout << s4 << endl;
return 0;
}
反轉字符串中的單詞 III
給定一個字符串，你須要反轉字符串中每一個單詞的字符順序，同時仍保留空格和單詞的初始順序。
示例 1:
輸入: "Let's take LeetCode contest" 輸出: "s'teL ekat edoCteeL tsetnoc"
**注意：**在字符串中，每一個單詞由單個空格分隔，而且字符串中不會有任何額外的空格。
#include <iostream>
using namespace std;
/// Reverse in place
/// Time Complexity: O(len(s))
/// Space Complexity: O(1)
class Solution{
public:
string reverseWords(string s){
int start = 0;
for(int i=start + 1; i<=s.size(); )
if(i == s.size() || s[i] == ' '){ //空格翻轉無影響
reverse(s, start, i-1);
start = i+1;
i = start + 1;
}
else
i ++;
return s;
}
private:
void reverse(string& s, int start, int end){
for(int i = start, j = end; i<j; )
swap(s[i++], s[j--]);
}
};
刪除排序數組中的重複項
給定一個排序數組，你須要在原地刪除重複出現的元素，使得每一個元素只出現一次，返回移除後數組的新長度。
不要使用額外的數組空間，你必須在原地修改輸入數組並在使用 O(1) 額外空間的條件下完成。
示例 1:
給定數組 nums = [1,1,2], 函數應該返回新的長度 2, 而且原數組 nums 的前兩個元素被修改成 1, 2。 你不須要考慮數組中超出新長度後面的元素。
示例 2:
給定 nums = [0,0,1,1,1,2,2,3,3,4], 函數應該返回新的長度 5, 而且原數組 nums 的前五個元素被修改成 0, 1, 2, 3, 4。 你不須要考慮數組中超出新長度後面的元素。
說明:
爲何返回數值是整數，但輸出的答案是數組呢?
請注意，輸入數組是以**「引用」**方式傳遞的，這意味着在函數裏修改輸入數組對於調用者是可見的。
你能夠想象內部操做以下:
// nums 是以「引用」方式傳遞的。也就是說，不對實參作任何拷貝
int len = removeDuplicates(nums);
// 在函數裏修改輸入數組對於調用者是可見的。
// 根據你的函數返回的長度, 它會打印出數組中該長度範圍內的全部元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
#include <iostream>
#include <vector>
#include <cassert>
#include <stdexcept>
using namespace std;
/// Two pointers
/// Time Complexity: O(n)
/// Space Complexity: O(1)
class Solution{
public:
int removeDuplicates(vector<int>& nums){
if(nums.size()==0)
return 0;
int res = 1;
int index = nextDifferentCharacterIndex(nums, 1);
int i = 1;
while(index < nums.size()){
res++;
nums[i++] = nums[index];
index = nextDifferentCharacterIndex(nums, index + 1);
}
return res;
}
private:
int nextDifferentCharacterIndex(const vector<int> & nums, int p){
for(; p<nums.size(); p++)
if(nums[p] != nums[p-1])
break;
return p;
}
};
int main(){
vector<int> nums1 = {1, 1, 2};
cout << Solution().removeDuplicates(nums1) << endl;
return 0;
}
移動零
給定一個數組 nums，編寫一個函數將全部 0 移動到數組的末尾，同時保持非零元素的相對順序。
示例:
輸入: [0,1,0,3,12] 輸出: [1,3,12,0,0]
說明:
- 必須在原數組上操做，不能拷貝額外的數組。
- 儘可能減小操做次數。
#include <iostream>
#include <vector>
using namespace std;
// Time Complexity: O(n)
// Space Complexity: O(n)
class Solution{
public:
void moveZeroes(vector<int>& nums){
vector<int> nonZeroElements;
// put all the non zero elements into a new vector
for(int i = 0; i<nums.size(); i++)
if(nums[i])
nonZeroElements.push_back(nums[i]);
// make nums[0...nonZeroElements.size()) all non zero elements
for(int i = 0; i<nonZeroElements.size(); i++)
nums[i] = nonZeroElements[i];
// make nums[nonZeroElements.size()...nums.size()) all zero elements
for(int i = nonZeroElements.size(); i<nums.size(); i++)
nums[i] = 0;
};
};
void printVec(const vector<int>& vec){
for(int e: vec)
cout << e << " ";
cout << endl;
}
int main() {
int arr[] = {0, 1, 0, 3, 12};
vector<int> vec(arr, arr + sizeof(arr) / sizeof(int));
Solution().moveZeroes(vec);
printVec(vec);
return 0;
}
相關文章
- 1. 數據結構丨數組和字符串
- 2. 數據結構二——數組、字符串
- 3. 數據結構--字符串
- 4. 數據結構 - 字符串
- 5. 數據結構實驗四 ：字符串和多維數組
- 6. 串（字符串）--數據結構
- 7. chapter . 2.二、Python內置數據結構：字符串、字節和字節數組
- 8. Python字符串和常用數據結構(三):使用元組
- 9. 字符串式數組和數組式字符串
- 10. 字符串和數組面試總結
- 更多相關文章...
- • Redis字符串數據結構和常用命令 - Redis教程
- • R 字符串 - R 語言教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 安裝cuda+cuDNN
- 2. GitHub的使用說明
- 3. phpDocumentor使用教程【安裝PHPDocumentor】
- 4. yarn run build報錯Component is not found in path 「npm/taro-ui/dist/weapp/components/rate/index「
- 5. 精講Haproxy搭建Web集羣
- 6. 安全測試基礎之MySQL
- 7. C/C++編程筆記：C語言中的複雜聲明分析，用實例帶你完全讀懂
- 8. Python3教程(1)----搭建Python環境
- 9. 李宏毅機器學習課程筆記2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里雲ECS配置速記
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 數據結構丨數組和字符串
- 2. 數據結構二——數組、字符串
- 3. 數據結構--字符串
- 4. 數據結構 - 字符串
- 5. 數據結構實驗四 ：字符串和多維數組
- 6. 串（字符串）--數據結構
- 7. chapter . 2.二、Python內置數據結構：字符串、字節和字節數組
- 8. Python字符串和常用數據結構(三):使用元組
- 9. 字符串式數組和數組式字符串
- 10. 字符串和數組面試總結