JavaSE学习（六）：随机数—简单的排序算法

 

第一节：随机数

1.1 Math.random()函数

　　Math.random随机生成0~1间的随机点数，前包括（0.00）后不包括（1）

一般没有实际意义,需要转为整数。

例程：生成30-50随机数

int t = Math.random*20+30;

1.2 Random类：

语法：Random r = new Random();

常用的方法:

nextInt();//随机生成int类型取值范围内的整数，对我们来说意义不大。

nextInt(参数);随机生成指定范围内的整数（常用）

例: nextInt(100);随机生成0~100之间的整数

练习:

结合数组和随机数完成双色球生成

需求: 红球 1~33(包含) 号码中随机生成6个不重复的号码添加到球的数组中去蓝球 1~16(包含)号码中随机生成1个号码，扩容到红球数组中去

分析:  球的数组 int[] bool=new int[6]

第一个球: 随机生成一个号添加到数组中去后面生成的每一个球，都需要和前面每个球进行比较，只有不重复的情况下才能添加到数组中去，如果重复，舍弃，重新生成再比较，直到6个球全部添加到数组中去时完成红球功能。蓝球通过扩容添加到bool数组中去即可;

例程：DoubleColerBall.java

package random;

import java.util.Arrays;
import java.util.Random;

public class DoubleColerball {
    
    public static void main(String[] args) {
        
        Random r = new Random();
        
        int[] redBall =new int[6];
        int index = 0;
        
        redBall[index++] = r.nextInt(33)+1;            //生成第一个数

        loop:        while(true) {
            
            int x = r.nextInt(33)+1;
            
            //判断生成的x,是否在数组中
            for (int j=0;  j<index;  j++) {
                //如果x在数组里面则跳出循环到loop处重新生成x,再判断，直到x不是之前数组内的数
                if(redBall[j] == x) {                                 
                     //到loop处循环
                    continue loop;                                  
                    
                }
                
            }        //while
            //将x填入数组，递加index
            redBall[index++] = x;                             
            
            if (index==6) {
            
                break;                
            }
            
        }   //while    
    
        System.out.println("红球生成的数为"+Arrays.toString(redBall));
        
        int blue = r.nextInt(16)+1;
        
        System.out.println("蓝球生成的数为"+blue);

        int[] ball = Arrays.copyOf(redBall, redBall.length+1);
        
        ball[ball.length-1] = blue;
        
        System.out.println("最终生成的数为"+Arrays.toString(ball));
        
        System.out.println("最终生成的数排序为"+Arrays.toString( sort (ball) )  );

        
    }
    
}

第二节 几种排序算法

2.1 冒泡排序算法

2.1.1原理实现

将数列从小向大排序（或从大向小），将每个位置数与下个位置数比较若比后面的数大则交换位置，一轮下来能得到一个最大数，第二轮得到第二大的数......

2.1.2实例分析

  例: [6,8,5,7,4]想要的最终结果是[4,5,6,7,8]

               　　　6  8  5  7  4

  第一轮第一次:  6  8  5  7  4

  第一轮第二次:  6  5  8  7  4

  第一轮第三次:  6  5  7  8  4

  第一轮第四次:  6  5  7  4  8

 

  第二轮第一次:  5  6  7  4  8

  第二轮第二次:  5  6  7  4  8

  第二轮第三次:  5  6  4  7  8

 

  第三轮第一次:  5  6  4  7  8

  第三轮第二次:  5  4  6  7  8

  

  第四轮第一次:  4  5  6  7  8

  规律:轮数每增加一次，比较的次数都会减少一次

　Demo2.java

 

2.2 选择排序法：

2.2.1原理实现

选择排序法:

第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换;

第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换;以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

例:

初始序列:{49 27 65 97 76 12 38}

第1趟:12与49交换:12{27 65 97 76 49 38}

第2趟:27不动 :12 27{65 97 76 49 38}

第3趟:65与38交换:12 27 38{97 76 49 65}

第4趟:97与49交换:12 27 38 49{76 97 65}

第5趟:76与65交换:12 27 38 49 65{97 76}

第6趟:97与76交换:12 27 38 49 65 76 97 完成

分析:

1.设定数组中第一个数为最小

2.将其和数组后面的每一个数进行比较，如果有比其小的交换两者位置

Demo2.java

package random;

import java.util.Arrays;
/**
 * 
 * @项目名称：JavaSEDay07m
 * @模块功能：选择排序的实现
 * @模块版本：
 * @JDKVersions：JDK 8.0
 * @author：  Kanekiyi
 */
public class Demo3 {
    
    public static void main(String [] args) {
        int[] arr={5,9,2,807,89,88};
        int temp=0;
        
        //外层循环依次假设数组中的每一个数为最小值
        for(int i=0; i<arr.length-1;i++) {
            int min = arr[i];
            int minIndex = i;
            
            for (int j=i+1; j<arr.length;j++) {        //从i的下一个开始比较
                if(min>arr[j]) {
                     min = arr[j];
                     minIndex = j;
                }
                
            }
            //交换最小值
            temp = arr[i];
            arr[i]  = arr[minIndex];
            arr[minIndex] = temp;
            
        }
        System.out.println(Arrays.toString(arr));

    }
}

2.3 插入排序法：

2.3.1原理实现

插入排序类似整理扑克牌，将每一张牌插到其他已经有序的牌中适当的位置。

插入排序由N-1趟排序组成，对于P=1到N-1趟，插入排序保证从位置0到位置P上的元素为已排序状态。

简单的说，就是插入排序总共需要排序N-1趟，从index为1开始，讲该位置上的元素与之前的元素比较，放入合适的位置，这样循环下来之后，即为有序数组。

2.3.2实例分析

Demo2.java

    //插入排序算法
    public static void insertSort() {
        int[] arr = {3,6,8,4,2,9};
        int[] arr2 = new int[arr.length];
        arr2[0] = arr[0];
        int temp=0;

        for(int i=1; i<arr.length; i++) {      //依次取出原数组插入到新数组中比较
            
            for(int j=1; j<arr.length;j++) {
                for(int k =0; k<j+1;k++) {
                    
                    if(arr[i]>arr2[k]) {            //比较插入数与原数组中的数并交换位置
                        temp = arr2[k];
                        arr2[k] = arr[i];
                        arr[i] = temp;
                    }        
                }        
            }        
            //arr2[i] = temp;
        }
        System.out.println(Arrays.toString(arr2));
    }

　　注：这种方法是个人在看完原理后在冒牌排序的基础上改的，较为繁琐，下面地址（参考一）的博客有更简单的方法。

　　参考：

　　（一）8种排序算法详解：https://www.cnblogs.com/0201zcr/p/4764427.html

　　（二）13种排序算法详解：http://www.cnblogs.com/whf-Staring/p/4801418.html

　　综合练习：利用数组和数据结构，完成学生管理系统（SMS1.0)的开发：

　　要求：1、创建学生数组，用于保存数据

　　　　　2、通过键盘输入数字选择功能，不同数字完成不同功能，要求对学生数字完成增删该查功能；

代码：SMS.java

package random;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 学生管理系统1.0版本
 * @author  Kanekiyi
 * 分析：1、while 循环
 *            2、Scannre
 *               3、if 分支
 *               4、数组 扩容 缩容 遍历
 *      String
 * */

public class SMS {
    
    public static void main(String[] args) {
        System.out.println("欢迎使用学生管理系统1.0版本");
        
        String[] students = {"刘一","孙二","张三","李四"};
        
        Scanner sc = new Scanner(System.in);
        
        while(true) {
            System.out.println("1.添加学生 2.删除学生 3.修改学生 4.学生列表 5.查询学生 6.退出");
            System.out.println("请输入数字选择功能");

            int type = sc.nextInt();
            
            //1添加学生
            if (type ==1) {
                System.out.println("请输入添加学生姓名");
                String name = sc.next();
                students = Arrays.copyOf(students,students.length+1);
                students[students.length-1] = name;
                System.out.println("添加成功");
            }
        
            //2、删除学生
            if (type ==2) {
                boolean flag = false;
                System.out.println("请输入需要删除学生的姓名");
                String name = sc.next();

                for(int i=0; i<students.length; i++) {
                    if(students[i].equals(name)) {
                        //最后一个数放在要删除的名字位置
                        students[i] = students[students.length-1];       
                        //缩减数组
                        students = Arrays.copyOf(students,students.length-1);                 
                        System.out.println("删除学生成功1");
                        flag = true;
                    }
                }
                
                if(!flag) {
                    System.out.println("查无此人！");
                }
                
            }    
            
            //3、修改学生
            if (type ==3) {
                /**
                 * equals 只是比较两个字符串字符是否相同，而不是比较两个字符串的地址值。
                 * 
                 * */
                boolean flag = false;
                System.out.println("请输入修改学生姓名");
                String name = sc.next();

                for (int i=0; i<students.length; i++) {
                    if(students[i].equals(name) ) {
                        System.out.println("请输入修改后学生姓名");
                        String resetName = sc.next();
                        flag = true;
                        students[i] = resetName;
                        System.out.println(" 修改成功！");
                    }
                    
                }
                
                if (!flag) {
                    System.out.println("查无此人！");
                }
                                
            }
            
            //4、学生列表
            if (type ==4) {
                    System.out.println(Arrays.toString(students));
            }            
            
            //5、查询学生
            if (type ==5) {
                System.out.println("请输入你要查询学生的名字");
                String name = sc.next();
                boolean flag = false;
                for(int i=0; i<students.length; i++) {
                    if(students[i].equals(name)) {
                        System.out.println(students[i]);
                    }
                    
                }
                
                if(!flag) {
                    System.out.println("查无此人！");
                }
                
            }
            
            //6、退出
            if (type ==6) {
                System.out.println("欢迎再次使用学生管理系统！"); 
                break;
            }
    
        }//while
        
    }

}