写过的算法题记录

function bubbleSort(arr){
    let len = arr.length
    if(len < 2) return arr
    for(let i = 0 ; i < len; i++){
        for(let j = 0; j < len - i -1; j++){
            if(arr[j] > arr[j+1]){
                swap(arr[j],arr[j+1])
            }

        }
    }
}

function selectSort(arr){
    if(arr.length <2) return arr
    let len = arr.length
    let minIndex
    for(let i = 0; i < len; i++){
        for(let j = 0; j < len - i -1; j++){
            if(arr[j] > arr[j+1]){
                minIndex = j
            }
        }
        swap(arr[minIndex],i)
    }
}

function getMax(arr,start,end){
    if(start == end){
        return arr[end]
    }
    let mid = Math.floor((start+end)/2)
    let maxLeft = getMax(start,mid)
    let maxRight = getMax(mid+1,end)
    return maxLeft > maxRight ? maxLeft : maxRight
}

//先分割后排序
function merge(arr,start,end){
    if(start == end){
        return
    }
    let mid = (left+right)/2
    merge(start,mid)
    merge(mid+1,end)
    let tmpArr = []
    let leftIndex = start
    let rightindex = mid +1
    while(leftIndex < mid && rightindex <end){     
        if(arr[leftIndex] < arr[rightindex]){
            tmpArr.push(arr[leftIndex++])
        }else{
            tmpArr.push(arr[rightindex++])
        }
    }
    while(leftIndex <mid){
        tmpArr.push(arr(leftIndex++))
    }
    while(rightindex < end){
        tmpArr.push(arr[rightindex])
    }
}

function littleSum(arr,left,right){
    if(left == right) return 0
    let mid = (left+right)/2
    let leftSum = littleSum(arr,left,mid)
    let rightSum = littleSum(arr,mid+1,right)
    let total = leftSum + rightSum
    let leftIndex = left, rightIndex = mid+1
    while(leftIndex <= mid && rightIndex <= right){
        if arr[leftIndex] < arr[rightIndex] {
                    total += arr[leftIndex] * (right - rightIndex + 1)
                    tempArr.append(arr[leftIndex])
                    leftIndex += 1
                } else {
                    tempArr.push(arr[rightIndex]);
                    rightIndex += 1
                }
         }
            
    while leftIndex <= mid {
                    tempArr.push(arr[leftIndex])
                    leftIndex += 1
                }
                while rightIndex <= right {
                    tempArr.push(arr[rightIndex])
                    rightIndex += 1
                }
                for (index,element) in tempArr.enumerated() {
                    arr[left + index] = element
                }
                return total
    
}

function quickSort(arr,start,end){
    if(start >= end-1){
        return
    }
    let pateBase = arr[start]
    let less,more = partition(arr, partBase, start, end)
    quickSort(arr,start,less+1)
    quickSort(arr,more,end)
}

function partition(arr,partBase,start,end){
    let less = start -1
    let more = end
    let current = start
    while(current < more){
        if(arr[current] > partBase){
            more--;
            arr.swap(arr[current],arr[more])     
        }else if(arr[current] == partBase){
            current++
        }else{
            arr.swap(less++,current++)
        }
    }
    return less,more
}