21
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class Solution { public: int Fibonacci(int n) { if (n == 0) { return 0; } else if (n == 1) { return 1; } else { return Fibonacci(n-1) + Fibonacci(n-2); } } }; |
16
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class Solution { public: string replaceSpaces(string &str) { int index = 0; index = str.find(" ", 0); while(index != -1) { std::string prefix = str.substr(0, index); std::string suffix = str.substr(index+1, str.size()-index); str = prefix + "%20" + suffix; index = str.find(" ", 0); } return str; } }; |
84
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class Solution { public: int sum(int n) { if (n == 0) { return 0; } else if (n == 1){ return 1; } else { return n + sum(n-1); } } int getSum(int n) { return sum(n); } }; |
28
- 在O(1)时间删除链表结点
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: void deleteNode(ListNode* node) { auto node_next = node->next; node->val = node_next->val; node->next = node_next->next; delete node_next; node_next = nullptr; } }; |
36
- 合并两个排序的链表
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* merge(ListNode* l1, ListNode* l2) { ListNode * dummy = new ListNode(0); ListNode * cur = dummy; while(l1 != nullptr && l2 != nullptr) { if (l1->val < l2->val) { cur->next = l1; l1 = l1->next; } else { cur->next = l2; l2 = l2->next; } cur = cur->next; } cur->next = (l1 != nullptr) ? l1 : l2; return dummy->next; } }; |
78
|
1 2 3 4 5 6 7 8 |
class Solution { public: string leftRotateString(string str, int n) { std::string prefix = str.substr(0, n); std::string suffix = str.substr(n, str.size()-n); return suffix + prefix; } }; |
87
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
// 考虑了整个字符串中所有带或不带符号的数字字符串 class Solution { public: int get_index(std::string str, int start, bool& flag) { int index = -1; for (int i = start; i < str.size() - 1; ++i) { if (str[i] != ' ') { if (str[i] == '+') { index = i + 1; break; } else if (str[i] == '-') { flag = false; index = i + 1; break; } else if (str[i] >= '0' && str[i] <= '9') { index = i; break; } } } return index; } int strToInt(string str) { str += '\0'; int start = 0; int end = 0; std::string res; bool flag1 = true; while (start < str.size()-1) { bool flag = true; start = get_index(str, start, flag); if (start < 0) { break; } flag1 = flag; for (size_t i = start; i < str.size(); ++i) { if (str[i] < '0' || str[i] > '9' || str[i] == '\0') { end = i; break; } } if (end > start) { std::string temp = str.substr(start, end-start); if (res.size() < temp.size()) { res = temp; } } else { break; } start = end; } int count = res.size(); int number = 0; for (size_t i = 0; i < count; ++i) { number += (res[i]-'1'+1) * pow(10, count-1-i); } number = (flag1) ? number : -number; if (number > INT_MAX) { return INT_MAX; } else if (number < INT_MIN) { return INT_MIN; } else { return number; } } }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
class Solution { public: int strToInt(string str) { str += '\0'; int k = 0; while(k < str.size() && str[k] == ' ') { k++; } long number = 0; bool flag = false; if (str[k] == '+') { k++; } else if (str[k] == '-') { k++; flag = true; } while (str[k] >= '0' && str[k] <= '9') { number = number*10 + str[k] - '0'; k++; if (!flag && number >= INT32_MAX) { number = INT32_MAX; break; } if (flag && number-1 >= INT32_MAX) { number = INT32_MIN; break; } } if (flag) { number *= -1; } return (int)number; } }; |
35
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* reverseList(ListNode* head) { if (!head) { return nullptr; } ListNode* temp = nullptr; ListNode* cur = head; while(cur) { ListNode* next = cur->next; cur->next = temp; temp = cur; cur = next; } return temp; } }; |
66
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) { ListNode* cura = headA; ListNode* curb = headB; while (cura != curb) { if (cura) { cura = cura->next; } else { cura = headB; } if (curb) { curb = curb->next; } else { curb = headA; } } return cura; } }; |
29
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* deleteDuplication(ListNode* head) { ListNode* dummy = new ListNode(-1); dummy->next = head; ListNode* cur = dummy; while(cur->next) { ListNode* next = cur->next; while(next && cur->next->val == next->val) { next = next->next; } if (cur->next->next == next) { cur = cur->next; } else { cur->next = next; } } return dummy->next; } }; |
67
|
1 2 3 4 5 6 7 8 9 10 11 |
class Solution { public: int getNumberOfK(vector<int>& nums , int k) { int arr[1001] = {0}; for (auto item : nums) { arr[item]++; } return arr[k]; } }; |
68
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
class Solution { public: int getMissingNumber(vector<int>& nums) { size_t n = nums.size() + 1; if (n == 1) { return 0; } int sum = 0; size_t i = 0; for (; i < n-1; ++i) { sum += nums[i]; int res = i*(i+1)/2; if (res < sum) { return i; } } return i; } }; |
32
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
class Solution { public: void reOrderArray(vector<int> &array) { int index1 = 0, index2 = array.size()-1; while (index1 < index2) { while ((index1 < index2) && (array[index1] % 2 == 1)) { index1++; } while ((index1 < index2) && (array[index2] % 2 == 0)) { index2--; } if (index1 < index2) { swap(array[index1], array[index2]); } } } }; |
17
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: vector<int> printListReversingly(ListNode* head) { std::vector<int> vec; if (!head) { return vec; } ListNode * temp = nullptr; ListNode* cur = head; while(cur) { ListNode* next = cur->next; cur->next = temp; temp = cur; cur = next; } while (temp) { vec.emplace_back(temp->val); temp = temp->next; } return vec; } }; |
20
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
class MyQueue { public: /** Initialize your data structure here. */ MyQueue() { } /** Push element x to the back of queue. */ void push(int x) { if (stack1.empty()) { stack1.push(x); } else { while(!stack1.empty()) { stack2.push(stack1.top()); stack1.pop(); } stack1.push(x); while(!stack2.empty()) { stack1.push(stack2.top()); stack2.pop(); } } } /** Removes the element from in front of queue and returns that element. */ int pop() { int temp = stack1.top(); stack1.pop(); return temp; } /** Get the front element. */ int peek() { return stack1.top(); } /** Returns whether the queue is empty. */ bool empty() { return stack1.empty(); } private: std::stack<int> stack1, stack2; }; /** * Your MyQueue object will be instantiated and called as such: * MyQueue obj = MyQueue(); * obj.push(x); * int param_2 = obj.pop(); * int param_3 = obj.peek(); * bool param_4 = obj.empty(); */ |
53
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
class Solution { public: vector<int> getLeastNumbers_Solution(vector<int> input, int k) { std::priority_queue<int> test; for (auto item : input) { test.push(item); if (test.size() > k) { test.pop(); } } std::vector<int> vec; while (!test.empty()) { vec.push_back(test.top()); test.pop(); } std::reverse(vec.begin(), vec.end()); return vec; } }; |
75
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class Solution { public: vector<int> findNumbersWithSum(vector<int>& nums, int target) { std::unordered_map<int, int> findmap; for (auto item : nums) { if (findmap[target-item] == 0) { findmap[item]++; } else { return {item, target-item}; } } return {}; } }; |
51
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
class Solution { public: std::vector<bool> flag; std::vector<int> path; std::vector<std::vector<int>> ans; vector<vector<int>> permutation(vector<int>& nums) { std::sort(nums.begin(), nums.end()); flag = std::vector<bool>(nums.size(), false); path = std::vector<int>(nums.size()); dfs(nums, 0, 0); return ans; } void dfs(std::vector<int>& nums, int r, int start) { if (r == nums.size()) { ans.push_back(path); return; } for (int i = start; i < nums.size(); i++) { if (!flag[i]) { flag[i] = true; path[i] = nums[r]; if (r + 1 < nums.size() && nums[r+1] != nums[r]) { dfs(nums, r+1, 0); } else { dfs(nums, r+1, i+1); } flag[i] = false; } } } }; |
26
|
1 2 3 4 5 6 7 8 9 |
#include <bitset> class Solution { public: int NumberOf1(int n) { std::bitset<32> num(n); return num.count(); } }; |
862
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#include <iostream> #include <iomanip> #include <map> using pair_d_s = std::pair<double, std::string>; int main() { int n = 0; std::cin >> n; std::map<int, pair_d_s> maps; while (n--) { int x = 0; double y = 0.0; std::string z; std::cin >> x >> y >> z; maps.insert(std::make_pair(x, std::make_pair(y, z))); } auto ite = maps.begin(); while (ite != maps.end()) { std::cout << ite->first << " " << std::fixed <<std::setprecision(2) << (ite->second).first << " " << (ite->second).second << std::endl; ite++; } return 0; } |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ 【AcWing 语法基础课 第四讲】02/23
- ♥ 【LeetCode-Mar-链表一】03/24
- ♥ 【AcWing 语法基础课 第三讲】02/22
- ♥ 【AcWing 语法基础课 第六讲】03/02
- ♥ 【LeetCode-Aug】08/10
- ♥ 【LeetCode-30 天 JavaScript 挑战】07/23