java数组查找排序_Java学习第四篇:数组，排序，查找

最新推荐文章于 2022-09-10 22:30:46 发布

采璇

最新推荐文章于 2022-09-10 22:30:46 发布

阅读量276

点赞数

文章标签： java数组查找排序

本文链接：https://blog.csdn.net/weixin_33606346/article/details/114773150

版权

一.数组

1.一维数组

(1).数组的定义

数据类型数组名[]=new 数据类型[大小]

public classDemo1 {public static voidmain(String[] args) {//第一种定义方式

intarr[];

arr=new int[5];//第二种定义方式

int arr2[]=new int[5];//第三种定义方式

int[] arr3;

arr3=new int[5];//第四种定义方式

int arr4[]={1,2,3,4};

}

(2).对象数组

假设一个养狗场有4只狗, 名字分别是花花, 白白, 黑黑, 红红, 体重分别为4.5Kg, 5.6Kg, 7.8Kg, 9.0Kg, 计算出平均体重, 并找出体重最大的狗的名字.

import java.io.*;public classDemo2 {public static voidmain(String[] args) {try{//输入流

InputStreamReader isr=newInputStreamReader(System.in);

BufferedReader bReader=newBufferedReader(isr);//定义一个对象数组,可以存放4只狗的对象数组

Dog dogs[]=new Dog[4];//给对象赋值

for(int i=0;i

dogs[i]=newDog();

System.out.println("请输入第"+(i+1)+"狗的名字:");

String dogName=bReader.readLine();

dogs[i].setName(dogName);

System.out.println("请输入第"+(i+1)+"狗的体重:");

String dogWeight=bReader.readLine();float dWeight=Float.parseFloat(dogWeight);

dogs[i].setWeight(dWeight);

}//总体重

float allWeight=0;//平均体重

float averWeight=0;for(int i=0;i

allWeight+=dogs[i].getWeight();

}

averWeight=allWeight/dogs.length;

System.out.println("平均体重为:"+averWeight);//体重最大的

float maxWeight=dogs[0].getWeight();int maxWeightIndex=0;for(int i=1;i

maxWeight=dogs[i].getWeight();

maxWeightIndex=i;

}

System.out.println("体重最大的狗是:"+dogs[maxWeightIndex].getName()+

" 体重为:"+dogs[maxWeightIndex].getWeight());

}catch(Exception e) {

e.printStackTrace();

}

}classDog {privateString name;private floatweight;publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public floatgetWeight() {returnweight;

}public void setWeight(floatweight) {this.weight =weight;

}

运行结果：

请输入第1狗的名字:

花花

请输入第1狗的体重:

4.5

请输入第2狗的名字:

白白

请输入第2狗的体重:

5.6

请输入第3狗的名字:

黑黑

请输入第3狗的体重:

7.8

请输入第4狗的名字:

红红

请输入第4狗的体重:

9.0

平均体重为:6.7250004

体重最大的狗是:红红体重为:9.0

(3).数组小结

①数组可存放同一类型的数据;

②简单数据类型(int, float...)数组可直接赋值, 对象数组在定义后,赋值时需要再次为每个对象分配空间;

③数组大小必须事先指定;

④数组名可理解为指向数组首地址的引用;

⑤数组的下标是从0开始编号的.

2.多维数组

二维数组的定义

数据类型数组名[][]=new 数据类型[大小][大小]

二.排序

这里主要介绍了七种常用的排序方法, 包括冒泡排序, 选择排序, 直接插入排序, 希尔排序, 堆排序, 归并排序和快速排序. 这里主要参考了《大话数据结构》和《MoreWindows白话经典算法之七大排序第2版(高清)》", 下载链接为http://download.csdn.net/detail/morewindows/4560056

1.冒泡排序

classBubbleSort {/*** 冒泡排序方法1,从小到大

* 如果经过一趟排序之后没有任何交换,说明已经排好序了,不需要再进行下去了

*@paramarr 待排序数组*/

public void bubbleSort1(intarr[]) {//标记位

boolean Flag=true;int k=arr.length;while(Flag) {

Flag=false;for(int j=1;j

if(arr[j-1]>arr[j]) {

arr[j-1]^=arr[j];

arr[j]^=arr[j-1];

arr[j-1]^=arr[j];

Flag=true;

}

k--;

}

}/*** 冒泡排序方法2,从小到大

* 如果有100个数的数组,仅前面10个无序,后面90个都已经排好序了且大于前面10个数字

* 那么在第一趟遍历后,最后发生交换的位置必定小于10,且这个位置之后的数据必定已经

* 有序了,记录下这个位置,第二次只要从数组头部遍历到这个位置就可以了

*@paramarr 待排序数组*/

public void bubbleSort2(intarr[]) {//标记位置的标记位

int Flag=arr.length;intk;while(Flag>0) {

k=Flag;

Flag=0;for(int j=1;jarr[j]) {

arr[j-1]^=arr[j];

arr[j]^=arr[j-1];

arr[j-1]^=arr[j];//更新记录交换位置的变量Flag

Flag=j;

}

2.选择排序

classSelectSort {/*** 选择排序,从小到大

*@paramarr 待排序数组*/

public void selectSort(intarr[]) {int length=arr.length;//最小值的下标索引

intminIndex;for(int i=0;i

minIndex=i;for(int j=i+1;j

minIndex=j;

}

}if(minIndex!=i) {if(arr[minIndex]!=arr[i]) {

arr[minIndex]^=arr[i];

arr[i]^=arr[minIndex];

arr[minIndex]^=arr[i];

}

3.插入排序

classInsertSort {/*** 插入排序,从小到大

* 即每次arr[i]先和前面一个数据arr[i-1]比较,如果arr[i]>arr[i-1],说明arr[0...i]也是有序的,无须调整

* 否则就令j=i-1,temp=arr[i],然后一边将数据arr[j]向后移动一边向前搜索,当有数据arr[j]

* 并将temp放到arr[j+1]处

*@paramarr 待排序数组*/

public void insertSort(intarr[]) {int length=arr.length;int temp=0,j=0;for(int i=1;i

if(arr[i]

temp=arr[i];//向后移动

for(j=i-1;j>=0 && arr[j]>temp;j--) {

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

}

arr[j+1]=temp;

}

4.希尔排序

classShellSort {/*** 希尔排序,从小到大

* 希尔排序的实质就是分组插入排序,又称缩小增量排序

*@paramarr 待排序数组*/

public void shellSort(intarr[]) {//gap为步长

inti,j,gap;int length=arr.length;//步长

for(gap=length/2;gap>0;gap/=2) {//分组

for(i=0;i

for(j=i+gap;j=0 && arr[k]>temp) {

arr[k+gap]=arr[k];

k-=gap;

}

arr[k+gap]=temp;

}

5.堆排序

classHeapSort {/*** 堆排序,从大到小

*@paramarr 待排序数组*/

public void heapSort(intarr[]) {int length=arr.length;//建立最小堆

for(int i=length/2-1;i>=0;i--) {

heapAdjust(arr,i,length);

}//堆排序//构建小顶堆,排序的结果是由大到小

for(int i=length-1;i>=1;i--) {//将小顶堆的顶部arr[0]与arr[i]依次交换

if(arr[i]!=arr[0]) {

arr[i]^=arr[0];

arr[0]^=arr[i];

arr[i]^=arr[0];

}//重新构建小顶堆

heapAdjust(arr,0,i);

}

}/*** 堆调整

*@paramarr 待排序数组

*@parami 从i节点开始调整,从0开始计算,第i节点的子节点为2*i+1,2*i+2

*@paramn 节点总数*/

private void heapAdjust(int arr[],int i,intn) {//定义变量

intj,temp;

temp=arr[i];

j=2*i+1;while(j

if(j+1

j++;

}//不需要调整

if(arr[j]>=temp) {break;

}//把较小的节点往上移动,替换它的父节点

arr[i]=arr[j];

i=j;

j=2*i+1;

}

arr[i]=temp;

}

6.归并排序

classMergeSort {/*** 归并排序,从小到大

*@paramarr 待排序数组*/

public void mergeSort(intarr[]) {int length=arr.length;//创建一个和待排序数组同样大小临时数组

int temp[]=new int[length];//归并排序

merge_sort(arr, 0, length-1, temp);

}/*** 归并排序

*@paramarr 待排序数组

*@paramfirst 起始下标

*@paramlast 终点下标

*@paramtemp 临时数组*/

private void merge_sort(int arr[],int first,int last,inttemp[]) {if(first

merge_sort(arr, 0, mid, temp);//右边有序

merge_sort(arr, mid+1, last, temp);//再将两个有序数组合并

merge_array(arr, first, mid, last, temp);

}

}/*** 合并两个有序数组

*@paramarr 待排序数组

*@paramfirst 起始下标

*@parammid 中间下标

*@paramlast 终点下标

*@paramtemp 临时数组*/

private void merge_array(int arr[],int first,int mid,int last,inttemp[]) {int i=first,j=mid+1;int m=mid,n=last;int k=0;while(i<=m && j<=n) {if(arr[i]

temp[k++]=arr[i++];

}else{

temp[k++]=arr[j++];

}

}while(i<=m) {

temp[k++]=arr[i++];

}while(j<=n) {

temp[k++]=arr[j++];

}for(i=0;i

arr[first+i]=temp[i];

}

7.快速排序

import java.util.*;public classDemo9 {public static voidmain(String[] args) {//关于Java中生成特定区间里的随机数见http://blog.sina.com.cn/s/blog_59aebaa10100ct47.html//生成8000000个[1,9000000]之间的随机数

Random random=newRandom();int length=8000000;int arr[]=new int[length];for(int i=0;i

arr[i]=random.nextInt(9000000)+1;

}//快速排序

QuickSort qSort=newQuickSort();//关于统计程序运行时间见http://blog.csdn.net/uyu2yiyi/article/details/6267990//排序开始时间

long startTime=System.currentTimeMillis();

qSort.quickSort(arr);//排序结束时间

long endTime=System.currentTimeMillis();

System.out.println("快速排序时间为:"+(endTime-startTime)+"毫秒");

}

}classQuickSort {/*** 快速排序,从小到大

*@paramarr 待排序数组*/

public void quickSort(intarr[]) {