Menguruskan Data Penstriman dengan Min dan Max Heaps dalam JavaScript: Perspektif Teknologi Kesihatan Atlet Digital-tutorial js-php.cn

Managing Streaming Data with Min and Max Heaps in JavaScript: A Digital Athlete Health Tech Perspective

Pengurusan data adalah penting dalam teknologi kesihatan. Sama ada menjejak metrik prestasi atau memantau masa pemulihan untuk atlet, menyusun data dengan cekap boleh membuat perbezaan yang ketara dalam cara cerapan diperoleh. Satu alat yang berkuasa untuk mengurus data dalam senario sedemikian ialah timbunan, khususnya timbunan min dan maks. Dalam siaran ini, kami akan meneroka cara untuk melaksanakan dan menggunakan timbunan min dan maks dalam JavaScript, menggunakan contoh dunia sebenar yang berkaitan dengan pengurusan data atlet.

Apakah Heaps?

Timbunan ialah struktur data berasaskan pokok binari khusus yang memenuhi sifat timbunan. Dalam timbunan min, nod induk sentiasa lebih kecil daripada atau sama dengan nod anaknya. Sebaliknya, dalam timbunan maks, nod induk sentiasa lebih besar daripada atau sama dengan nod anaknya. Ini menjadikan timbunan amat berguna untuk mendapatkan semula nilai minimum atau maksimum daripada set data dengan cekap.

Kes Penggunaan Timbunan Min: Menjejak Masa Pemulihan

Bayangkan anda seorang doktor yang menjejaki masa pemulihan atlet selepas bersenam. Anda ingin menjejaki masa pemulihan terpendek dengan cekap supaya anda boleh mengenal pasti atlet mana yang pulih paling cepat.

Mencipta Timbunan Min

Dalam JavaScript, anda boleh mencipta timbunan min menggunakan tatasusunan dan mengurusnya dengan fungsi mudah untuk mengekalkan sifat timbunan:

class MinHeap {
    constructor() {
        this.heap = [];
    }

    getMin() {
        return this.heap[0];
    }

    insert(value) {
        this.heap.push(value);
        this.bubbleUp();
    }

    bubbleUp() {
        let index = this.heap.length - 1;
        while (index > 0) {
            let parentIndex = Math.floor((index - 1) / 2);
            if (this.heap[parentIndex] <= this.heap[index]) break;
            [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
            index = parentIndex;
        }
    }

    extractMin() {
        if (this.heap.length === 1) return this.heap.pop();
        const min = this.heap[0];
        this.heap[0] = this.heap.pop();
        this.bubbleDown();
        return min;
    }

    bubbleDown() {
        let index = 0;
        const length = this.heap.length;
        const element = this.heap[0];

        while (true) {
            let leftChildIndex = 2 * index + 1;
            let rightChildIndex = 2 * index + 2;
            let leftChild, rightChild;
            let swap = null;

            if (leftChildIndex < length) {
                leftChild = this.heap[leftChildIndex];
                if (leftChild < element) swap = leftChildIndex;
            }

            if (rightChildIndex < length) {
                rightChild = this.heap[rightChildIndex];
                if (
                    (swap === null && rightChild < element) ||
                    (swap !== null && rightChild < leftChild)
                ) {
                    swap = rightChildIndex;
                }
            }

            if (swap === null) break;
            [this.heap[index], this.heap[swap]] = [this.heap[swap], this.heap[index]];
            index = swap;
        }
    }
}

Salin selepas log masuk

Menggunakan Timbunan Min untuk Masa Pemulihan Atlet

Sekarang, mari gunakan ini pada senario kami:

const recoveryTimes = new MinHeap();
recoveryTimes.insert(10); // Athlete A
recoveryTimes.insert(7);  // Athlete B
recoveryTimes.insert(12); // Athlete C

console.log("Fastest recovery time:", recoveryTimes.getMin()); // Outputs: 7

Salin selepas log masuk

Di sini, timbunan min membolehkan doktor mengenal pasti atlet dengan cepat dengan masa pemulihan terpantas, yang penting untuk membuat keputusan masa nyata semasa sesi latihan.

Kes Penggunaan Timbunan Maks: Memantau Metrik Prestasi Puncak

Sebaliknya, timbunan maks adalah sesuai untuk senario di mana anda perlu menjejaki nilai tertinggi, seperti memantau metrik prestasi puncak seperti kadar denyutan jantung maksimum yang dicapai semasa senaman yang sengit.

Mencipta Timbunan Maks

Timbunan maks boleh dilaksanakan sama seperti timbunan min, dengan beberapa pelarasan:

class MaxHeap {
    constructor() {
        this.heap = [];
    }

    getMax() {
        return this.heap[0];
    }

    insert(value) {
        this.heap.push(value);
        this.bubbleUp();
    }

    bubbleUp() {
        let index = this.heap.length - 1;
        while (index > 0) {
            let parentIndex = Math.floor((index - 1) / 2);
            if (this.heap[parentIndex] >= this.heap[index]) break;
            [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
            index = parentIndex;
        }
    }

    extractMax() {
        if (this.heap.length === 1) return this.heap.pop();
        const max = this.heap[0];
        this.heap[0] = this.heap.pop();
        this.bubbleDown();
        return max;
    }

    bubbleDown() {
        let index = 0;
        const length = this.heap.length;
        const element = this.heap[0];

        while (true) {
            let leftChildIndex = 2 * index + 1;
            let rightChildIndex = 2 * index + 2;
            let leftChild, rightChild;
            let swap = null;

            if (leftChildIndex < length) {
                leftChild = this.heap[leftChildIndex];
                if (leftChild > element) swap = leftChildIndex;
            }

            if (rightChildIndex < length) {
                rightChild = this.heap[rightChildIndex];
                if (
                    (swap === null && rightChild > element) ||
                    (swap !== null && rightChild > leftChild)
                ) {
                    swap = rightChildIndex;
                }
            }

            if (swap === null) break;
            [this.heap[index], this.heap[swap]] = [this.heap[swap], this.heap[index]];
            index = swap;
        }
    }
}

Salin selepas log masuk

Menggunakan Timbunan Maks untuk Kadar Jantung Puncak

Mari kita pertimbangkan cara timbunan maksimum boleh digunakan untuk menjejaki kadar denyutan jantung puncak atlet semasa bersenam:

const heartRates = new MaxHeap();
heartRates.insert(150); // Athlete A
heartRates.insert(165); // Athlete B
heartRates.insert(160); // Athlete C

console.log("Peak heart rate:", heartRates.getMax()); // Outputs: 165

Salin selepas log masuk

Di sini, timbunan maksimum memastikan bahawa doktor dapat mengenal pasti dengan cepat atlet yang mencapai kadar denyutan jantung tertinggi, yang mungkin memberi isyarat bahawa perhatian atau penyejukan lanjut diperlukan.

Operasi Timbunan Asas Lain

Selain memasukkan elemen dan mendapatkan semula nilai min atau maks, timbunan menyokong operasi asas lain, seperti:

Mengekstrak min/maks: Ini mengalih keluar punca timbunan (elemen terkecil dalam timbunan min atau yang terbesar dalam timbunan maks) dan mengimbangi semula timbunan.
Heapify: Menukar tatasusunan arbitrari kepada timbunan, memastikan sifat timbunan dikekalkan.
Intai: Melihat nilai min atau maksimum tanpa mengalih keluarnya daripada timbunan.

Operasi ini penting untuk mengurus dan memproses data dengan cekap dalam masa nyata, menjadikan timbunan sebagai alat yang berharga dalam aplikasi teknologi kesihatan.

Memudahkan Operasi Timbunan dalam Python dan JavaScript

Dalam Python, modul heapq menyediakan cara yang mudah dan cekap untuk mengurus timbunan min menggunakan senarai. Berikut ialah contoh:

import heapq

# Create an empty list to represent the heap
recovery_times = []

# Add elements to the heap
heapq.heappush(recovery_times, 10)  # Athlete A
heapq.heappush(recovery_times, 7)   # Athlete B
heapq.heappush(recovery_times, 12)  # Athlete C

# Retrieve the smallest element (fastest recovery time)
fastest_recovery_time = heapq.heappop(recovery_times)
print(f"Fastest recovery time: {fastest_recovery_time}")  # Outputs: 7

Salin selepas log masuk

Untuk JavaScript, walaupun tidak ada modul timbunan terbina dalam, anda boleh menggunakan perpustakaan pihak ketiga seperti @datastructures-js/priority-queue untuk mencapai fungsi yang serupa:

// First, you would need to install the @datastructures-js/priority-queue library using npm:
// npm install @datastructures-js/priority-queue

const { MinPriorityQueue } = require('@datastructures-js/priority-queue');

// Create a new min heap
const minHeap = new MinPriorityQueue();

// Add elements to the heap
minHeap.enqueue(10); // Athlete A
minHeap.enqueue(7);  // Athlete B
minHeap.enqueue(12); // Athlete C

// Retrieve the smallest element
const fastestRecoveryTime = minHeap.dequeue().element;
console.log("Fastest recovery time:", fastestRecoveryTime); // Outputs: 7

Salin selepas log masuk

Dengan memanfaatkan alatan ini, anda boleh menumpukan pada aspek kritikal aplikasi anda, seperti menganalisis data atlet, tanpa terperangkap dalam butiran pelaksanaan timbunan.

Mendapatkan semula data dengan cekap dalam JavaScript

Timbunan, terutamanya timbunan min dan maks, ialah alat yang berkuasa untuk mengurus dan mendapatkan semula data kritikal dengan cekap dalam JavaScript. Sama ada anda menjejak masa pemulihan atau memantau metrik prestasi puncak, struktur ini membantu doktor dan profesional teknologi kesihatan membuat keputusan termaklum dengan cepat. Dengan memahami dan melaksanakan timbunan, anda boleh memastikan bahawa data atlet anda teratur, boleh diakses dan sedia untuk dianalisis apabila ia paling penting.

Dengan menggunakan timbunan dalam aplikasi teknologi kesihatan anda, anda akan dapat mengendalikan data dengan cara yang menyokong hasil yang lebih baik untuk atlet, memberikan cerapan yang diperlukan untuk mengoptimumkan prestasi dan pemulihan.

Atas ialah kandungan terperinci Menguruskan Data Penstriman dengan Min dan Max Heaps dalam JavaScript: Perspektif Teknologi Kesihatan Atlet Digital. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!