การค้นหาตัวเลขที่เล็กที่สุดอันดับที่ 3 ใน Java: คู่มือฉบับสมบูรณ์

คุณเคยสงสัยบ้างไหมว่าจะหาจำนวนที่น้อยที่สุดเป็นอันดับสามในอาร์เรย์ รายการ หรือกระแสจำนวนเต็มอย่างมีประสิทธิภาพได้อย่างไร ในบล็อกโพสต์นี้ เราจะเจาะลึกเข้าไปในโลกของการเขียนโปรแกรม Java และสำรวจเทคนิคต่างๆ เพื่อระบุจำนวนที่น้อยที่สุดเป็นอันดับสามในแหล่งข้อมูลต่างๆ

เมื่อทำงานกับการจัดการและการวิเคราะห์ข้อมูล มักมีความจำเป็นในการระบุองค์ประกอบเฉพาะภายในกลุ่มตัวเลข การค้นหาจำนวนที่น้อยที่สุดหรือมากที่สุดนั้นค่อนข้างตรงไปตรงมา แต่การระบุจำนวนที่น้อยที่สุดเป็นอันดับสามนั้นต้องใช้ความเฉียบแหลมมากกว่าเล็กน้อย ในบล็อกโพสต์นี้ เราจะกล่าวถึงสามวิธีในการแก้ไขปัญหานี้โดยใช้ Java: การเรียงลำดับอาร์เรย์ การเรียงลำดับรายการ และการใช้สตรีม

วิธีที่ 1: การเรียงลำดับอาร์เรย์

อาร์เรย์เป็นหนึ่งในโครงสร้างข้อมูลพื้นฐานใน Java ทำให้เป็นจุดเริ่มต้นตามธรรมชาติสำหรับการสำรวจของเรา แนวคิดนี้คือการเรียงลำดับอาร์เรย์จากน้อยไปหามาก จากนั้นดึงข้อมูลองค์ประกอบที่ดัชนี 2

วิธีที่ 2: การเรียงลำดับรายการ

รายการเป็นทางเลือกที่ยืดหยุ่นกว่าสำหรับอาร์เรย์ ช่วยให้สามารถปรับขนาดแบบไดนามิกและจัดการได้ง่ายขึ้น หากต้องการค้นหาจำนวนที่น้อยที่สุดเป็นอันดับสามในรายการ เราสามารถใช้วิธีการจัดเรียงอาร์เรย์ที่คล้ายกันได้

วิธีที่ 3: การใช้สตรีม

สตรีม Java เป็นวิธีที่มีประสิทธิภาพในการประมวลผลลำดับขององค์ประกอบ เราสามารถใช้สตรีมเพื่อจัดเรียงองค์ประกอบแล้วดึงตัวเลขที่เล็กที่สุดเป็นอันดับสาม

การเลือกวิธีการที่เหมาะสม

แต่ละวิธีมีข้อดีและกรณีการใช้งานของตัวเอง หากคุณมีอาร์เรย์อยู่แล้ว วิธีการเรียงลำดับอาร์เรย์อาจมีประสิทธิภาพมากที่สุด รายการมีความหลากหลายและให้ความสะดวกมากขึ้น ในขณะที่สตรีมให้แนวทางการทำงานและสามารถจัดการชุดข้อมูลขนาดใหญ่ได้อย่างง่ายดาย

นี่คือตัวอย่างที่สมบูรณ์:

CrunchyThirdSmallestNumberFinder.java

 แพ็คเกจ crunchify.com.tutorial;

นำเข้า java.util.Arrays;
นำเข้า java.util.List;
นำเข้า java.util.stream.Collectors;
นำเข้า java.util.stream.Stream;

/**
 * @ผู้เขียน Crunchify.com
 * การค้นหาตัวเลขที่เล็กที่สุดอันดับที่ 3 ใน Java: คู่มือฉบับสมบูรณ์
 *
 */

คลาสสาธารณะ CrunchyThirdSmallestNumberFinder {

    // วิธีการค้นหาตัวเลขที่เล็กที่สุดเป็นอันดับสามในอาร์เรย์
    int สาธารณะคงที่ findCrunchyThirdSmallest (int [] crunchArr) {
        ถ้า (crunchArr.length < 3) {
            โยน IllegalArgumentException ใหม่ ("อาร์เรย์ควรมีองค์ประกอบกระทืบอย่างน้อย 3 องค์ประกอบ");
        }

        // จัดเรียงอาร์เรย์แบบกรุบกรอบจากน้อยไปหามาก
        อาร์เรย์.sort(crunchArr);
        กลับ crunchArr [2]; // คืนองค์ประกอบกรุบกรอบที่เล็กที่สุดเป็นอันดับสาม
    }

    // วิธีการหาตัวเลขที่น้อยที่สุดเป็นอันดับสามในรายการ
    int สาธารณะคงที่ findCrunchyThirdSmallest (รายการ <จำนวนเต็ม> crunchList) {
        ถ้า (crunchList.size() < 3) {
            โยน IllegalArgumentException ใหม่ ("รายการควรมีองค์ประกอบกระทืบอย่างน้อย 3 รายการ");
        }

        // จัดเรียงรายการแบบกรุบกรอบโดยใช้สตรีมและรวบรวมองค์ประกอบที่เรียงลำดับไว้ในรายการใหม่
        รายการ <จำนวนเต็ม> sortedCrunchList = crunchList.stream()
                .เรียงลำดับ()
                .collect(Collectors.toList());

        กลับ sortedCrunchList.get (2); // คืนองค์ประกอบกรุบกรอบที่เล็กที่สุดเป็นอันดับสาม
    }

    // วิธีการหาตัวเลขที่เล็กที่สุดเป็นอันดับสามที่กรุบกรอบในสตรีม
    int สาธารณะคงที่ findCrunchyThirdSmallest (กระแส <จำนวนเต็ม> crunchStream) {
        // รวบรวมองค์ประกอบจากสตรีมกรุบกรอบ จัดเรียงและรวบรวมเป็นรายการ
        รายการ <จำนวนเต็ม> sortedCrunchList = crunchStream.sorted().collect(Collectors.toList());

        ถ้า (sortedCrunchList.size() < 3) {
            โยน IllegalArgumentException ใหม่ ("สตรีมควรมีองค์ประกอบกระทืบอย่างน้อย 3 องค์ประกอบ");
        }

        กลับ sortedCrunchList.get (2); // คืนองค์ประกอบกรุบกรอบที่เล็กที่สุดเป็นอันดับสาม
    }

    โมฆะคงที่สาธารณะ main (String [] args) {
        int[] crunchArr = {35, 62, 28, 31, 13, 97};
        รายการ<จำนวนเต็ม> crunchList = Arrays.asList(9, 14, 676, 62, 11, 328);
        สตรีม <จำนวนเต็ม> crunchStream = Stream.of (427, 53, 71, 99, 25, 62);

        // ค้นหาตัวเลขที่เล็กที่สุดเป็นอันดับสามแบบกรุบกรอบโดยใช้แหล่งต่างๆ
        int crunchyThirdSmallestFromArr = ค้นหา CrunchyThirdSmallest (crunchArr);
        int crunchyThirdSmallestFromList = findCrunchyThirdSmallest (crunchList);
        int crunchyThirdSmallestFromStream = findCrunchyThirdSmallest (crunchStream);

        // พิมพ์ตัวเลขที่เล็กที่สุดเป็นอันดับสามกรุบกรอบ
        System.out.println("กรุบกรอบที่เล็กที่สุดเป็นอันดับสามจาก arr: " + crunchyThirdSmallestFromArr);
        System.out.println("กรุบกรอบที่เล็กที่สุดเป็นอันดับสามจากรายการ: " + crunchyThirdSmallestFromList);
        System.out.println("Crunchy Third SmallestFromStream: " + crunchyThirdSmallestFromStream);
    }
}

ผลลัพธ์คอนโซล Eclipse:

เพียงรันโปรแกรมด้านบนใน Eclipse IDE หรือ IntelliJ IDEA แล้วคุณจะได้ผลลัพธ์ดังนี้

 กรุบกรอบเล็กเป็นอันดับสามจาก arr: 31
กรุบกรอบที่เล็กที่สุดเป็นอันดับสามจากรายการ: 14
กรุบกรอบเล็กที่สุดเป็นอันดับสามจากสตรีม: 62

กระบวนการเสร็จสิ้นด้วยรหัสทางออก 0

มีความแตกต่างด้านประสิทธิภาพที่ควรพิจารณา:

ในแง่ของความซับซ้อนของเวลา ทั้งสามวิธีมีขั้นตอนการเรียงลำดับที่คล้ายกัน ซึ่งโดยทั่วไปจะมีความซับซ้อนของเวลาเป็น O(n log n) โดยที่ 'n' คือจำนวนองค์ประกอบในคอลเลกชัน (อาร์เรย์ รายการ หรือสตรีม)

ความซับซ้อนของเวลาในการเข้าถึงองค์ประกอบที่เล็กที่สุดอันดับที่สามนั้นคงที่ O(1) เนื่องจากเป็นการค้นหาอาร์เรย์หรือรายการอย่างง่าย

1. วิธีอาร์เรย์: วิธีการนี้จะเรียงลำดับอาร์เรย์ให้เข้าที่ ดังนั้นจึงไม่จำเป็นต้องใช้หน่วยความจำเพิ่มเติมสำหรับคอลเลกชันที่เรียงลำดับใหม่ ซึ่งอาจนำไปสู่การใช้หน่วยความจำที่ดีขึ้นเล็กน้อยเมื่อเปรียบเทียบกับรายการและวิธีการสตรีม
2. วิธีการรายการ: วิธีการนี้จะแปลงรายการเป็นรายการที่เรียงลำดับโดยใช้สตรีม แม้ว่าสะดวก แต่ก็เกี่ยวข้องกับการสร้างรายการใหม่ซึ่งใช้หน่วยความจำเพิ่มเติม นี่อาจเป็นข้อกังวลหากการใช้หน่วยความจำมีความสำคัญ
3. วิธีการสตรีม: วิธีการสตรีมค่อนข้างยืดหยุ่นและใช้งานได้ แต่เกี่ยวข้องกับการรวบรวมสตรีมลงในรายการ สิ่งนี้จะเพิ่มค่าใช้จ่ายเล็กน้อยในแง่ของหน่วยความจำและการประมวลผล เมื่อเปรียบเทียบกับการเรียงลำดับอาเรย์โดยตรง

แจ้งให้เราทราบหากคุณประสบปัญหาในการใช้รหัสนี้