Sorting Algorithm(1)

  为了加强自己的计算机思维和编程功底,会尝试使用底层语言来实现一下传统算法,目的加强基本功的同时督促自己坚持学习。

  • 插入排序
      插入排序的基本思想是:每步将一个待排序的记录,按其关键码值的大小插入前面已经排序的文件中适当位置上,直到全部插入完为止。
# include<iostream>
// 定义输入函数
template<typename type> void inputnumber(type *a, int length)
{
  type input;
  std::cout << "please enter numbers:" << std::endl;
  for (int i = 0;i<length;i++)
  { 
     std::cin >> input;
     a[i] = input;
  }

}
// 定义输出函数
template<typename type> void printnumber(type *a, int length)
{
   for (int i = 0;i<length;i++)
       std::cout << a[i] << " ";
   std::cout << std::endl;
}
// 插入排序函数
template<typename type> void insertsort(type *a, int length)
{
    int i, j;
    type v;
    for (i=1;i<length;i++)
    {
       v = a[i];
       j = i - 1;
       while ((j >=0) && (a[j]> v))
      {
        a[j+1] = a[j];
        j--;   
      }
      a[j+1] = v;
    }
    printnumber(a, length);   
}
// 运行函数
template<typename type> void run(type *a, int length)
{
    inputnumber(a, length);
    std::cout << "show original array:" << std::endl;
    printnumber(a, length);
    std::cout << "show sorted array:" << std::endl;
    insertsort(a, length);
}
// 主函数
int main()
{
    int length = 10;
    int a[10];
    float b[10];
    double c[10];
    // 输入整型数组
    run(a, length);
    // 输入浮点型数组
    run(b, length);
    // 输入双精度型数组
    run(c, length);
    return 0;
}

  运行结果:

  • 整型
    这里写图片描述

  • 浮点型
    这里写图片描述

  • 双精度型
    这里写图片描述
Sure, I understand your question. You want me to develop a NetBeans application that demonstrates the use of one sorting algorithm on a collection of 10 items, sorting them in descending order. The algorithm should be based on one of the four sorting algorithms studied during the semester and should be implemented as part of a class called MyArrayList that extends the ArrayList class functionality with your sorting algorithm. Additionally, you want me to extend the application to measure the efficiency of the implemented sorting algorithm in terms of the number of comparisons performed by the algorithm, and to plot the number of comparisons measured by the sorting algorithm when three different sizes of collection are considered in an Excel graph. To start, let's define and populate the collection of 10 items in the NetBeans application code. We can use integers for the items stored in the collection. Here's an example of how the collection can be defined and populated: ``` import java.util.ArrayList; public class SortingDemo { public static void main(String[] args) { MyArrayList<Integer> list = new MyArrayList<Integer>(); list.add(5); list.add(2); list.add(10); list.add(8); list.add(1); list.add(7); list.add(9); list.add(3); list.add(4); list.add(6); System.out.println("Original list: " + list); list.sortDescending(); System.out.println("Sorted list: " + list); } } class MyArrayList<E extends Comparable<E>> extends ArrayList<E> { public void sortDescending() { // Insertion sort algorithm for (int i = 1; i < size(); i++) { E key = get(i); int j = i - 1; while (j >= 0 && get(j).compareTo(key) < 0) { set(j + 1, get(j)); j--; } set(j + 1, key); } } } ``` In the above code, we define a class called SortingDemo which contains a main method. Inside the main method, we create an instance of MyArrayList and add 10 integers to it. We then print out the original list and call the sortDescending method on the list to sort it in descending order. Finally, we print out the sorted list. The MyArrayList class extends the ArrayList class and defines a sortDescending method that implements the insertion sort algorithm to sort the list in descending order. Next, we need to extend the application to measure the efficiency of the sorting algorithm in terms of the number of comparisons performed by the algorithm. We can modify the MyArrayList class to keep track of the number of comparisons performed during the sorting process, like this: ``` class MyArrayList<E extends Comparable<E>> extends ArrayList<E> { private int comparisons; public void sortDescending() { comparisons = 0; // Insertion sort algorithm for (int i = 1; i < size(); i++) { E key = get(i); int j = i - 1; while (j >= 0 && get(j).compareTo(key) < 0) { set(j + 1, get(j)); j--; comparisons++; } set(j + 1, key); } } public int getComparisons() { return comparisons; } } ``` We added a private variable called comparisons to keep track of the number of comparisons performed during the sorting process. We initialize it to 0 at the start of the sortDescending method and increment it for each comparison performed. We also added a public method called getComparisons to retrieve the number of comparisons performed. Finally, we need to plot the number of comparisons measured by the sorting algorithm when three different sizes of collection are considered in an Excel graph. To do this, we can modify the SortingDemo class to create three different lists of different sizes and sort each of them, recording the number of comparisons performed for each sort. We can then export the data to an Excel file and create a graph with the data. Here's an example of the modified SortingDemo class: ``` import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Row; import org.apache.poi.xssf.usermodel.XSSFWorkbook; public class SortingDemo { public static void main(String[] args) { MyArrayList<Integer> list1 = new MyArrayList<Integer>(); list1.add(5); list1.add(2); list1.add(10); list1.add(8); list1.add(1); list1.add(7); list1.add(9); list1.add(3); list1.add(4); list1.add(6); System.out.println("Original list 1: " + list1); list1.sortDescending(); System.out.println("Sorted list 1: " + list1); int comparisons1 = list1.getComparisons(); MyArrayList<Integer> list2 = new MyArrayList<Integer>(); for (int i = 0; i < 100; i++) { list2.add((int) (Math.random() * 100)); } System.out.println("Original list 2: " + list2); list2.sortDescending(); System.out.println("Sorted list 2: " + list2); int comparisons2 = list2.getComparisons(); MyArrayList<Integer> list3 = new MyArrayList<Integer>(); for (int i = 0; i < 1000; i++) { list3.add((int) (Math.random() * 100)); } System.out.println("Original list 3: " + list3); list3.sortDescending(); System.out.println("Sorted list 3: " + list3); int comparisons3 = list3.getComparisons(); System.out.println("Comparisons 1: " + comparisons1); System.out.println("Comparisons 2: " + comparisons2); System.out.println("Comparisons 3: " + comparisons3); try (XSSFWorkbook workbook = new XSSFWorkbook()) { FileOutputStream out = new FileOutputStream(new File("sorting.xlsx")); org.apache.poi.ss.usermodel.Sheet sheet = workbook.createSheet("Sorting"); Row headerRow = sheet.createRow(0); Cell cell0 = headerRow.createCell(0); cell0.setCellValue("Collection Size"); Cell cell1 = headerRow.createCell(1); cell1.setCellValue("Comparisons"); Row row1 = sheet.createRow(1); Cell cell10 = row1.createCell(0); cell10.setCellValue("10"); Cell cell11 = row1.createCell(1); cell11.setCellValue(comparisons1); Row row2 = sheet.createRow(2); Cell cell20 = row2.createCell(0); cell20.setCellValue("100"); Cell cell21 = row2.createCell(1); cell21.setCellValue(comparisons2); Row row3 = sheet.createRow(3); Cell cell30 = row3.createCell(0); cell30.setCellValue("1000"); Cell cell31 = row3.createCell(1); cell31.setCellValue(comparisons3); workbook.write(out); out.close(); System.out.println("Excel file written successfully."); } catch (IOException e) { e.printStackTrace(); } } } ``` In the above code, we create three different lists of sizes 10, 100, and 1000, and sort each of them using the MyArrayList class. We record the number of comparisons performed for each sort and print them to the console. We then create an Excel file and write the data to it, creating a graph with the data. To create the graph in Excel, open the sorting.xlsx file and select the data in cells A1:B3. Click on the Insert tab and select the type of graph you want to create. You can then customize the graph as needed.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值