过三关 Java冒泡排序选择排序插入排序小练习

材料:猴子排序,按照身高来从小到大来排序。

第一关:

老猴子带领小猴子队伍按大小逐一比较,交换,开始高矮排列队伍。(冒泡排序)

第二关:

太慢了,给第一关增加难度,进行选择排序

第三关:

最后,尝试选择用插入排序法,来进行排序。

测试类:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

//功能:猴子排序
public class MonkeySelect {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 定义一个可以装5只猴子的对象数组
        int size = 5;
        Monkey[] monkeys = new Monkey[size];

        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        // 初始化各个猴子
        for (int i = 0; i < monkeys.length; i++) {
            System.out.println("请输入第" + (i + 1) + "只猴子的高度");

            try {
                String height = br.readLine();
                monkeys[i] = new Monkey((i + 1) + "", Float.parseFloat(height));
            } catch (NumberFormatException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        // 让老猴子排序
        Monkey oldMonkey = new Monkey("1000", 1.2f);
        // 冒泡排序
        oldMonkey.bubbleSort(monkeys);

        // oldMonkey.selectSort(monkeys);选择排序调用
        // oldMonkey.insertSort(monkeys);插入排序调用

        // 验证
        oldMonkey.show(monkeys);
    }
}

猴子类(功能):

// 猴子
class Monkey {
    private String monkeyId;
    private float height;

    public Monkey(String monkeyId, float height) {
        this.monkeyId = monkeyId;
        this.height = height;
    }

    // 插入排序
    public void insertSort(Monkey[] monkeys) {
        // 开始排序
        for (int i = 0; i < monkeys.length; i++) {
            // 先记录该猴子的身高
            float insertHeight = monkeys[i].height;
            String insertNo = monkeys[i].monkeyId;
            int insertIndex = i - 1;

            while (insertIndex >= 0
                    && monkeys[insertIndex].height > insertHeight) {
                monkeys[insertIndex + 1].height = monkeys[insertIndex].height;
                monkeys[insertIndex + 1].monkeyId = monkeys[insertIndex].monkeyId;
                insertIndex--;
            }
            // 插入
            monkeys[insertIndex + 1].height = insertHeight;
            monkeys[insertIndex + 1].monkeyId = insertNo;
        }
    }

    // 选择排序
    public void selectSort(Monkey[] monkeys) {
        float tempHeight = 0.0f;
        String tempNo = "";
        for (int i = 0; i < monkeys.length; i++) {

            float minHeight = monkeys[i].height;
            int minIndex = i;

            // 和后面的比较
            for (int j = i + 1; j < monkeys.length; j++) {
                if (minHeight > monkeys[j].height) {
                    // 修正一下最小值
                    minHeight = monkeys[j].height;
                    // 修正下标
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                // 交换
                tempHeight = monkeys[minIndex].height;
                monkeys[minIndex].height = monkeys[i].height;
                monkeys[i].height = tempHeight;

                tempNo = monkeys[minIndex].monkeyId;
                monkeys[minIndex].monkeyId = monkeys[i].monkeyId;
                monkeys[i].monkeyId = tempNo;
            }
        }
    }

    // 冒泡排队
    public void bubbleSort(Monkey[] monkeys) {
        float tempHeight = 0.0f;
        String tempNo = "";

        // 冒泡
        for (int i = 0; i < monkeys.length - 1; i++) {
            for (int j = 0; j < monkeys.length - 1 - i; j++) {
                // 判断
                if (monkeys[j].height > monkeys[j + 1].height) {
                    // 身高
                    tempHeight = monkeys[j].height;
                    monkeys[j].height = monkeys[j + 1].height;
                    monkeys[j + 1].height = tempHeight;
                    // 编号
                    tempNo = monkeys[j].monkeyId;
                    monkeys[j].monkeyId = monkeys[j + 1].monkeyId;
                    monkeys[j + 1].monkeyId = tempNo;

                }
            }
        }

    }

    // 显示队列
    public void show(Monkey[] monkeys) {
        for (int i = 0; i < monkeys.length; i++) {
            System.out.println("猴子编号:" + monkeys[i].monkeyId + " 身高:"
                    + monkeys[i].height);
        }
    }
}

原文地址:https://www.cnblogs.com/1693977889zz/p/8447319.html

时间: 2024-08-11 09:42:17

过三关 Java冒泡排序选择排序插入排序小练习的相关文章

冒泡排序 选择排序 插入排序 java

双向冒泡 1 package com.huang; 2 3 public class _014_bubb_sort { 4 5 int[] b={1,2}; 6 static int a[]={12,4,35,65,43,63,2,6,9,544,43543}; 7 public static void main(String[] args) { 8 display(); 9 10 //冒泡 11 for(int i=0;i<a.length/2;i++) 12 { 13 for(int j=0

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

简单排序算法 冒泡排序 选择排序 插入排序

冒泡排序: 总体思路:对未排序的各个元素,依次比较两个元素,如果这两个元素为逆序(与想要的顺序相反),则交换这两个元素. 这样可以有两种排序的思路: 思路一: 固定位置排序:比如有一个未排序队列,下标依次为0,1,2,.....N-1, 第一轮排序:首先固定位置0,将下标为0的元素依次和下标为1.下标为2.....下标为N-1的元素相比较,若相比较的两个元素为逆序,则交换这两个元素,这样第一轮排序完之后,位置为0的元素,就是最大的(最小的). 第二轮排序:首先固定位置1,将下标为1的元素依次和下

算法_基本排序算法之冒泡排序,选择排序,插入排序和希尔排序

排序的元素实现了Comparable接口,以达到对于通用性. 最基础的排序是冒泡排序,下面是其思路: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 下面是其实现代码: public class Maopao { public void sort(Comparable[]

基本排序算法(冒泡排序 选择排序 插入排序 快速排序 归并排序 基数排序 希尔排序)

冒泡排序 public static void bubbleSort(int[] arr){ int lgn = arr.length; for (int i = 0; i < lgn - 1; i++) { for (int j = 0; j < lgn - 1 - i; j++) { if(arr[j] > arr[j + 1]){ int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; } } } } 选择排序 publ

冒泡排序/选择排序/插入排序(c#)

---恢复内容开始--- 每次看这些排序都像没见过一样,完全理解不了,可是不久前明明了解的十分透彻.记下来记下来记下来! 1>>>冒泡排序:相邻的两两相比 把大的(或者小的)放后边,这样一轮下来,最下边的肯定是最大的数(或者最小的数).重复arr.length次就能把arr按有序排列了. class Program { static void Main(string[] args) { int[] arr = new int[] { 22, 11, 2, 9, 6 }; MP(arr);

C++中的冒泡排序,选择排序,插入排序

最简单的插入排序:思想,两两之间比较,时间复杂度o(n^2) void bubblesort(vector<int>&vec, int n) { if (&vec==NULL) return; int temp; bool flag; for (int i = 0; i < n - 1; i++)//外层循环控制循环次数 { flag = false;//判断是否有序的标志 for (int j = 0; j < n - 1 - i; j++)//内层循环控制边界

C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序

以下列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序,然后是測试的样例.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

下面列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序,然后是测试的例子.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <