数组与基础语法

                                  

 数组的应用排序查找 反转 查表法应用

选择排序(开发):用数组中左边元素与右边所有元素依次比较，如果满足条件，进行交接，最值出现在左边。

代码实现

                            public static voidselectSort(int[] arr){

                                     //对数组进行排序

                                     for(inti=0;i<arr.length-1;i++){

                                     //控制数组中的每一个元素下标，要比较的那个元素符号                                         

                                               for(intj=i+1;j<arr.length;j++){

                                               //操作与i元素比较的所有元素下标                                                  

                                                        if(arr[i]<arr[j]){

                                                                 inttmp=arr[i];

                                                                 arr[i]=arr[j];

                                                                 arr[j]=tmp;

                                                        }

                                                       

 

                                               }

                                     }

 

                            }

                            改进代码

                            public static voidselectSort1(int[] arr){

                                     //对数组进行排序

                                     for(inti=0;i<arr.length-1;i++){

                                              

                                               for(intj=i+1;j<arr.length;j++){

                                                       

                                                        swap(arr,i,j);

                                                       

 

                                               }

                                     }

 

                            }

                            //将指定的两个值进行交换

                            /*

                                    参数:int[] arr要操作的数组   int i,int j这是数组中两个元素交换的元素的下标。

                            */

                            public static voidswap(int[] arr,int i,int j){

 

                                     if(arr[i]>arr[j]){

                                               inttmp=arr[i];

                                               arr[i]=arr[j];

                                               arr[j]=tmp;

                                     }

                            }

                           

         //选择排序的优化

public static voidselectSort(int[] arr){              

                            //对数组进行排序

                            for(int i=0;i<arr.length-1;i++){

                                     intindex=i; //用来记录最值的下标

                                     for(intj=i+1;j<arr.length;j++){

                                               if(arr[index]>arr[j]){

                                                        index=j;//让index一直记录的是最值的下标.

                                               }

                                     }

                                     //将i位置上的元素与index位置上的元素进行交换

                                     if(index!=i){//如果当前要交接的元素的值正好在应该存在的位置，那么不需要进行交换

                                               inttmp=arr[i];

                                               arr[i]=arr[index];

                                               arr[index]=tmp;

                                     }

                            }

 

                   }

冒泡排序

原理:相邻的两个元素依次进行比较，当所有元素比较一次后，产生的最值就出现在数组的最右边

                        下次在将其它的元素进行比较，最值出现在比较的这些元素的最右边。所有的元素全都比较完成

                             后数组中的元素就排序。

                             //冒泡排序

                   public static voidbubbleSort(int[] arr){

                            for(int i=0;i<arr.length;i++){//只是控制比较的次数

                             for(intj=0;j<arr.length-1-i;j++){  //-1目的是为了控制越界  -i：为了控制最右边的最值不在参与比较。

                                               if(arr[j]>arr[j+1]){//相邻元素进行比较

//两个元素进行交换。        

                                                        inttmp=arr[j];

                                                        arr[j]=arr[j+1];

                                                        arr[j+1]=tmp;

                                               }

                                     }

                            }

                   }

数组中元素查找

1.普通查找：比较简单，可以应用在任意数组

                  

                   /*

                            功能:查找数组中是否存在指定元素,如果存在返回其下标

                            参数: 1.数组   2.要查找的元素

                            返回值:查找到的元素的下标,如果返回-1,代表没有查找到指定的元素

 

                   */

                   public static intsearch(int[] arr,int key){

                            for(int i=0;i<arr.length;i++){

                            if(arr[i]==key){

                                               returni;

                                     }      

                            }

 

                            //没找到返回什么

                            return -1;

                   }

2.二分法(折半)查找只能应用有顺序的数组中。

                   原理:需要定义 start=0 end=数组的下标最大值(数组名.length-1) middle=(start+end)/2

                        用要查找的值与middle位置上的元素进行比较，

                        如果大于  start=middle+1

                        如果小于  end=middle-1

                        等于     中了，找到了这个值

                        middle每次操作后都应该重新计算middle=(start+end)/2

当start>end的值代表找不到这个值了，这时候就不需要查找了

                  /*

                   功能;通过折半查找指定元素

                   参数：int[] arr它必须是有顺序的  int key要查找的元素符号

                   返回值:如果key在数组中存在，那么返回其下标，不存在返回-1

*/

                   public static inthalfSearch(int[] arr,int key){

                            int start=0; //开始

                            int end=arr.length-1;//结束

                            intmiddle=(start+end)/2; //中间

while(start<=end){ //如果开始的值一下直小于或等于结束值那么说明元素还没有查找完成。

                                     if(key>arr[middle]){//要查找的元素大于中间位置元素，那么开始就应该变化的成middle+1，从这个位置在查找

                                               start=middle+1;  

                                     }elseif(key<arr[middle]){ //要查找的元素小于中间元素，那么结束就应该成middle-1,这个位置就是新的结束位置

end=middle-1;    

                                     }elseif(key==arr[middle]){//如果等于，那么代表查找到了。

                                               returnmiddle;

                                     }

                                      middle=(start+end)/2; //每一次变化后，middle必须重新计算                 

                            }

 

                            return -1;

 

                   }

 

数组元素反转

原理:定义开始为0与结束为数组长度-1,变量来操作数组的下标

                        将开始与结束的位置元素进行交换，

                             然后让开始++,结束执行--,在进行交换.

 

                   直到开始下标值大于或等于于结束的下标的值，不在进行交换。

 

                   public static voidreverseArray(int[] arr){

                           

                            //start 代表的是开始

                            //end 代表的是结束.

 

                            for(intstart=0,end=arr.length-1;start<end;start++,end--){

 

                                     inttmp=arr[start];

                                     arr[start]=arr[end];

                                     arr[end]=tmp;

                            }      

                   }

查表完成进制转换

           主要是完成进制转换.

                   十进制----->2,8,16

使用查表法对进制转换进行改良

查表示例

         现在数组arr中的元素值与tools数组中的元素值对应，当我们得到arr数组的元素0时，我们就可以显示tools数组中下标为0元素

         ,就得到了周日.

int[] arr={0,1,2,3,4,5,6};

String[] tools={"周日","周一","周二","周三","周四","周五","周六"};

什么时候使用查表法

当我们操作的数组与另一个表中的数组有一一对应关系，这个时候就可以使用查表法.

class Demo9

         {

                   public static voidmain(String[] args)

                   {

                            Strings1=toBinary(10);

System.out.println(s1);

String s2=toOctal(10);

System.out.println(s2);

String s3=toHex(10);

System.out.println(s3);

                  

                   }

 

                   //使用位运算符进行十进制转换成二进制。

                   /*

                            参数：要转换的十进制数

                            返回值:它的二进制表示形式

                   */

                   public static StringtoBinary(int n){

                           

                            returnnumberToString(n,1,1);

                   }

//使用位运算进行下进制转换成八进制

                   public static StringtoOctal(int n){

                            returnnumberToString(n,7,3);

                   }

//使用位运算进行下进制转换成十六进制

                   public static StringtoHex(int n){

                            returnnumberToString(n,15,4);

                   }

 

                   /*

                            该方法作用：将一个整数n,转换成对应的进制数

                            参数:n要转换的整数   num代表的是截取位 1 7 15  off位移的偏移量

                   */

                   public static StringnumberToString(int n,int num,int off){

                            Stringstr="";

                            String[] tools={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};

                            int[] arr=newint[32];

                            intindex=0;//

                            for(;index<arr.length;index++){

                                     arr[index]=n&num;   //截取几位问题

                                     n=n>>>off;  //右移几位问题

                                     if(n==0){

                                               break;

                                     }

                            }

                            for(int i=index;i>=0;i--){

                                     intnumber=arr[i];

str+=tools[number];

}

                            return str;

                   }

         }

二维数组

数组本身是一种数组类型，它是引用类型。

数组是容器可以装数据。数据可以是什么类型?

数组中的元素可以是任何类型数据。数组中就可以装入数组.

int[] a=new int[10]; //数组

int[][] arr={a}; //arr是一个数组，它里面装入了一个元素a

二维数组的创建方式

         静态

                   元素类型[][]数组名={};

                   元素类型[][]数组名=new元素类型[][]{};

         动态

                   元素类型[][]数组名=new元素类型[长度][];

class Demo11

{

         public static void main(String[] args)

         {

                   //下面代码代表数组中有三个一维数组，每个一维数组中有三个int类型的元素，当前值为默认值0

                   //int[][] arr=new int[3][3];//{{0,0,0},{0,0,0},{0,0,0}}

//System.out.println(arr[0][0]);

int[][] arr=new int[3][]; //代表二维数组中的每一个一维数组没有初始化.

                   arr[0]=new int[5];

                   arr[1]=new int[3];

                   arr[2]=new int[4];

                   //System.out.println(arr[0][0]);

//将二维数组中的元素赋值成1-100以内随机数

Random ran=new Random();

                   for(int i=0;i<arr.length;i++){

                            for(intj=0;j<arr[i].length;j++){ //arr[i].length代表的是二维数组中每一个一维数组的长度.

                                     arr[i][j]=ran.nextInt(100);

                            }

                   }

//打印数组中的内容

                   for(inti=0;i<arr.length;i++){

                            for(intj=0;j<arr[i].length;j++){

                                     System.out.print(arr[i][j]+"  ");

                            }

                            System.out.println();

                   }

}

}