2022年7月15日，第四组，周鹏，JAVA认识的第三天，算法的第一天(╥╯^╰╥)(╥╯^╰╥)

算了，已经没有力气去创作些什么了，

 

8种排序方法我只会4种，剩下的以后再补。

 

发一个逻辑题吧：

一个村落，有50户人，在这些人中存在着n个红眼病。

在保证每人每天最少见一面的情况下，有如下规则：

1，村里没有镜子，也就是说看不到自己的眼睛

2，红眼病不是传播病，也就是说的病人数固定

3，所有人不得有任何形式的交流

4，在得知了自己是红眼病后得在当天晚上自杀

5，第一天，第二天没人自杀，第三天有人自杀了

请问村里一共有多少红眼病人？

 

 

JAVA初始的第三天

 

数据结构

1，数组

最基本的数据结构；是一张表，线性表（数据元素之间是一对一的，除了第一个和最后一个之外，其余元素都是首尾连接，所以数组有顺序）

2，链表

3，树

3，图

 

 

 

算法：

1，线性查找：

简单方便，但不适合数量大的数据。

2，二分查找：

必须要排序。

 

 

 

 

3，排序算法：

1.冒泡排序

 

/*
思路分析：
    1，我先拿第一个数和后面的数一一比较大小,如果比这个数小就换位，经过一轮比较之后，最大的数就会在最后
    2，经过数组长度减一次的比较，就会排序完成
    3，外层循环：表示排几轮
    4，里层循环：实现数和数之间的比较
    
*/
int []a = {1,58,46,33,10,5,-8,9,16,78,99,-45,48,33};
int i = 0;
int j = 1;
int m;
​
    for (i=0;i<(a.length-1);i++){
        for (j=1;j<a.length;j++){
            if (a[j-1]<a[j]) {
                m=a[j];
                a[j]=a[j-1];
                a[j-1]=m;
            }
​
            }
        }
​
    for(int b : a){
        System.out.print(b + ",");
​
​
}
​
​
​
​
​
简易算法：
直接调用方法Arrays.sort（数组）

 

2，快速排序

思路：选一个基点，把比基点小的都放在左边，把比基点大的都放在右边（不是基点的左右边！），这样就分成了两个区域，基点就是这两个区域的中间值，再将基点放到中间，

然后选择新建一个基点，以这个基点重复上面的步骤，

不断的新建基点，直到排序完成！

 

int[] a = {1, 58, 46, 33, 10, 5, -8, 9, 16, 78, 99, -45, 48, 33};
int m ;
int q;
for(int i=0;i<(a.length-1);i++){//取此时作为基点的数组值，为后面进行判断
    q=a[i];//保存此时a[i]的值
    int n=0;//用来记录下面循环成功次数，也就是有多少个比a[i]大的数
    for (int j =(i+1);j<a.length;j++){//开始循环
​
            if(a[i]>a[j]){//判断是否有数小于此时的q
                m=a[j];//如果有，让这个数和q前面的数依次交换，注，已交换的数不再交换！！
                a[j]=a[(i+1)+n];
                a[(i+1)+n]=m;//最关键的一步！
                n++;//记录比q大的数的个数
            }
    }
    int x = 0;
    x=a[i];
    a[i]=a[i+n];
    a[i+n]=x;//让a[i]和比他大的最后一个数进行交换，
    if (a[i]!=q){
        i--;
    }//这个if的作用就是判断一次，万一交换的最后一个数，比(第一个比q大的数)要大，那么就会出现问题！
}

3，插入排序

 

4，选择排序

 

​
/**
思路分析
 *第一轮，i等于-。m=0,里层for循环，int j=1; j <a.lenth;
 * if(arr[0])>arr[1]{}.由于if不满足，则继续下一次的比较。
 * j=2 ,if(arr[0]>arr[2]){}.由于if不满足，则继续下一次比较。
 * j= 3,if(arr[0]>arr[3]){}.由于if不满足，则继续下一次比较。
 * j= 4,if(arr[0]>arr[4]){}.由于if不满足，则继续下一次比较。
 * j=5 ,if(arr[0]>arr[5]){}.由于if满足条件，执行了交换操作 ，m=5。
 * j=6 ,if(arr[5]>arr[6]){}.由于if不满足，则继续下一次比较。
 * j=7 ,if(arr[5]>arr[7]){}.由于if不满足，则继续下一次比较。
 * 到此为止，里层for循序执行完毕。m = 5  。执行的
 * int n = a[5];
 * a[5] = a[0];
 * a[0] = n;
 * i = 0 的这次外层循环执行完毕，数组最小的数就在第一位了。
 * 第二轮继续
 * 以此类推到第七轮，排序完毕
 */
​
int[] a = {1, 58, 46, 33, 10, 5, -8, 9, 16, 78, 99, -45, 48, 33};
int i;
int j;
int n;
for (i = 0; i < a.length ; i++) {
    int m =i;
​
    for (j =i+ 1; j < a.length; j++) {
        if (a[m] > a[j]) {
            m = j;
            }
        }
    n = a[m];
    a[m]=a[i];
    a[i]=n;
    }
for (int b : a) {
    System.out.print(  b + ",");
}

5，希尔排序

6，堆排位

7，归并排序

8，桶排序

 

 

 

数组反转；

 

int[] a = {1, 58, 46, 33, 10, 5, -8, 9, 16, 78, 99, -45, 48, 33};
int[]b = new int[a.length];
for (int i=(a.length-1);i>=0;i--){
    for (int j =0 ; j<a.length;j++){
       if((i+j)==(a.length-1)) {
           b[j] = a[i];
       }
    }
}

数组的扩容：

    int []arr=new int[]{3,4,6   };
  int [] temp=new int[6];//定义一个临时的数组
   for (int i = 0; i < arr.length; i++) {
      temp[i]=arr[i];
    }
    arr=temp;
    for (int i : arr) {
      System.out.println(i);
    }
​
​