Welcome to Subscribe On Youtube

912. Sort an Array

Description

Given an array of integers nums, sort the array in ascending order and return it.

You must solve the problem without using any built-in functions in O(nlog(n)) time complexity and with the smallest space complexity possible.

 

Example 1:

Input: nums = [5,2,3,1]
Output: [1,2,3,5]
Explanation: After sorting the array, the positions of some numbers are not changed (for example, 2 and 3), while the positions of other numbers are changed (for example, 1 and 5).

Example 2:

Input: nums = [5,1,1,2,0,0]
Output: [0,0,1,1,2,5]
Explanation: Note that the values of nums are not necessairly unique.

 

Constraints:

• 1 <= nums.length <= 5 * 104
• -5 * 104 <= nums[i] <= 5 * 104

Solutions

• Java
• C++
• Python
• Go
• TypeScript
• Javascript

• class Solution {
      private int[] nums;
  
      public int[] sortArray(int[] nums) {
          this.nums = nums;
          quikcSort(0, nums.length - 1);
          return nums;
      }
  
      private void quikcSort(int l, int r) {
          if (l >= r) {
              return;
          }
          int x = nums[(l + r) >> 1];
          int i = l - 1, j = r + 1;
          while (i < j) {
              while (nums[++i] < x) {
              }
              while (nums[--j] > x) {
              }
              if (i < j) {
                  int t = nums[i];
                  nums[i] = nums[j];
                  nums[j] = t;
              }
          }
          quikcSort(l, j);
          quikcSort(j + 1, r);
      }
  }
  

• class Solution {
  public:
      vector<int> sortArray(vector<int>& nums) {
          function<void(int, int)> quick_sort = [&](int l, int r) {
              if (l >= r) {
                  return;
              }
              int i = l - 1, j = r + 1;
              int x = nums[(l + r) >> 1];
              while (i < j) {
                  while (nums[++i] < x) {
                  }
                  while (nums[--j] > x) {
                  }
                  if (i < j) {
                      swap(nums[i], nums[j]);
                  }
              }
              quick_sort(l, j);
              quick_sort(j + 1, r);
          };
          quick_sort(0, nums.size() - 1);
          return nums;
      }
  };
  

• class Solution:
      def sortArray(self, nums: List[int]) -> List[int]:
          def quick_sort(l, r):
              if l >= r:
                  return
              x = nums[randint(l, r)]
              i, j, k = l - 1, r + 1, l
              while k < j:
                  if nums[k] < x:
                      nums[i + 1], nums[k] = nums[k], nums[i + 1]
                      i, k = i + 1, k + 1
                  elif nums[k] > x:
                      j -= 1
                      nums[j], nums[k] = nums[k], nums[j]
                  else:
                      k = k + 1
              quick_sort(l, i)
              quick_sort(j, r)
  
          quick_sort(0, len(nums) - 1)
          return nums
  
  

• func sortArray(nums []int) []int {
  	quickSort(nums, 0, len(nums)-1)
  	return nums
  }
  
  func quickSort(nums []int, l, r int) {
  	if l >= r {
  		return
  	}
  	i, j := l-1, r+1
  	x := nums[(l+r)>>1]
  	for i < j {
  		for {
  			i++
  			if nums[i] >= x {
  				break
  			}
  		}
  		for {
  			j--
  			if nums[j] <= x {
  				break
  			}
  		}
  		if i < j {
  			nums[i], nums[j] = nums[j], nums[i]
  		}
  	}
  	quickSort(nums, l, j)
  	quickSort(nums, j+1, r)
  }
  

• function sortArray(nums: number[]): number[] {
      function quickSort(l: number, r: number) {
          if (l >= r) {
              return;
          }
          let i = l - 1;
          let j = r + 1;
          const x = nums[(l + r) >> 1];
          while (i < j) {
              while (nums[++i] < x);
              while (nums[--j] > x);
              if (i < j) {
                  [nums[i], nums[j]] = [nums[j], nums[i]];
              }
          }
          quickSort(l, j);
          quickSort(j + 1, r);
      }
      const n = nums.length;
      quickSort(0, n - 1);
      return nums;
  }
  
  

• /**
   * @param {number[]} nums
   * @return {number[]}
   */
  var sortArray = function (nums) {
      function quickSort(l, r) {
          if (l >= r) {
              return;
          }
          let i = l - 1;
          let j = r + 1;
          const x = nums[(l + r) >> 1];
          while (i < j) {
              while (nums[++i] < x);
              while (nums[--j] > x);
              if (i < j) {
                  [nums[i], nums[j]] = [nums[j], nums[i]];
              }
          }
          quickSort(l, j);
          quickSort(j + 1, r);
      }
      const n = nums.length;
      quickSort(0, n - 1);
      return nums;
  };
  
  

All Problems

All Solutions