简单题，字符串全排列（带重复字符）

层序遍历

/*
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;
    }
};