2022-07-15 第五小组修身课学习笔记（every day）-CSDN博客

冒泡排序的原理：
每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。

而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。

        int temp=0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]<arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+"\t");
        }

二分查找

二分查找思路分析

1、首先确定该数组的中间下标

mid=(left+right)/2

2、然后让需要查找的findVal和mid做比较

2.1 findVal>mid ，说明你要查找的数在mid的右边，因此需要递归向右查找

2.2 findVal<mid ，说明你要查找的数在mid的左边，因此需要递归向左查找

2.3 findVal=mid，说明找到，就返回

什么时候结束

1.找到就结束递归

2.递归完整个数组，仍然没有找到findVal,也需要结束递归当left>right就需要导出

        //这个数组必须有顺序
         int[] arr= new int[]{1,2,3,5,7,56,345};
        System.out.println(binarySearch(arr, 0, (arr.length-1), 3));
    }
    public static int binarySearch(int[] arr,int left,int right,int fandVal){

        if(left>right){
            return -1;
        }
        int mid=(left+right)/2;
        int midVal=arr[mid];

        if(fandVal>midVal){
            return binarySearch(arr,mid+1,right,fandVal);
        }else if (fandVal<midVal){
            return binarySearch(arr,left,mid-1,fandVal);
        }else {
            return mid;
        }

二分查找的完善

思考：当有一个有序数组是，有多个相同的数值，如何将所有的数值都找到

思路：

如：在数组{1,2,3,4,5,5,5,5,5,5,6} 找5的下标

1.找到mid索引值，不要马上返回

2.向mid索引的左边扫描，将所有满足5的下标，加入到集合ArrayList

3.向mid索引的左边扫描，将所有满足5的下标，加入到集合ArrayList

4.将ArrayList返回

package com.jsoft.practice;

import java.util.ArrayList;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
//        int[] arr= new int[]{1,2,3,5,7,56,345};
//        System.out.println(binarySearch(arr, 0, (arr.length-1), 3));
        int[] arr1= new int[]{1,2,3,5,7,7,7,56,345};
        System.out.println(binarySearch2(arr1, 0, arr1.length - 1, 7));
    }
    public static int binarySearch(int[] arr,int left,int right,int findVal){

        if(left>right){
            return -1;
        }
        int mid=(left+right)/2;
        int midVal=arr[mid];

        if(findVal>midVal){
            return binarySearch(arr,mid+1,right,findVal);
        }else if (findVal<midVal){
            return binarySearch(arr,left,mid-1,findVal);
        }else {
            return mid;
        }
    }
    public static ArrayList<Integer> binarySearch2(int[] arr,int left,int right ,int findVal){
        int mid=(left+right)/2;
        int midVal=arr[mid];
        if(left>right){
            return new ArrayList<>();
        }
        if(midVal>findVal){
            return binarySearch2(arr,left,right-1,findVal);
        }else if(midVal<findVal){
            return binarySearch2(arr,left-1,right,findVal);
        }else {
            ArrayList<Integer> list=new ArrayList<>();
            list.add(mid);
            int temp=mid+1;
            //左移
            while (true){
                if(temp>arr.length-1 || arr[temp]!=findVal){
                    break;
                }
                list.add(temp);
                temp+=1;

            }

            temp=mid-1;
            while (true){
                if (temp<0 || arr[temp]!=findVal){
                    break;
                }
                list.add(temp);
                temp-=1;

            }
            return list;
        }


    }
}

选择排序

选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，继续放在起始位置知道未排序元素个数为0。
选择排序的步骤：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到未排序序列的起始位置。
3重复第二步，直到所有元素均排序完毕。

int[] arr=new int[]{234,567,8,34,487,19};
        for (int i = 0; i < arr.length; i++) {
            int minindex=i;
            for (int j = i+1; j < arr.length; j++) {
                if(arr[minindex]>arr[j]){
                    minindex=j;
                }
            }
            int num=arr[minindex];
            arr[minindex]=arr[i];
            arr[i]=num;
        }
        for (int row:arr
        ) {
            System.out.print(row+"、");
        }

插入排序

插入排序的思想是：将初始数据分为有序部分和无序部分，每一步将一个无序部分的数据插入到前面已经排好序的有序部分中，直到插完所有元素为止。
插入排序的步骤如下：每次从无序部分中取出一个元素，与有序部分中的元素从后向前依次进行比较，并找到合适的位置，将该元素插到有序组当中。

假如有[5,2,3,9,4,7]六个元素，下面就以排序过程中的一个步骤（此时有序部分为[2,3,5,9]，无序部分为[4,7]，接下来要把无序部分的“4”元素插入到有序部分），来展示一下插入排序的运行过程。

  int[] arr=new int[]{1,33,5,10,8,-8,7,20};
        //定义一个参照物
        int current;
        for (int i=0;i< arr.length-1;i++){
            current=arr[i+1];
            //定义上一个元素的下标
            int preIndex=i;
            //上一个数下标有效，不能小于0，并且比上一个数小
            while (preIndex>=0 &&current<arr[preIndex]){
                arr[preIndex+1]=arr[preIndex];
                preIndex--;
            }
            arr[preIndex+1]=current;
        }
        for(int i:arr){
            System.out.print(i+"、");
        }

数组的扩容

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