411Java数组.docx

411Java数组.docx

《411Java数组.docx》由会员分享，可在线阅读，更多相关《411Java数组.docx（22页珍藏版）》请在冰豆网上搜索。

411Java数组

4.1Java数组

一、一维数组

1.基本概念：

（1）数组：

数组是有序数据的集合。

（2）数组元素：

数组名和下标来唯一地确定数组中的元素。

（数组元素的下标从0开始）

（3）数组长度：

数组对象所包含的元素个数。

2．一维数组的声明

在Java中，一维数组的定义形式为：

数组元素类型数组名[]；或数组元素类型[]数组名；

例如char[]c;

Charc[];

也可以在一条语句中声明多个数组变量：

（一般不提倡使用）

Char[]a,b,c;

Chara[],b[],c[];

但chara[],b,c;中a是数组变量，而b和c不是。

3.Java中数组对象的创建（两种形式）

（1）使用关键字new创建数组对象，格式为：

数组名=new数组元素的类型[数组元素的个数]；

例如：

public class TestNew 

{ 

 public static void main（String args[]） { 

         int[] s ; 

         int i ; 

         s = new int[5] ; 

         for（i = 0 ; i < 5 ; i++） { 

             s[i] = i ; 

         } 

         for（i = 4 ; i >= 0 ; i--） { 

             System.out.println（"" + s[i]） ; 

         } 

     }  

} 

（2）数组的初始化语句创建数组对象

数组元素的数据类型[]变量名={数组元素1，数组元素2，…,数组元素n};

或：

数组元素的数据类型变量名[]={数组元素1，数组元素2，…,数组元素n};

例如：

char[]c={‘a’，‘b’，‘c’，‘d’，‘e’}

初始化：

1）静态初始化：

在定义数组的同时就为数组元素分配空间并赋值；

2）动态初始化：

数组定义与为数组分配空间和赋值的操作分开进行；

3）默认初始化：

数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。

数组元素的数据类型是引用型（即类、接口或数组类型）时，数组名[下标]的值是引用。

在没有给它赋值前，其默认的值为null。

因此还需要通过new运算符及赋值语句给它们分别赋值。

例如：

Strings[]=newString[3];

S[0]=newString（“abc”）;

S[1]=newString（“def”）;

S[2]=newString（“gh”）;

上面的四条语句还可以简化成一个数组的初始化语句：

Strings[]={newString（“abc”）,newString（“def”）,newString（“gh”）};//变量s是一个数组对象的引用，执行初始化以后，该数组的三个元素分别指向三个不同的字符串对象。

程序举例：

publicclassTestD

{

publicstaticvoidmain（Stringargs[]）{

inta[];

a=newint[3];

a[0]=0;

a[1]=1;

a[2]=2;

for（inti=0;i<3;i++）

System.out.print（""+a[i]）;

System.out.println（）;

Datedays[];

days=newDate[3];

days[0]=newDate（2008,4,5）;

days[1]=newDate（2008,2,31）;

days[2]=newDate（2008,4,4）;

for（inti=0;i<3;i++）

{System.out.print（days[i].year）;

System.out.print（"."+days[i].month）;

System.out.print（"."+days[i].day）;

System.out.println（）;

}

}

}

classDate

{

intyear,month,day;

Date（intyear,intmonth,intday）{

this.year=year;

this.month=month;

this.day=day;

}

}

程序输出：

012

2008.4.5

2008.2.31

2008.4.4

静态初始化举例：

public class TestS    

{    

   public static void main（String args[]） {    

         int a[] = {0,1,2} ;    

         Time times [] = {new Time（19,42,42）,new Time（1,23,54）,new Time（5,3,2）} ;    

     }    

}    

class Time    

{    

     int hour,min,sec ;    

     Time（int hour ,int min ,int sec） {    

         this.hour = hour ;    

         this.min = min ;    

         this.sec = sec ;    

     }    

}   

4．一维数组元素的引用

•只有完成了对所有数组元素的创建和初始化工作之后，才可以在程序中引用数组元素、修改其属性和调用其方法。

•Java中数组元素的引用是通过数组下标来实现的，其引用方式为：

•数组名[数组下标]

•其中数组下标可以为整型常数或表达式，下标从0开始，到数组元素个数值减1为止。

每个数组都有一个属性length来指明它的长度，即数组元素的个数。

例：

//一维数组定义与输出

class shuzu

{

 publicstaticvoidmain（String[]args）

 {

  intstu[]=newint[]{1,2,3};   //方法一

  //intstu[]={1,2,3};                方法二

  //int[]stu=newint[]{1,2,3}; 方法三

  //int[]stu={1,2,3};               方法四

  for（inti=0;i

   System.out.println（stu[i]）;

 }

}

例2：

数组排序输出

publicclassBubbleSort{

publicstaticvoidmain（Stringargs[]）{

inta[]={27,6,4,8,10,12,89,68,45,37};

System.out.println（"排序前的数据序列：

"）;

printArray（a）;

System.out.println（"排序的各趟结果：

"）;

sortBubble（a）;

printArray（a）;

}

//数组排序的方法

publicstaticvoidsortBubble（inta[]）{

inthold;

for（intpass=1;pass

for（inti=0;i

if（a[i]>a[i+1]）{

hold=a[i];

a[i]=a[i+1];

a[i+1]=hold;

}

printArray（a）;

}

}

//打印数组的方法

publicstaticvoidprintArray（intb[]）{

for（inti=0;i

System.out.print（""+b[i]）;

System.out.println（""）;

}

}

AVA中运用数组的几种排序算法

JAVA中在运用数组进行排序功能时，一般有四种方法：

快速排序法、冒泡法、选择排序法、插入排序法。

排序算法即解决以下问题的算法：

输入：

n个数的序列。

输出：

原序列的一个重排；使得a1*<=a2*<=a3*<=...<=an*。

1.选择排序

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

基本思想

　　n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

　　①初始状态：

无序区为R[1..n]，有序区为空。

　　②第1趟排序

　　在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

　　……

　　③第i趟排序

　　第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R（i..n）。

该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

例如：

初始关键字[4938659776132749]

　　第一趟排序后13[38659776492749]

　　第二趟排序后1327[659776493849]

　　第三趟排序后132738[9776496549]

　　第四趟排序后13273849[76976549]

　　第五趟排序后1327384949[976576]

　　第六趟排序后132738494965[9776]

　　第七趟排序后13273849496576[97]

最后排序结果1327384949657697

publicclassselectsort{

publicstaticvoidmain（String[]args）{

int[]arr={2,345,111,1,34,5};

inttemp=0;

intmin=0;

for（inti=0;i

min=i;

for（intj=i+1;j

if（arr[min]>arr[j]）

min=j;

}

temp=arr[min];

arr[min]=arr[i];

arr[i]=temp;

}

System.out.println（"排序后的数组为:

"）;

for（inti=0;i

System.out.print（arr[i]+""）;

}

}

}

2.冒泡排序（BubbleSort）

基本概念是：

依次比较相邻的两个数，将小数放在前面，大数放在后面。

即在第一趟：

首先比较第1个和第2个数，将小数放前，大数放后。

然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。

至此第一趟结束，将最大的数放到了最后。

在第二趟：

仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。

如此下去，重复以上过程，直至最终完成排序。

由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

用二重循环实现，外循环变量设为i，内循环变量设为j。

假如有10个数需要进行排序，则外循环重复9次，内循环依次重复9，8，...，1次。

每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i,j的值依次为1,2,...10-i。

程序：

publicclassmaopaosort{

publicstaticvoidmain（String[]args）{

int[]arr={2,345,111,1,34,5};

inttemp=0;

for（inti=0;i

for（intj=0;j

if（arr[j]>arr[j+1]）

{temp=arr[j];

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

arr[j+1]=temp;

}

}

System.out.println（"排序后的数组为:

"）;

for（intk=0;k

System.out.print（arr[k]+""）;

}

}

3.插入排序

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O（n^2）。

是稳定的排序方法。

插入算法把要排序的数组分成两部分：

第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素。

在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的位置。

基本思想:

　　将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例：

　　{{a1}，{a2，a3，a4，…，an}}

　　{{a1⑴，a2⑴}，{a3⑴，a4⑴…，an⑴}}

　　…

　　{{a1（n-1），a2（n-1），…},{an（n-1）}}

每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，找出插入位置，将该元素插入到有序数列的合适位置中。

具体算法描述如下：

　　⒈从第一个元素开始，该元素可以认为已经被排序

　　⒉取出下一个元素，在已经排序的元素序列中从后向前扫描

　　⒊如果该元素（已排序）大于新元素，将该元素移到下一位置

　　⒋重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

　　⒌将新元素插入到下一位置中

⒍重复步骤2

publicclassInsertSort{

publicstaticint[]a={5,8,11,6,77,33,13,99,24,37};

publicstaticvoidmain（Stringargs[]）{

inti;//循环计数变量

intIndex=a.length;//数据索引变量

System.out.print（"排序前:

"）;

for（i=0;i

System.out.print（""+a[i]+""）;

System.out.println（""）;

InsertSort（a）;//选择排序

//排序后结果

System.out.print（"排序后:

"）;

for（i=0;i

System.out.print（""+a[i]+""）;

System.out.println（""）;

}

publicstaticvoidInsertSort（intb[]）{

inti,j,k;//循环计数变量

intInsertNode;//欲插入数据变量

for（i=1;i

{

InsertNode=a[i];//设定欲插入的数值

j=i-1;//欲插入数组的开始位置

//找适当的插入位置

while（j>=0&&InsertNode

a[j+1]=a[j];

j--;

}

a[j+1]=InsertNode;//将数值插入

//打印目前排序结果

System.out.print（"排序中:

"）;

for（k=0;k

System.out.print（""+a[k]+""）;

System.out.println（""）;

}

}

}

4.快速排序

基本思想：

   设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：

①分解：

   在R[low..high]中任选一个记录作为基准（Pivot），以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1）和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录（不妨记为pivot）的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置（pivotpos）上，它无须参加后续的排序。

 注意：

   划分的关键是要求出基准记录所在的位置pivotpos。

划分的结果可以简单地表示为（注意pivot=R[pivotpos]）：

   　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys

              其中low≤pivotpos≤high。

②求解：

  通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。

③组合：

  因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。

对快速排序而言，"组合"步骤无须做什么，可看作是空操作。

快速排序算法QuickSort

voidQuickSort（SeqListR，intlow，inthigh）

  {//对R[low..high]快速排序

    intpivotpos；//划分后的基准记录的位置

    if（low

       pivotpos=Partition（R，low，high）；//对R[low..high]做划分

       QuickSort（R，low，pivotpos-1）；//对左区间递归排序

       QuickSort（R，pivotpos+1，high）；//对右区间递归排序

     }

   }//QuickSort

Java快速排序代码：

publicclassQsort{

publicstaticvoidmain（String[]args）

{//TODO自动生成方法存根

quicksortqs=newquicksort（）;

intdata[]={44,22,2,32,54,22,88,77,99,11};

qs.data=data;

qs.sort（0,qs.data.length-1）;

qs.display（）;

}

}

classquicksort

{

publicintdata[];

privateintpartition（intsortArray[],intlow,inthight）//找出分界点

{

intkey=sortArray[low];

while（low

{

while（low=key）

hight--;

sortArray[low]=sortArray[hight];

while（low

low++;

sortArray[hight]=sortArray[low];

}

sortArray[low]=key;

returnlow;

}

publicvoidsort（intlow,inthight）

{

if（low

{

intresult=partition（data,low,hight）;

sort（low,result-1）;

sort（result+1,hight）;

}

}

publicvoiddisplay（）

{

for（inti=0;i

{

System.out.print（data[i]）;

System.out.print（""）;

}

}

}

二、二维数组

1．二维数组的定义

在Java中，二维数组的定义形式为：

•数组元素类型数组名[][]；

•数组元素类型[][]数组名；

2．二维数组的初始化

•静态初始化：

•Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。

例如：

•intintArray[][]={{1,2},{2,3},{3,4,5}};

3．二维数组元素的引用

•与一维数组相同，二维数组元素可以通过指定数组元素下标的方式进行引用。

•对二维数组中的每个元素，引用方式为：

数组名[index1][index2]。

•需要注意的是：

在数组的每一维中，数组元素的编号均从0开始，到该维的数组元素个数减1结束。

//二维数组定义与输出

classerwshzu

{

 publicstaticvoidmain（Stringargs[]）

 {

  //int[][]num=newint[][]{{1,2,3},{4,5,6}};    方法一

  int[][]num={{1,2,3},{4,5,6}};                      //方法二

  for（inti=0;i

  {

   for（intj=0;j