【Go】 最短无序连续子数组 #数组 Easy

本文介绍了一种算法,用于寻找一个整数数组中最短的连续子数组,通过对该子数组进行升序排序,可以使整个数组变为升序。通过复制并排序原始数组,对比两数组差异来确定子数组的起止位置。

给定一个整数数组,你需要寻找一个连续的子数组,如果对这个子数组进行升序排序,那么整个数组都会变为升序排序。

你找到的子数组应是最短的,请输出它的长度。

输入: [2, 6, 4, 8, 10, 9, 15] , 输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序,那么整个表都会变为升序排序。

说明 :

输入的数组长度范围在 [1, 10,000]。
输入的数组可能包含重复元素 ,所以升序的意思是<=。

解法一:

好难写啊! 复制数组就花了好长时间,
num2 需要先切一个与 nums 等长的切片出来,再往里面复制值才会成功。

另外go竟然不支持三元表达式,这真的不习惯啊。

思路
复制一个新数组 num2 ,对新数组排序,再比较两个数组的元素是否一致,从而找出最短子数组的开始-结束位置。

func findUnsortedSubarray(nums []int) int {

	num2 := make([]int,len(nums))
	copy(num2,nums)
	sort.Ints(num2)

	lo,hi :=-1,-1

	for key,value  := range nums {
		if lo==-1 && value != num2[key] {
			lo=key;
		}
		if value != num2[key] {
			hi = key
		}
	}

	if hi == lo {
		return 0
	}
	
	return hi-lo+1
}

执行用时:76 ms
已经战胜 24.00 % 的 golang 提交记录

### 排序无序数字数组的方法 在对一个无序的数字数组进行排序时,可以选择多种排序算法,具体取决于数据规模、性能需求以及实现语言。以下将介绍几种常见的排序方法及其具体实现。 #### 快速排序(Quick Sort) 快速排序是一种高效的排序算法,基于分治法原理。它选择一个基准元素,将数组划分为两个子数组:一部分包含比基准小的元素,另一部分包含比基准大的元素,然后递归地对这两个子数组进行排序。这种方法在大多数情况下表现良好,平均时间复杂度为 $ O(n \log n) $。 以下是快速排序的 Python 实现: ```python def quick_sort(arr): if len(arr) <= 1: return arr else: # 选择基准值 pivot = arr[len(arr) // 2] # 分别存放比基准小、等于和大的元素 left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] # 递归地对左右两边进行快排,并合并结果 return quick_sort(left) + middle + quick_sort(right) # 示例输入 numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] print(quick_sort(numbers)) # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] ``` #### 归并排序(Merge Sort) 归并排序同样基于分治法,将数组分成两个子数组,分别对它们进行排序,然后将结果合并为一个有序数组。归并排序的时间复杂度始终为 $ O(n \log n) $,适合处理大规模数据[^3]。 Python 实现如下: ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = merge_sort(arr[:mid]) right = merge_sort(arr[mid:]) return merge(left, right) def merge(left, right): result = [] i = j = 0 while i < len(left) and j < len(right): if left[i] < right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result.extend(left[i:]) result.extend(right[j:]) return result # 示例输入 numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] print(merge_sort(numbers)) # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] ``` #### 冒泡排序(Bubble Sort) 冒泡排序是一种简单但效率较低的排序算法,其时间复杂度为 $ O(n^2) $,适合小规模数据或教学用途。它通过重复遍历数组,比较相邻元素并交换位置来实现排序[^2]。 Kotlin 实现如下: ```kotlin fun bubbleSort(nums: MutableList<Int>): MutableList<Int> { val n = nums.size for (i in 0 until n) { for (j in 0 until n - i - 1) { if (nums[j] > nums[j + 1]) { val temp = nums[j] nums[j] = nums[j + 1] nums[j + 1] = temp } } } return nums } // 示例输入 val numbers = mutableListOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5) println(bubbleSort(numbers)) // 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] ``` #### 系统内置排序方法 在实际开发中,通常建议使用系统提供的排序方法,例如 Objective-C 中的 `sortedArrayUsingComparator` 方法可以对自定义对象数组进行排序,代码简洁且性能良好[^1]。 Objective-C 示例: ```objective-c NSArray *orderArray = [oldArray sortedArrayUsingComparator:^NSComparisonResult(CustomModel * _Nonnull model1, CustomModel *_Nonnull model2) { NSInteger number1 = model1.number; NSInteger number2 = model2.number; return number1 > number2 ? NSOrderedDescending : NSOrderedAscending; }]; ``` ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值