层序遍历
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<int> PrintFromTopToBottom(TreeNode* root) {
vector<int> vec;
if(root == nullptr)
return vec;
queue<TreeNode*> que;
que.push(root);
while(!que.empty())
{
TreeNode* cur = que.front();
que.pop();
vec.push_back(cur->val);
if(cur->left != nullptr)
que.push(cur->left);
if(cur->right != nullptr)
que.push(cur->right);
}
return vec;
}
};
/*
struct RandomListNode {
int label;
struct RandomListNode *next, *random;
RandomListNode(int x) :
label(x), next(NULL), random(NULL) {
}
};
*/
class Solution {
public:
RandomListNode* Clone(RandomListNode* pHead)
{
if (pHead == nullptr)
return nullptr;
RandomListNode* cur = pHead;
while (cur != nullptr)
{
RandomListNode* p = cur->next;
cur->next = new RandomListNode(cur->label);
cur = cur->next;
cur->next = p;
cur = p;
}
cur = pHead;
while (cur != nullptr)
{
if (cur->random == nullptr)
cur->next->random = nullptr;
else
cur->next->random = cur->random->next;
cur = cur->next->next;
}
cur = pHead;
RandomListNode* cur1 = pHead->next;
RandomListNode* cur2 = pHead->next;
while (cur != nullptr)
{
cur->next = cur1->next;
cur = cur->next;
if (cur != nullptr)
{
cur1->next = cur->next;
cur1 = cur1->next;
}
}
return cur2;
}
};
void Permutation1(vector<string> &array, string str, int begin)//遍历第begin位的所有可能性
{
if (begin == str.size() - 1)
array.push_back(str);
for (int i = begin; i <= str.size() - 1; i++)
{
if (i != begin && str[i] == str[begin])//有重复字符时,跳过
continue;
swap(str[i], str[begin]);//当i==begin时,也要遍历其后面的所有字符;
Permutation1(array, str, begin + 1);//遍历其后面的所有字符;
//swap(str[i], str[begin]);//取掉这个就可以取消aabb,这种重复的单词
}
}
//要是不考虑字符的重复的话可以这样写
/*void Permutation1(vector<string> &array, string str, int begin)//遍历第begin位的所有可能性
{
if (begin == str.size() - 1)
array.push_back(str);
for (int i = begin; i <= str.size() - 1; i++)
{
swap(str[i], str[begin]);//当i==begin时,也要遍历其后面的所有字符;
Permutation1(array, str, begin + 1);//遍历其后面的所有字符;
swap(str[i], str[begin]);
}
}
*/
vector<string> Permutation(string str) {
//可以用递归来做
vector<string> array;
if (str.size() == 0)
return array;
Permutation1(array, str, 0);
sort(array.begin(), array.end());
return array;
}
int main()
{
Permutation("abbb");
return 0;
}
class Solution {
public:
int MoreThanHalfNum_Solution(vector<int> numbers) {
int count = 0;
int num ;
int size = numbers.size();
for(int i = 0; i < size; ++i)
{
if(count == 0)
{
count = 1;
num = numbers[i];
}
else
{
if(numbers[i] == num)
count++;
else
count--;
}
}
if(count == 0)
return 0;
sort(numbers.begin(),numbers.end());
if(numbers[size / 2] == num)
return num;
else
return 0;
}
};
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> vec;
if(k > input.size())
return vec;
priority_queue<int,vector<int>, greater<int>> heap(input.begin(),input.end());
for(int i = 0; i < k;++i)
{
vec.push_back(heap.top());
heap.pop();
}
return vec;
}
};