题目1 ：给你一个数组 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。
解法一 暴力解法-直接用两个for循环来结题 这也是作者最开始想到的办法
/ 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int size = nums.size();
for (int i = 0; i < size; i++) {
if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
for (int j = i + 1; j < size; j++) {
nums[j - 1] = nums[j];
}
i--; // 因为下表i以后的数值都向前移动了一位，所以i也向前移动一位
size--; // 此时数组的大小-1
}
}
return size;
}
};解法二 双向指针解法（图借鉴于代码随想录 (programmercarl.com)）
这样就不需要利用两个fou 循环反复进行覆盖
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int size = nums.size();
for (int i = 0; i < size; i++) {
if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
for (int j = i + 1; j < size; j++) {
nums[j - 1] = nums[j];
}
i--; // 因为下表i以后的数值都向前移动了一位，所以i也向前移动一位
size--; // 此时数组的大小-1
}
}
return size;
}
};题目2 ：
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。(来源：力扣（LeetCode）)
解法一：双向箭头，向中间走
class Solution {
public:
void moveZeroes(vector<int>& nums)
{
int end = nums.size()-1;
int beg = 0;
if(nums.size()>=2)
{
//双向指针，判断队头
while(beg<end){
if(nums[beg] == 0){
nums.push_back(0);
nums.erase(nums.begin()+beg);
end--;
}
//队头的元素为0 ，即可不变，反之加一
else{
beg ++;
}
//双尾指针，判断队尾
if(nums[end] == 0&&beg!=end){
nums.push_back(0);
nums.erase(nums.begin()+end);
end--;
}
}
}
}
};
解法二：快慢指针
class Solution {
public:
void moveZeroes(vector<int>& nums)
{
int slow_index = 0;
for(int faster_index =0;faster_index<nums.size();faster_index++){
if(nums[faster_index]!=0){
nums[slow_index++] = nums[faster_index];
}
}
for(;slow_index<nums.size();slow_index++){
nums[slow_index]=0;
}
}
};二、快速排序
# include<iostream>
# include<vector>
using namespace std;
void quickrank(vector<int> &q, int l, int r) {
if (l < r) {
int i = l, j = r;
int x = q[l];
while (i < j) {
while (i < j && q[j] >= x) j--;
if (i < j) {
q[i] = q[j];
i++;
}
while (i < j && q[i] < x) i++;
if (i < j) {
q[j] = q[i];
j--;
}
}
q[i] = x;
quickrank(q, l, i - 1);
quickrank(q, i + 1, r);
}
return;
}
int main()
{
vector<int> q;
for (int i = 0; i < 10; i++) {
q.push_back(11-i);
}
quickrank(q, 0, 9);
for (int i = 0; i < 10; i++) {
cout << q[i] << endl;;
}
return 0;
}三、堆排序
递增
# include<iostream>
# include<vector>
using namespace std;
void max_head(vector<int>& nums, int dad, int end) {
int son = 2 * dad + 1;
while (son <= end) {
if (son + 1 <= end && nums[son] < nums[son + 1]) {
son++;
}
if (nums[son] < nums[dad]) {
return;
}
else {
swap(nums[dad], nums[son]);
dad = son;
son = 2 * dad + 1;
}
}
}
void head_sort(vector<int>& nums) {
int len = nums.size();
//建立最大堆
for (int i = len / 2 - 1; i >= 0; i--) {
max_head(nums, i, len - 1);
}
//对最大堆进行排序
for (int i = len - 1; i > 0; i--) {
swap(nums[i], nums[0]);
max_head(nums, 0, i - 1);
}
}
int main() {
vector<int> q;
for (int i = 0; i < 10; i++) {
q.push_back(11 - i);
}
q.push_back(-1);
head_sort(q);
for (int i = 0; i < 10; i++) {
cout << q[i] << " ";;
}
return 0;
}递减
# include<iostream>
# include<vector>
using namespace std;
void min_head(vector<int>& nums, int dad, int end) {
int son = 2 * dad + 1;
while (son <= end) {
if (son + 1 <= end && nums[son] > nums[son + 1]) {
son++;
}
if (nums[son] > nums[dad]) {
return;
}
else {
swap(nums[dad], nums[son]);
dad = son;
son = 2 * dad + 1;
}
}
}
void head_sort(vector<int>& nums) {
int len = nums.size();
//建立最大堆
for (int i = len / 2 - 1; i >= 0; i--) {
min_head(nums, i, len - 1);
}
//对小顶堆进行排序,结果出来为大顶堆
for (int i = len - 1; i > 0; i--) {
swap(nums[i], nums[0]);
min_head(nums, 0, i - 1);
}
}
int main() {
vector<int> q;
for (int i = 0; i < 10; i++) {
q.push_back(11 - i);
}
q.push_back(-1);
head_sort(q);
for (int i = 0; i < 10; i++) {
cout << q[i] << " ";;
}
四、前K个紧邻元素
// 时间复杂度：O(nlogk)
// 空间复杂度：O(n)
class Solution {
public:
// 小顶堆
class mycomparison {
public:
bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second > rhs.second;
}
};
vector<int> topKFrequent(vector<int>& nums, int k) {
// 要统计元素出现频率
unordered_map<int, int> map; // map<nums[i],对应出现的次数>
for (int i = 0; i < nums.size(); i++) {
map[nums[i]]++;
}
// 对频率排序
// 定义一个小顶堆，大小为k
priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
// 用固定大小为k的小顶堆，扫面所有频率的数值
for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
pri_que.push(*it);
if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
pri_que.pop();
}
}
// 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
vector<int> result(k);
for (int i = k - 1; i >= 0; i--) {
result[i] = pri_que.top().first;
pri_que.pop();
}
return result;
}
};