冒泡排序（遍历一次之后，把最大的放到了最后面）
function bubble(arr) {
for(let i=0;i<arr.length-1;i++){
for(let j=0;j<arr.length-1-i;j++){
let temp = ''
temp = arr[j]
if(arr[j]>arr[j+1]){
arr[j] = arr [j+1]
arr[j+1] = temp
}
}
}
return arr
}
// 外层的循环记录总的循环次数，里层的循环进行比对交换
const result = bubble([3,2,1,4])
console.log('result', result)
选择排序（不断地从某个位置之后找最小的做交换）
function select(arr) {
for(let i=0;i<arr.length-1;i++){
let min = arr[i]
for(let j=i+1;j<arr.length;j++){
let temp = ''
if(arr[j]<min){
temp = min
min = arr[j]
arr[j] = temp
}
}
arr[i] = min
}
return arr
}
const result = select([3,2,1,4,8,6]) // 1,2,3,4
console.log('result', result)
// 首先在未排序的数列中找到最小(or最大)元素，然后将其存放到数列的起始位置；接着，再从剩余未排序的元素中继续寻找最小(or最大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
// 每次选出最小的按奇偶排序数组
给定一个非负整数数组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]也会被接受
function sort(arr) {
arr.sort((a,b)=>a-b)
let r = [] // 存放按奇偶排好序的数组
let odd = 1 // 奇数下标
let even = 0 // 偶数下标
arr.forEach(item=>{
if(item%2===1){
r[odd] = item
odd = odd + 2
} else {
r[even] = item
even = even + 2
}
})
return r
}
const result = sort([4,2,5,7])
console.log(result)
数组中的第k个最大元素
在未排序的数组中找到第k个最大的元素。请注意，你需要找的是数组排序后的第k个最大的元素，而不是第k个不同的元素。
示例1：输入：[3,2,1,5,6,4]和k=2
输出：5
示例2：输入：[3,2,3,1,2,4,5,5,6]和k=4
输出：4
// 在排序中找第k个最大的值，冒泡排序进行到第k次时，第k个最大值就已经出现了
function getValue(arr,k) {
for(let i=arr.length;i>arr.length-1-k;i--){
for(let j=0;j<i;j++){
if(arr[j]>arr[j+1]){
let temp = arr[j+1]
arr[j+1] = arr[j]
arr[j] = temp
}
}
}
return arr[arr.length-k]
}
// const result = getValue([3,2,1,5,6,4], 2)
const result = getValue([3,2,3,1,2,4,5,5,6], 4)
console.log(result)
最大间距
给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。
如果数组元素个数小于2，则返回0
示例1：输入：[3,6,9,1]
输出：3
解释：排序后的数组是[1,3,6,9]，其中相邻元素（3,6）和（6,9）之间都存在最大差值3.
// 排好序，遍历寻找差值
function getValue(arr) {
if(arr.length<2){
return 0
}
arr.sort()
let max = 0
for(let i=0;i<arr.length;i++){
const temp = arr[i+1]-arr[i]
if(max<temp){
max = temp
}
}
return max
}
// 在排序的过程中，寻找最大差值；在排序进行完第二遍循环时，数组的最后两位数已经排好序了，可以进行差值比较了
function getValue2(arr) {
if(arr.length<2){
return 0
}
let max = 0
for(let i=0;i<arr.length;i++){
for(let j=0;j<arr.length-i;j++){
if(arr[j]>arr[j+1]){
let temp = ''
temp = arr[j+1]
arr[j+1] = arr[j]
arr[j] = temp
}
}
if(i>=1){
const tp = arr[arr.length-i] - arr[arr.length-i-1]
if(max<tp){
max = tp
}
}
}
return max
}
const result2 = getValue2([2,9,5,4])
const result = getValue([2,9,5,4]) // i=1, 2, length=4-1=3 4-2=2
// const result = getValue([2])
console.log('result', result, result2)
缺失的第一个正数
给定一个未排序的整数数组，找出其中没有出现的最小的正整数。
示例1：输入:[1,2,0]
输出：3
示例2：输入：[3,4,-1,1]
输出：2
// 先排序，再循环
// 如果第一个数不是1，则返回1；如果是1，再比较第二个数和第一个数的差值，如果大于1，返回第一个数+1
function getValue(arr) {
arr = arr.filter(item=>item>0)
arr.sort((a,b)=>a-b)
if(arr[0]!==1){
return 1
}else{
for(let i=0;i<arr.length-1;i++){
if(arr[i+1]-arr[i]>1){
return arr[i]+1
}
}
return arr.pop()+1
}
}
// 在排序中比较
// 先找到第一个最小的数，如果不是1，返回1，结束排序；如果是1，继续往下排序；从第二次循环开始，就可以比较两数的差值，如果大于1，就返回前一个数+1；如果排序结束都没有返回值，说明数组是从1开始连续的，就返回数组的最后一个值加1
function getValue2(arr) {
arr=arr.filter(item=>item>0)
// let value = 0
for(let i=0;i<arr.length;i++){
let min = arr[i]
for(let j=i+1;j<arr.length;j++){
if(arr[j]<min){
let temp = min
min = arr[j]
arr[j] = temp
}
}
arr[i] = min
if(i>0){
if(arr[i]-arr[i-1]>1){
return arr[i-1]+1
}
} else {
if(min!==1){
return 1
}
}
}
return arr.pop()+1
}
// const result = getValue([3,4,1,-1])
// const result1 = getValue([3,4,5,-1])
// const result2 = getValue([3,4,5,1,2])
// const result3 = getValue([3,4,5,1,2,6,8])
const result = getValue2([3,4,1,-1])
const result1 = getValue2([3,4,5,-1])
const result2 = getValue2([3,4,5,1,2])
const result3 = getValue2([3,4,5,1,2,6,7,10])
console.log(result,result1,result2,result3)
// console.log(result)
