数组 冒泡排序 选择排序

数组

什么是数组

数组的定义：相同类型数据的集合。

数组的作用：数组是用来存储相关数据的。

数组的特点

（1）数组是一块连续的内存空间，所以数组的大小在创建数组时必须确定，否则如果数组空间增大了就需要对后面的数据挪移；

（2）存储数据的数据类型一定是相同的。

原因：数组在获取数据的时候采用的是定长的方式进行切割，而长度的大小来源于数据的类型，因此数组才可以通过下标获取数据。

在内存中给数组开辟一块空间，里面密密麻麻的全是电容器，每个电容器存储1bit数据，它们都是一排一排连接好的，如果此时存储一个byte类型的 '5'，再连着存储一个int类型的 '10' ，byte类型只占8bit，int类型占32bit，如果此时要获取这个数据的时候，byte类型的8位和int类型的32位数据是拼接在一起的，此时无法确定从什么位置截取，会产生歧义。

创建数组的四种方式

int arr[]=new int[] {}; //创建一个大小为0的数组，往里面添加数组的时候添加不进去，后续执行 arr[0] = 1; 时会报错。

int brr[]=new int[5]; //定义了一个长度为5的数组，数组内部的默认值全是0。

int crr[]=new int[] {1,2,3,4,5,6}; //创建一个长度为6的数组。

int drr[]={1,11,33,44}; //创建一个大小为4的数组。

输出数组

//方法一：使用for循环遍历数组进行输出
for (int i=0;i<brr.length;i++) {
    System.out.println(brr[i]);
}

//方法二：使用Java提供的Arrays.toString方法进行输出
System.out.print(Arrays.toString(crr));

在数组当中 = 的意义

在数组中，当两个相同的数组的同一个位置用等号相连时，等号前是变量，等号后面是值

crr[1]=crr[1]++;
System.out.print(crr[1]);
//输出结果：2

crr[1]=++crr[1];
System.out.print(crr[1]);
//输出结果：3

数组的扩容

数组的扩容是不可能在原地址进行的，只能舍弃原有空间，开辟新的空间。

int[] arr = new int[5];
arr[0] = 1;
arr[1] = 1;
arr[2] = 1;
arr[3] = 1;
arr[4] = 1;

//此时数组已经满了，需要扩容就需要开辟新的空间
int[] brr = new int[arr.length*2];

//通过for循环遍历将arr的数放入brr
for(int i = 0; i < arr.length ;i++){
    brr[i] = arr[i];
}

//令arr重新指向brr指向的地址，JVM回收arr的地址
arr = brr;

System.out.println(Arrays.toString(arr));

//输出结果：[1,1,1,1,1,0,0,0,0,0]

例题一

在一组未排序的数中找到最大的数和最小的数

public static void main(String[] args) {
    int[] arr= {8,4,1,3,9,7,10,42,0};
    fund(arr);
}
public static void fund(int[] arr) {
    int tempMax=arr[0];
    int tempMin=arr[0];
    for(int i=0;i<arr.length;i++) {
        if(tempMin<arr[i]) {
            tempMin=arr[i];
        }else if(tempMax>arr[i]) {
            tempMax=arr[i];
        }
    }
    System.out.println("最小的数是："+tempMin+" 最大的数是："+tempMax);
}
//输出结果：最小的数是：42 最大的数是：0

例题二

删除数组中的重复元素，返回当前剩余数组的长度与新数组。（使用快慢指针）

if(nums.length == 0){
    return 0;
}
int fast = 0;
int slow = 0;
while(fast < nums.length){
    if(nums[fast] == nums[slow]){
        fast++;    
    }else{
        slow++;
        nums[slow] = nums[fast];    
    }
}
return slow +1;

例题三

给定一个数组和一个值，移除数组中所有数值等于val的元素，并返回移除后数组的新长度

int fast = 0;
int slow = 0;
while(fast < nums.length){
    if(nums[fast] != val){
        nums[slow] = nums[fast];
        slow++;    
    }
    fast++;
}
return slow;

例题四

编写一个函数，将输入的字符串 s[i] 反转过来

int length=s.length;
int mid=(length)/2;
length--;
for(int i=0;i<mid;i++){
    char temp=s[i];
    s[i]=s[length-i];
    s[length-i]=temp;
}

例题五

给定一个数组arr[]，在给定的下标 index =2 处插入给定的数值 value = 9

public static void main(String[]args) {
    int[] arr= {8,4,1,3,9,7,10,42,0};
    int temp=9; //temp是当前数组有效数的个数，也可以用arr.length表示
    insert(arr,22,2,temp);
}
public static void insert(int[] arr,int value,int index,int temp){
    int[] brr=new int[temp+1];
    brr[index]=value;
    int k=0;
    for(int i=temp;i>=0;i--) {
        if(i==index) {
        i--;
        k++;
        }
    brr[i]=arr[i-1+k];
    }
    arr=brr;
    System.out.print(Arrays.toString(arr));
}
//输出结果：[8,4,9,1,3,9,7,10,42,0]

排序算法

冒泡排序

冒泡排序的核心思想就是两两进行对比交换，给定一个数组，我们可以定义一个 i 指针，再定义一个 i+1 指针，如果 i+1比 i 对应的值小，则将它们的值进行交换，一轮排序下来就可以将整个数组中最大的数放在最右边。重复前面的操作，就可以将整个数组完成排序。

public static void main(String[]args){
    int[] arr = {8,4,1,3,9,7,10,42,0};
    sort(arr);
    System.out.print(Arrays.toString(arr));
}
public static void sort(int[] arr){
    for(int j = 0; j < arr.length ;j++){ //总共进行的轮数
        for(int i = 0; i < arr.length; i++){ //一轮排序
            if(arr[i] > arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;    
            }
        }
    }
}
//输出结果：[0,1,3,4,7,8,9,10,42]

简单选择排序

在一个数组中，找到待排序数组中的最小值与数组的第一个值进行交换，再在剩下的数组中找到最小的值与第二个值进行交换，以此类推。

public static void main(String[]args){
    int[] arr = {8,4,1,3,9,7,10,42,0};
    sort(arr);
    System.out.print(Arrays.toString(arr));
}
public static void sort(int[] arr){
    for(int h = 0; h < arr.length; h++){ //总共进行的轮数
        int min = arr[0]; //定义min表示数组的最小值并赋初值为arr[0]
        int minIndex = 0; //定义minIndex表示数组最小值的下标并赋初值为0
        for(int i = 0; i < arr.length; i++){ //一轮排序
            //比较下标为i的数和min谁小 如果i对应的值小 就把arr[i]赋值给min 并且标记i的位置
            if(arr[i] < min){
                min = arr[i];
                minIndex = i;        
            }
        }
        //将这一轮找到的最小值与这一轮的第一个值进行交换
        int temp = arr[0];
        arr[0] = arr[minIndex];
        arr[minIndex] = temp;
    }
}
//输出结果：[0,1,3,4,7,8,9,10,42]