Day4-知识总结

磕代码

已于 2023-07-15 11:56:58 修改

阅读量40

点赞数

分类专栏： java第一阶段文章标签：算法 java

于 2023-07-15 10:48:21 首次发布

本文链接：https://blog.csdn.net/m0_69480146/article/details/131730801

版权

java第一阶段专栏收录该内容

23 篇文章 0 订阅

订阅专栏

数组

数组：在一个变量中,存储多个数据值(java的数组只能同种类型数据)
数组长度：数组中可以存放的数据个数，就是数组的长度(java中数组长度不变)
数组下标：从0开始计数(索引length-1)
数值长度：从1开始计数(length)
数组遍历：通过循环,找到每一个元素
数组排序,无序数组，通过交换位置实现升序/降序
数组越界异常：使用数组下表之外的索引来找数组元素
编译错误：语法规则有误，无法将.java文件转变为.class文件

数组初始化

方法一

int[] a1;//a1就是一个数组
a1=new int[]{1,2,3,4,5}; //数组赋值初始化

方法二

int []a2={1,2,3,4,5,6}; //创建了数组，并进行初始化赋值

方法三

int []a3=new int[10];//创建了数组，设置了数值长度为10
//赋值
for(int i=0;i<a3.length;i++){ a3[i]=10;}

数组扩容

数组是固定长度是无法扩容的,
可以利用Arrays.copyOf(num,num.length+1)
对数组进行长度增加

int []a3=new int[10];
for(int i=0;i<a3.length;i++){ a3[i]=10;}
a3=Arrays.copyOf(a3,a3.length+1);
//原理:创建一个新的数组，长度比原来+1,将原数组的赋给新数组后，将新数组付给原数组。

数组逆序输出

逆序不是排序，可以是无序的
排序只有升序与降序
有序的数组另算

public static void reversedNumber(int num[]){
    for(int i=0;i<num.length/2;i++){
        int tmp=num[i];
        num[i]=num[num.length-1-i];  //数组两两交换==元素两交换
        num[num.length-1-i]=tmp;
        }
    }

最大的与第一个元素交换，最小的与最后一个元素交换

首先找到最大元素的下标，让其与第一个元素交换
其次找到最小元素的下标，让其与最后一个元素交换
综上所述，先找下标，后元素之间交换

public static void exchangeNumber(int num[]){
    int max=0;
    for (int i=0;i<num.length;i++){
         if(num[i]>num[max])
           max=i;
        }
     if(max!=0){
        int tmp=num[max];
        num[max]=num[0];
        num[0]=tmp;
        }
     int min=num.length-1;
     for (int i=0;i<num.length;i++){
          if(num[i]<num[min])
             min=i;
         }
     if (min!=num.length-1){
         int tmp=num[min];
         num[min]=num[num.length-1];
         num[num.length-1]=tmp;
        }
    }

n个整数，使其前面各数顺序向后移m个位置

首先，n个整数放置在固定长度N[n]的数组中
其次每次元素整体向后移1个位置，则1~n-1个元素向后移一位，最后一个元素放置在原先第一个元素的位置上。
因此，后移m个位置==将“1~n-1个元素向后移一位，最后一个元素放置在未移动前的第1个元素的位置上”这个循环进行m次，则可实现

int[]N={1,2,3,4,5,6}
int m=3; //后移3个位置
for(int i=1;i<=m;i++){  //控制循环次数
		int last=N[N.length-1];  //将数组的最后一个元素值用变量保存起来
		for(int j=N.length-2;j>=0;j--){    //开始将n-1~1个元素都向后移一位
				N[j+1]=N[j];  将前一个元素的值赋给下一个元素; 直到把索引0上的值赋到索引1上
		}
		N[0]=last; //最后将原先最后一个元素值赋值到索引0上
}

排序

逆序不是排序
排序–升序与降序
排序规则–两两比较,看是否需要交换位置。

冒泡排序

以从小到大排序进行解释:

相邻的两个元素之间比较互换，每一趟可以找到一个最大值放在最后。
(第一趟，找到一个最大值放置最后一个位(倒数第一的位置)；第二趟，找到一个最大值放置倒数第二的位置…)
因此,在每次一趟结束后，下一趟的比较次数将会减少。

int[]N={6,5,4,3,2,1}
//每一次比较确定一个元素的位置，有6个元素，当前五个元素的位置确认好时，第6个元素的位置则不用再比较了。
//因此比较次数为N.length-1
for(int i=0;i<N.length-1;i++){ //控制比较次数-- 因为i=0，因此i需要小于N.length-1;不能等于
		for(int j=0;j<N.length-1-i;j++){  //控制趟数，每次确认一个元素的位置需要进行几趟对比
				if(N[j+1]<N[j]){  //若j+1位置上的数据比j上的小，则两个元素值之间进行交换
						int tmp=N[j];
						N[j]=N[j+1];
						N[j+1]=tmp;
				}
		}//内部一次循环找出一个最大值
}

选择排序

以从小到大排序进行解释:

找每个位置,即外层循环控制位置，内存循环找到最小的元素，再将其进行两个元素之间位置交换得到最小值。
(第一次，找出数组最小的元素放入索引0的位置；第二次，找出数组最小的元素放入索引1的位置…)
一个位置一个位置的找

int[]N={6,5,4,3,2,1}
for(int i=0;i<N.length;i++){
		int min=i;  //默认当前位为最小值
		for(int j=i+1;j<N.length;j++){  //遍历当前位之后的元素，进行元素之间的比较
				if(N[min]>N[j])
					min=j;  //找出当前位最小值的下标
 		}
		if(min!=i){    //若当前i本身位最小值，则不用交换
			int tmp=N[i];
			N[i]=N[min];
			N[min]=tmp;
		}
}

插入

对于N[n]固定长度数组的元素插入，
首先，N[n]的数组需是有序数组；
其次，涉及到需要将数组先扩容至n+1的长度；
而后，找利用for循环进行判断插入位置的下标；
最后，通过移动元素再将需要插入的数据插入

int[]N={7,6,5,3,2,1} //从大到小的排序
N=Arrays.copyOf(N,N.length+1);
int num=4//需要插入的数字
int index=0; //默认插入位置的下标为-1
for(int i=0;i<N.length;i++){
		if(num>N[i]){  //找到第一个元素值比插入值小的
			index=i;
			break;
		}
}
for(int i=index;i<N.length;i++){
		N[i+1]=N[i];
}
N[index]=num;