数据结构与算法之按奇偶排序数组II

开发 前端 算法
一道简单模拟题,来做做看!给定一个非负整数数组 A, A 中一半整数是奇数,一半整数是偶数。对数组进行排序,以便当 A[i] 为奇数时,i 也是奇数;当 A[i] 为偶数时, i 也是偶数。

[[429517]]

一道简单模拟题,来做做看!

按奇偶排序数组II

力扣题目链接:https://leetcode-cn.com/problems/sort-array-by-parity-ii/

给定一个非负整数数组 A, A 中一半整数是奇数,一半整数是偶数。

对数组进行排序,以便当 A[i] 为奇数时,i 也是奇数;当 A[i] 为偶数时, i 也是偶数。

你可以返回任何满足上述条件的数组作为答案。

示例:

  • 输入:[4,2,5,7]
  • 输出:[4,5,2,7]
  • 解释:[4,7,2,5],[2,5,4,7],[2,7,4,5] 也会被接受。

思路

这道题目直接的想法可能是两层for循环再加上used数组表示使用过的元素。这样的的时间复杂度是O(n^2)。

方法一

其实这道题可以用很朴实的方法,时间复杂度就就是O(n)了,C++代码如下:

  1. class Solution { 
  2. public
  3.     vector<int> sortArrayByParityII(vector<int>& A) { 
  4.         vector<int> even(A.size() / 2); // 初始化就确定数组大小,节省开销 
  5.         vector<int> odd(A.size() / 2); 
  6.         vector<int> result(A.size()); 
  7.         int evenIndex = 0; 
  8.         int oddIndex = 0; 
  9.         int resultIndex = 0; 
  10.         // 把A数组放进偶数数组,和奇数数组 
  11.         for (int i = 0; i < A.size(); i++) { 
  12.             if (A[i] % 2 == 0) even[evenIndex++] = A[i]; 
  13.             else odd[oddIndex++] = A[i]; 
  14.         } 
  15.         // 把偶数数组,奇数数组分别放进result数组中 
  16.         for (int i = 0; i < evenIndex; i++) { 
  17.             result[resultIndex++] = even[i]; 
  18.             result[resultIndex++] = odd[i]; 
  19.         } 
  20.         return result; 
  21.     } 
  22. }; 
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

方法二

以上代码我是建了两个辅助数组,而且A数组还相当于遍历了两次,用辅助数组的好处就是思路清晰,优化一下就是不用这两个辅助树,代码如下:

  1. class Solution { 
  2. public
  3.     vector<int> sortArrayByParityII(vector<int>& A) { 
  4.         vector<int> result(A.size()); 
  5.         int evenIndex = 0;  // 偶数下表 
  6.         int oddIndex = 1;   // 奇数下表 
  7.         for (int i = 0; i < A.size(); i++) { 
  8.             if (A[i] % 2 == 0) { 
  9.                 result[evenIndex] = A[i]; 
  10.                 evenIndex += 2; 
  11.             } 
  12.             else { 
  13.                 result[oddIndex] = A[i]; 
  14.                 oddIndex += 2; 
  15.             } 
  16.         } 
  17.         return result; 
  18.     } 
  19. }; 
  • 时间复杂度O(n)
  • 空间复杂度O(n)

方法三

当然还可以在原数组上修改,连result数组都不用了。

  1. class Solution { 
  2. public
  3.     vector<int> sortArrayByParityII(vector<int>& A) { 
  4.         int oddIndex = 1; 
  5.         for (int i = 0; i < A.size(); i += 2) { 
  6.             if (A[i] % 2 == 1) { // 在偶数位遇到了奇数 
  7.                 while(A[oddIndex] % 2 != 0) oddIndex += 2; // 在奇数位找一个偶数 
  8.                 swap(A[i], A[oddIndex]); // 替换 
  9.             } 
  10.         } 
  11.         return A; 
  12.     } 
  13. }; 
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

这里时间复杂度并不是O(n^2),因为偶数位和奇数位都只操作一次,不是n/2 * n/2的关系,而是n/2 + n/2的关系!

其他语言版本

Java

  1. // 方法一 
  2. class Solution { 
  3.     public int[] sortArrayByParityII(int[] nums) { 
  4.         // 分别存放 nums 中的奇数、偶数 
  5.         int len = nums.length; 
  6.         int evenIndex = 0; 
  7.         int oddIndex = 0; 
  8.         int[] even = new int[len / 2]; 
  9.         int[] odd = new int[len / 2]; 
  10.         for (int i = 0; i < len; i++) { 
  11.             if (nums[i] % 2 == 0) { 
  12.                 even[evenIndex++] = nums[i]; 
  13.             } else { 
  14.                 odd[oddIndex++] = nums[i]; 
  15.             } 
  16.         } 
  17.         // 把奇偶数组重新存回 nums 
  18.         int index = 0; 
  19.         for (int i = 0; i < even.length; i++) { 
  20.             nums[index++] = even[i]; 
  21.             nums[index++] = odd[i]; 
  22.         } 
  23.         return nums; 
  24.     } 

Python3

  1. #方法2 
  2. class Solution: 
  3.     def sortArrayByParityII(self, nums: List[int]) -> List[int]: 
  4.         result = [0]*len(nums) 
  5.         evenIndex = 0 
  6.         oddIndex = 1 
  7.         for i in range(len(nums)): 
  8.             if nums[i] % 2: #奇数 
  9.                 result[oddIndex] = nums[i] 
  10.                 oddIndex += 2 
  11.             else: #偶数 
  12.                 result[evenIndex] = nums[i] 
  13.                 evenIndex += 2 
  14.         return result 
  15.  
  16. #方法3 
  17. class Solution: 
  18.     def sortArrayByParityII(self, nums: List[int]) -> List[int]: 
  19.         oddIndex = 1 
  20.         for i in range(0,len(nums),2): #步长为2 
  21.             if nums[i] % 2: #偶数位遇到奇数 
  22.                 while  nums[oddIndex] % 2: #奇数位找偶数 
  23.                     oddIndex += 2 
  24.                 nums[i], nums[oddIndex] = nums[oddIndex], nums[i] 
  25.         return nums 

Go

  1. // 方法一 
  2. func sortArrayByParityII(nums []int) []int { 
  3.  // 分别存放 nums 中的奇数、偶数 
  4.  even, odd := []int{}, []int{} 
  5.  for i := 0; i < len(nums); i++ { 
  6.   if (nums[i] % 2 == 0) { 
  7.    even = append(even, nums[i]) 
  8.   } else { 
  9.    odd = append(odd, nums[i]) 
  10.   } 
  11.  } 
  12.  
  13.  // 把奇偶数组重新存回 nums 
  14.  result := make([]int, len(nums)) 
  15.  index := 0 
  16.  for i := 0; i < len(even); i++ { 
  17.   result[index] = even[i]; index++; 
  18.   result[index] = odd[i]; index++; 
  19.  } 
  20.  return result; 

JavaScript

  1. //方法一 
  2. var sortArrayByParityII = function(nums) { 
  3.     const n = nums.length; 
  4.     // 分别存放 nums 中的奇数、偶数 
  5.     let evenIndex = 0, oddIndex = 0; 
  6.     // 初始化就确定数组大小,节省开销 
  7.     const even = new Array(Math.floor(n/2)); 
  8.     const odd = new Array(Math.floor(n/2)); 
  9.     // 把A数组放进偶数数组,和奇数数组 
  10.     for(let i = 0; i < n; i++){ 
  11.         if(nums[i] % 2 === 0) even[evenIndex++] = nums[i]; 
  12.         else odd[oddIndex++] = nums[i]; 
  13.     } 
  14.     // 把奇偶数组重新存回 nums 
  15.     let index = 0; 
  16.     for(let i = 0; i < even.length; i++){ 
  17.         nums[index++] = even[i]; 
  18.         nums[index++] = odd[i]; 
  19.     } 
  20.     return nums; 
  21. }; 
  22.  
  23. //方法二 
  24. var sortArrayByParityII = function(nums) { 
  25.     const n = nums.length; 
  26.     const result = new Array(n); 
  27.     // 偶数下标 和 奇数下标 
  28.     let evenIndex = 0, oddIndex = 1; 
  29.     for(let i = 0; i < n; i++){ 
  30.         if(nums[i] % 2 === 0) { 
  31.             result[evenIndex] = nums[i]; 
  32.             evenIndex += 2; 
  33.         } else { 
  34.             result[oddIndex] = nums[i]; 
  35.             oddIndex += 2; 
  36.         } 
  37.     } 
  38.     return result; 
  39. }; 
  40.  
  41. //方法三 
  42. var sortArrayByParityII = function(nums) { 
  43.     let oddIndex = 1; 
  44.     for(let i = 0; i < nums.length; i += 2){ 
  45.         if(nums[i] % 2 === 1){ // 在偶数位遇到了奇数 
  46.             while(nums[oddIndex] % 2 !== 0) oddIndex += 2;// 在奇数位找一个偶数 
  47.             [nums[oddIndex], nums[i]] = [nums[i], nums[oddIndex]]; // 解构赋值交换 
  48.         } 
  49.     } 
  50.     return nums; 
  51. }; 

 

责任编辑:姜华 来源: 代码随想录
相关推荐

2023-03-10 08:07:39

数据结构算法计数排序

2023-03-02 08:15:13

2021-07-16 04:57:45

Go算法结构

2023-03-07 08:02:07

数据结构算法数列

2022-01-18 19:13:52

背包问题数据结构算法

2023-03-13 10:08:31

数据结构算法

2023-04-27 09:13:20

排序算法数据结构

2019-03-29 09:40:38

数据结构算法前端

2021-03-23 08:33:22

Java数据结构算法

2017-06-16 09:22:22

数据结构算法链表

2023-03-06 08:10:52

数据结构算法数据

2020-12-31 05:31:01

数据结构算法

2021-04-15 09:36:44

Java数据结构算法

2021-04-16 09:40:52

Java数据结构算法

2020-10-12 11:48:31

算法与数据结构

2009-08-03 17:38:12

排序算法C#数据结构

2020-10-30 09:56:59

Trie树之美

2022-09-26 07:56:53

AVL算法二叉树

2022-09-21 07:57:33

二叉搜索树排序二叉树

2021-03-08 06:28:57

JAVA数据结构与算法稀疏数组
点赞
收藏

51CTO技术栈公众号