Leetcode 912. 排序数组（DAY 195）

已于 2023-01-06 20:48:52 修改
阅读量172 收藏 1
点赞数
分类专栏： 从c++开始的进步之路 # Leetcode算法之路-Medium 文章标签： c++
于 2021-11-01 21:08:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37500516/article/details/121088679
版权

文章目录

原题题目

在这里插入图片描述

代码实现（首刷三分钟 手撕快排递归）

class Solution {
public:
    int partition(vector<int>& nums,int left,int right)
    {
        int lo = left,hi = right + 1,mid = (lo + (hi - lo) / 2);
        swap(nums[left],nums[mid]);
        while(lo < hi)
        {
            while(lo < right && nums[++lo] <= nums[left]);
            while(hi > left && nums[--hi] >= nums[left]);
            if(lo < hi)
                swap(nums[lo],nums[hi]);
        }

        swap(nums[hi],nums[left]);
        return hi;
    }

    void qsort(vector<int>& nums,int left,int right)
    {
        if(left >= right)   return;
        int mid = partition(nums,left,right);
        qsort(nums,left,mid - 1);
        qsort(nums,mid + 1,right);
    }

    vector<int> sortArray(vector<int>& nums) {
        qsort(nums,0,nums.size() - 1);
        return nums;
    }
};

代码实现（首刷自解 快排非递归 TLE 8/13）

class Solution {
public:
    int partition(vector<int>& nums,int left,int right)
    {
        int lo = left,hi = right + 1,mid = (lo + (hi - lo) / 2);
        swap(nums[left],nums[mid]);
        while(lo < hi)
        {
            while(lo < right && nums[++lo] <= nums[left]);
            while(hi > left && nums[--hi] >= nums[left]);
            if(lo < hi)
                swap(nums[lo],nums[hi]);
        }

        swap(nums[hi],nums[left]);
        return hi;
    }

    void qsort(vector<int>& nums,int left,int right)
    {
        if(left >= right)   return;
        stack<pair<int,int>> stack;
        stack.emplace(left,right);
        while(!stack.empty())
        {
            auto pair = stack.top();
            stack.pop();
            int lo = pair.first,hi = pair.second;
            int mid = partition(nums,lo,hi);
            if(mid > lo)  stack.emplace(left,mid - 1);
            if(mid < hi)  stack.emplace(mid + 1,hi);
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        qsort(nums,0,nums.size() - 1);
        return nums;
    }
};

代码实现（二刷自解 堆排序 DAY 198 C++）

class Solution {
public:
    class minheap
    {
    public:
        vector<int> heap;
        minheap() {heap.clear();}
        minheap(vector<int>& v)
        { 
            heap = v;
            for(int i = (heap.size() - 1) / 2;i >= 0;--i)
                adjustheap(heap,i);
        }

        void adjustheap(vector<int>& heap,int pos)
        {
            if(heap.empty() || pos == heap.size()-1)
                return;

            int val = heap[pos];
            int maxpos = heap.size() - 1;
            for(int i = pos*2+1;i <= maxpos;i = pos*2+1)
            {
                if(i < maxpos && heap[i+1] < heap[i])   ++i;
                if(val <= heap[i])  break;

                heap[pos] = heap[i];
                pos = i;
            }
            heap[pos] = val;
        }

        void push(int val)
        {
            int pos = heap.size();
            heap.emplace_back(val);
            for(;val < heap[(pos - 1)/2];pos = (pos - 1)/2)
            {
                heap[pos] = heap[(pos - 1) / 2];
                if(pos == 0)    break;
            }
            heap[pos] = val;
        }

        int pop()
        {
            int ret = heap[0];
            int pos = heap.size() - 1;
            heap[0] = heap.back();
            heap.pop_back();
            adjustheap(heap,0);
            return ret;
        }

        bool empty()
        {
            return !heap.size();
        }

    };

    vector<int> sortArray(vector<int>& nums) {
        minheap heap(nums);
        vector<int> ret;

        while(!heap.empty())
            ret.emplace_back(heap.pop());
        return ret;
    }
};

代码实现（三刷自解 归并排序 DAY 213 C++）

class Solution {
public:
    void merge_nums(vector<int>& nums,vector<int>& tmp,int left,int right)
    {
        int l = left,mid = (left + right) / 2,r = mid+1,pos = left;
        while(l <= mid || r <= right)
        {
            if(l > mid || r > right)
            {
                if(l > mid)   tmp[pos++] = nums[r++];
                else          tmp[pos++] = nums[l++];
            }
            else
            {
                if(nums[l] <= nums[r])
                    tmp[pos++] = nums[l++];
                else
                    tmp[pos++] = nums[r++];
            }
        }

        for(int i=left;i<=right;++i)
            nums[i] = tmp[i];
    }

    void merge_sort(vector<int>& nums,vector<int>& tmp,int left,int right)
    {
        if(left >= right)   return; 
        int mid = (left + right) / 2;

        merge_sort(nums,tmp,left,mid);
        merge_sort(nums,tmp,mid+1,right);
        merge_nums(nums,tmp,left,right);
    }

    vector<int> sortArray(vector<int>& nums) {
        vector<int> tmp(nums.size(),0);
        merge_sort(nums,tmp,0,nums.size()-1);
        return nums;
    }
};

代码实现（四刷自解 DAY 269 C++）

class Solution {
public:
    void merge(vector<int>& nums, vector<int>& tmp, int left, int right)
    {
      int mid = ((right - left) >> 1) + left;
      int l = left,r = mid + 1,pos = left;
      while(l <= mid && r <= right)
      {
        if(nums[l] <= nums[r])
          tmp[pos++] = nums[l++];
        else
          tmp[pos++] = nums[r++];
      }

      while(l <= mid)   tmp[pos++] = nums[l++];
      while(r <= right) tmp[pos++] = nums[r++];

      for(int i = left; i <= right; ++i)
        nums[i] = tmp[i];
      
      return;
    } 

    void merge_sort(vector<int>& nums, vector<int>& tmp, int left, int right)
    {
      if( left >= right )   return;

      int mid = ((right - left) >> 1) + left;
      merge_sort(nums, tmp, left, mid);
      merge_sort(nums, tmp, mid + 1, right);
      merge(nums, tmp, left, right);
    }

    vector<int> sortArray(vector<int>& nums) {
        vector<int> tmp(nums);
        merge_sort(nums, tmp, 0, nums.size() - 1);
        return nums; 
    }
};

代码实现（五刷自解 堆排序 DAY 293 C++）

class Heap {
 public:
  Heap() {}
  Heap(vector<int>& heap__) : heap_(heap__) {
    for (int i = heap_.size() / 2 - 1; i >= 0; --i) {
      Heapify(i);
    }    
  }
  
  void Heapify(int pos) {
    int val = heap_[pos];
    int nextpos = pos * 2 + 1;

    for (; nextpos < heap_.size(); nextpos = nextpos * 2 + 1) {
      if (nextpos < heap_.size() - 1 && heap_[nextpos + 1] < heap_[nextpos]) {
        ++nextpos;
      }

      if (val > heap_[nextpos]) {
        heap_[pos] = heap_[nextpos]; 
        pos = nextpos;
      } else {
        break;
      }
    }
    heap_[pos] = val;
  }

  void Push(int val) {
    heap_.emplace_back(val);
    
    int pos = heap_.size() - 1;
    while (pos > 0) {
      int nextpos = (pos - 1) / 2; 
      if (heap_[nextpos] > val) {
        heap_[pos] = heap_[nextpos];
        pos = nextpos;
      } else {
        break;
      }
    }
    heap_[pos] = val;
  }

  void Pop() {
    int lastelem = heap_.back();
    heap_.pop_back();
    heap_[0] = lastelem;
    Heapify(0);
  }

  int Top() const {
    return heap_[0];
  }

  bool Empty() const {
    return heap_.size() == 0;
  }

 private:
  vector<int> heap_;
};

class Solution {
 public:
  vector<int> sortArray(vector<int>& nums) {
    vector<int> ret;
    Heap heap;

    for (const auto& num : nums) {
      heap.Push(num);
    }

    while (!heap.Empty()) {
      ret.emplace_back(heap.Top());
      heap.Pop();
    }
    return ret;
  }
};

代码实现（六刷自解 归并排序 DAY 300 C++）

class Solution {
 public:
  void Merge(vector<int>& nums, vector<int>& tmp, int left, int right) {
    int mid = (left + right) / 2;
    int l = left, r = mid + 1;
    int pos = l;
    while (l <= mid && r <= right) {
      if (nums[l] <= nums[r]) {
        tmp[pos++] = nums[l++];
      } else {
        tmp[pos++] = nums[r++];
      }
    }

    while (l <= mid) tmp[pos++] = nums[l++];
    while (r <= right) tmp[pos++] = nums[r++];

    for (int i = left; i <= right; ++i) {
      nums[i] = tmp[i];
    }
  }

  void MergeSort(vector<int>& nums, vector<int>& tmp, int left, int right) {
    if (left >= right)  return;
    int mid = (left + right) / 2;
    MergeSort(nums, tmp, left, mid);
    MergeSort(nums, tmp, mid + 1, right);
    Merge(nums, tmp, left, right);
  }

  vector<int> sortArray(vector<int>& nums) {
    vector<int> tmp(nums.size(), 0);
    MergeSort(nums, tmp, 0, nums.size() - 1);
    return nums;
  }
};

代码实现（七刷自解 DAY 1 Golang）

func swap(x, y int) (int, int) {
  return y, x
}

func QuickSort(nums []int, left, right int) {
  if (left >= right) {
    return
  }

  mid := ((right - left) >> 1) + left
  nums[left], nums[mid] = swap(nums[left], nums[mid])
  l, r, pivot := left, right + 1, nums[left]

  for l < r {
    for l < right {
      l++
      if nums[l] >= pivot {
        break
      }
    }

    for r > left {
      r--
      if nums[r] <= pivot {
        break
      }
    }
    if l < r {
      nums[l], nums[r] = swap(nums[l], nums[r])
    } else {
      break
    }
  }

  nums[left], nums[r] = swap(nums[left], nums[r])  
  QuickSort(nums, left, r - 1)
  QuickSort(nums, r + 1, right)
}

func sortArray(nums []int) []int {
  QuickSort(nums, 0, len(nums) - 1)
  return nums
}

代码实现（八刷自解 DAY 10 Golang）

type Heap struct {
  heap []int
}

func (this *Heap) Construct(nums []int) {
  this.heap = nums
  for i := len(this.heap) / 2; i >= 0; i-- {
    this.Heapify(i)
  }
}

func (this *Heap) Heapify(pos int) {
  val, nextpos := this.heap[pos], pos * 2 + 1
  size := len(this.heap)
  for ; nextpos < size; nextpos = nextpos * 2 + 1 {
    if nextpos < size - 1 && this.heap[nextpos] > this.heap[nextpos + 1] {
      nextpos = nextpos + 1
    }
    if val > this.heap[nextpos] {
      this.heap[pos] = this.heap[nextpos]
      pos = nextpos
    } else {
      break
    }
  }
  this.heap[pos] = val
}

func (this *Heap) Push(val int) {
  this.heap = append(this.heap, val)
  pos := len(this.heap) - 1
  
  for pos > 0 {
    if this.heap[(pos - 1) / 2] > this.heap[pos] {
      this.heap[pos] = this.heap[(pos - 1) / 2]
      pos = (pos - 1) / 2
    } else {
      break
    }
  }

  this.heap[pos] = val
}

func (this *Heap) Pop() int {
  ret := this.heap[0]
  this.heap[0] = this.heap[len(this.heap) - 1]
  this.Heapify(0)
  this.heap = this.heap[: len(this.heap) - 1]
  
  return ret
}

func (this *Heap) Empty() bool {
  return len(this.heap) == 0
}

func sortArray(nums []int) []int {
  heap_ := Heap{}
  heap_.Construct(nums)

  ret := make([]int, 0)
  for heap_.Empty() == false {
    ret = append(ret, heap_.Pop())
  }
  return ret
}

代码实现（九刷自解 DAY 12 golang）

func mergeSort(nums, tmp []int, left, right int) {
  if left >= right {
    return
  }

  mid := ((right - left) >> 1) + left
  mergeSort(nums, tmp, left, mid)
  mergeSort(nums, tmp, mid + 1, right)

  l, r, pos := left, mid + 1, left
  for l <= mid && r <= right {
    if nums[l] <= nums[r] {
      tmp[pos] = nums[l]
      l++
    } else {
      tmp[pos] = nums[r]
      r++
    }
    pos++
  }
  for l <= mid { 
    tmp[pos] = nums[l] 
    pos, l = pos + 1, l + 1
  }
  for r <= right { 
    tmp[pos] = nums[r] 
    pos, r = pos + 1, r + 1
  }

  for i := left; i <= right; i++ {
    nums[i] = tmp[i]
  }
}

func sortArray(nums []int) []int {
  tmp := make([]int, len(nums))
  mergeSort(nums, tmp, 0, len(tmp) - 1)
  
  return nums
}
Love 6
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode卡-30-day-leetcoding-challenge:https://leetcode.com/explore/chal
07-06
2. **算法**：包括排序（快速排序、归并排序、插入排序等）、搜索（二分查找、深度优先搜索、广度优先搜索等）、图论算法（最短路径、拓扑排序等）以及动态规划等。掌握这些算法是提高解题效率的关键。 3. **递归与...
LeetCode:LeetCode每天day
04-22
解决这个问题的一种常见方法是排序数组，然后比较相邻元素之间的差值，找到最小差值。在JavaScript中，可以使用内置的`sort()`函数对数组进行排序，然后遍历排序后的数组，比较相邻元素。为了优化性能，还可以考虑...
Leetcode189. 轮转数组
ProgramNovice的博客
03-15 1481
Every day a leetcode 题目来源：189. 轮转数组 解法1：模拟 每次右移一个，执行k次。 代码： void oneRotate(int* nums, int numsSize) { int temp=nums[numsSize-1]; for(int i=numsSize-1;i>0;i--) { nums[i]=nums[i-1]; } nums[0]=temp; } void rotate(int* nums, int
Leetcode977. 有序数组的平方
ProgramNovice的博客
03-15 753
Every day a leetcode 题目来源：977. 有序数组的平方 解法1：排序 遍历一次数组，每个元素取平方后排序。 代码： /** * Note: The returned array must be malloced, assume caller calls free(). */ int cmpfunc (const void * a, const void * b) { return ( *(int*)a - *(int*)b ); } int* sortedSquares(
Leetcode2966. 划分数组并满足最大差限制
ProgramNovice的博客
01-06 505
Leetcode2966. 划分数组并满足最大差限制
LeetCode977. 有序数组的平方(day0024_2)
distant_Rove666的博客
06-23 85
给你一个按 非递减顺序 排序的整数数组 ，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。示例 1： 示例 2： 提示： 已按 非递减顺序 排序暴力算法： 双指针法：
LeetCode 977. 有序数组的平方（简单、数组）day23
qq_43751200的博客
05-10 59
题目描述：给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。 示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100] 示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121] 提示： 1 <= nums.length <= 104 -104 &lt
刷题日记 Day 2 : Leetcode 977 . 有序数组的平方、Leetcode 209 . 长度最小的子数组、Lettcode 59 : 螺旋数组 II
m0_53117341的博客
03-16 255
题目链接 977. 有序数组的平方 这道题 , 暴力方法非常好想出来 , 首先 , 我们可以将数组中所有元素都转成正数 (对负数元素取相反数) , 然后对此时的数组进行排序 , 排序之后我们就可以把每个元素平方 , 就通过这道题了 那么这道题 , 最妙的办法就是双指针算法 我们来看图~ 那双指针思路的有序数组的平方也非常好实现了 , 代码就在这里 二 . Leetcode 209 . 长度最小的子数组 题目链接 : 209. 长度最小的子数组 这道题 , 是双指针算法的一道变种题 , 通过两个指针之间范围
Leetcode3010. 将数组分成最小总代价的子数组 I
ProgramNovice的博客
02-16 337
Leetcode3010. 将数组分成最小总代价的子数组 I
Day2|Leetcode977. 有序数组的平方 Leetcode209. 长度最小的子数组 Leetcode59. 螺旋矩阵 II
weixin_72635630的博客
10-26 1120
解释一下为什么可以用双指针：对于nums来说，平方之后的元素一定是两边的最大，从外向里依次是从大到小，所以就可以用双指针来比较平方后元素的大小，大的放新数组的最后，然后通过指针的移动，不停的靠近最中间，当两指针重合时，就完成了新数组元素的传递。本题目的主要思路就是一个运用二维数组，而在讨论边界情况时一定要注意循环不变量问题，边界讨论时一定要有规律。这个题第一眼看的时候就是暴力法：先把数组中的每个元素平方，然后直接一个快排就解决了。第一种暴力法，把全部的符合的集合区间全部求出来，然后来一个判断解决全部问题。
Leetcode945. 使数组唯一的最小增量
ProgramNovice的博客
02-24 159
Every day a leetcode 题目来源：945. 使数组唯一的最小增量 解法1：hash计数 用一个hash表统计nums中各数字出现的次数。 设置count统计+1的次数。 遍历hash表，若hash[i]>1，说明有重复个数字，根据贪心的思想，应该将hash[i]-1个该值+1，则有： count+=hash[i]-1; hash[i+1]+=hash[i]-1; hash[i]=1; 结果： 无论是int，还是long long，都溢出了。 解法2：快排+贪心 先将nums数组从
算法day2 | LeetCode 977. 有序数组的平方，LeetCode 209. 长度最小的子数组，LeetCode 59. 螺旋矩阵||
weixin_47436601的博客
10-13 148
算法刷题第二天，LeetCode 977. 有序数组的平方，LeetCode 209. 长度最小的子数组，LeetCode 59. 螺旋矩阵||
记录自己的LeetCode之day6（双指针，部分排序）
01-20
重回双指针，排序还有几个坑没填回头再填。 今天的题目是 680 验证回文子串II 215 数组中的第k个最大元素 680 验证回文子串II 思路如下： 在List的最左边和最右边插入指针，如果指针所指字母相同则i++，j- – 如果...
leetcode2sumc-leetcode_day_by_day:leetcode_day_by_day
07-06
天：从排序数组中删除重复项 给定一个已排序的数组，删除原地重复项，使每个元素只出现一次并返回新的长度。 C： int removeDuplicates(int* nums, int numsSize) { if (numsSize == 0) return 0; int index = 1; ...
leetcode2-Day3:第3天
06-29
leetcode 2 第3天 ...给定一个未知长度的排序数组和一个要搜索的数字，返回该数字在数组中的索引。 越界访问元素会引发异常。 如果该数字出现多次，则返回任何出现的索引。 如果不存在，则返回 -1。
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1134
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 330
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++中的模板函数和模板类
2302_81171591的博客
07-22 659
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
最新发布
siu~
07-24 757
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Love 6

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值