📊 排序算法

import numpy as np

class NeuralSort:
    def __init__(self):
        self.learned_patterns = {}

    def analyze_pattern(self, arr):
        n = len(arr)
        if n <= 1:
            return {'is_nearly_sorted': True, 'sortedness': 1.0}

        sorted_count = sum(1 for i in range(1, n) if arr[i] >= arr[i-1])
        reverse_count = sum(1 for i in range(1, n) if arr[i] <= arr[i-1])

        return {
            'is_nearly_sorted': sorted_count >= n * 0.8,
            'is_nearly_reverse': reverse_count >= n * 0.8,
            'sortedness': sorted_count / (n - 1)
        }

    def smart_sort(self, arr):
        pattern = self.analyze_pattern(arr)

        if pattern['is_nearly_sorted']:
            return self._insertion_sort(arr)

        if pattern['sortedness'] > 0.5:
            return self._bubble_sort_optimized(arr)

        return self._quick_sort(arr)

    def _insertion_sort(self, arr):
        result = arr.copy()
        for i in range(1, len(result)):
            key = result[i]
            j = i - 1
            while j >= 0 and result[j] > key:
                result[j + 1] = result[j]
                j -= 1
            result[j + 1] = key
        return result

    def _bubble_sort_optimized(self, arr):
        result = arr.copy()
        while True:
            swapped = False
            for i in range(len(result) - 1):
                if result[i] > result[i + 1]:
                    result[i], result[i + 1] = result[i + 1], result[i]
                    swapped = True
            if not swapped:
                break
        return result

    def _quick_sort(self, arr):
        if len(arr) <= 1:
            return arr
        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 self._quick_sort(left) + middle + self._quick_sort(right)

# 测试
ns = NeuralSort()
print(ns.smart_sort([1, 2, 3, 5, 4, 6, 7]))  # 近乎有序
print(ns.smart_sort([64, 34, 25, 12, 22, 11, 90]))  # 随机

package main

import "fmt"

type NeuralSort struct {
    learnedPatterns map[string]interface{}
}

func NewNeuralSort() *NeuralSort {
    return &NeuralSort{
        learnedPatterns: make(map[string]interface{}),
    }
}

type Pattern struct {
    IsNearlySorted  bool
    IsNearlyReverse bool
    Sortedness      float64
}

func (ns *NeuralSort) AnalyzePattern(arr []int) Pattern {
    n := len(arr)
    if n <= 1 {
        return Pattern{IsNearlySorted: true, Sortedness: 1.0}
    }

    sortedCount := 0
    reverseCount := 0
    for i := 1; i < n; i++ {
        if arr[i] >= arr[i-1] {
            sortedCount++
        }
        if arr[i] <= arr[i-1] {
            reverseCount++
        }
    }

    return Pattern{
        IsNearlySorted:  float64(sortedCount) >= float64(n)*0.8,
        IsNearlyReverse: float64(reverseCount) >= float64(n)*0.8,
        Sortedness:      float64(sortedCount) / float64(n-1),
    }
}

func (ns *NeuralSort) SmartSort(arr []int) []int {
    pattern := ns.AnalyzePattern(arr)

    if pattern.IsNearlySorted {
        return ns.insertionSort(arr)
    }

    if pattern.Sortedness > 0.5 {
        return ns.bubbleSortOptimized(arr)
    }

    return ns.quickSort(arr)
}

func (ns *NeuralSort) insertionSort(arr []int) []int {
    result := make([]int, len(arr))
    copy(result, arr)
    for i := 1; i < len(result); i++ {
        key := result[i]
        j := i - 1
        for j >= 0 && result[j] > key {
            result[j+1] = result[j]
            j--
        }
        result[j+1] = key
    }
    return result
}

func (ns *NeuralSort) bubbleSortOptimized(arr []int) []int {
    result := make([]int, len(arr))
    copy(result, arr)
    for {
        swapped := false
        for i := 0; i < len(result)-1; i++ {
            if result[i] > result[i+1] {
                result[i], result[i+1] = result[i+1], result[i]
                swapped = true
            }
        }
        if !swapped {
            break
        }
    }
    return result
}

func (ns *NeuralSort) quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }
    pivot := arr[len(arr)/2]
    var left, middle, right []int
    for _, x := range arr {
        if x < pivot {
            left = append(left, x)
        } else if x == pivot {
            middle = append(middle, x)
        } else {
            right = append(right, x)
        }
    }
    left = ns.quickSort(left)
    right = ns.quickSort(right)
    return append(append(left, middle...), right...)
}

func main() {
    ns := NewNeuralSort()
    fmt.Println(ns.SmartSort([]int{1, 2, 3, 5, 4, 6, 7}))
    fmt.Println(ns.SmartSort([]int{64, 34, 25, 12, 22, 11, 90}))
}