数组是一种在内存中连续分布的数据结构,很方便存储和取出。
java中一维数组定义几种格式如下:(直接赋值时就不能规定长度)
1.数据类型 [] 数组名 = {值,....};
2.数据类型 [] 数组名 = new 数据类型[长度];
3.数据类型 [] 数组名;
数组名 = new 数据类型[长度];
4.数据类型 [] 数组名;
数组名 = new 数据类型[]{值,...};
类似的,二维数组格式如下:
1.数据类型 [][] 数组名 = {{值,....},...};
2.数据类型 [][] 数组名 = new 数据类型[行][列];
3.数据类型 [][] 数组名;
数组名 = new 数据类型[行][列];
4.数据类型 [][] 数组名;
数组名 = new 数据类型[][]{{值,...},...};
我们可以用一些算法对数据进行排序,常见的几种算法原理和代码如下:
//冒泡法从小到大排列:首先将第一个元素与后面所有元素比较,
//若第一个元素小则互换元素,这样就把最小的元素放在第一个位置,
//后面第n个位置依次方法可获取到倒数第n小的元素
public int [] maopao(int array[]){
System.out.print("冒泡排序(从小到大): ");
for(int i=0;i<array.length;i++){
for(int j=i+1;j<array.length;j++){
int temp;
if(array[i]>array[j]){
//互换两位置元素
temp=array[j];
array[j]=array[i];
array[i]=temp;
}
}
}
return array;
}
//选择排序从大到小排序:找出元素中的最大值与第一个元素互换,倒数第二大的元素
//与第二个元素互换,依次下去
public int [] xuanze(int array[]){
System.out.print("选择排序(从大到小): ");
for(int i=0;i<array.length;i++){
int max=array[i];
int num=i;
for(int j=i+1;j<array.length;j++){
if(array[j]>max){
max=array[j];
num=j;
}
}
array[num]=array[i];
array[i]=max;
}
return array;
}
//插入排序:即在一个已知有序排列的数字中,依次插入每个数字
//可以先把第一个数字和第二个数字先排成有序的,后面的数字依次插入;
//以下方法从小到大;
public int [] charu(int array[]){
System.out.print("插入排序(从小到大): ");
//数组长度小于2时
if(array.length<2){
return array;
}
//先将前面两个数据排好序
else if(array[0]>array[1]){//
int temp=array[0];
array[0]=array[1];
array[1]=temp;
}
//后面的依次插入
for(int i=2;i<array.length;i++){
int tem=array[i];
//插入的数字比第一个数字小时
if(tem<array[0]){
for(int k=i;k>0;k--){
array[k]=array[k-1];
}
array[0]=tem;
}
else {
//插入的数字比最后一个数字大时
if(tem>array[i-1]){
array[i]=tem;
}
else {
插入的数字处于中间位置
for(int j=0;j<i;j++){
if(tem>=array[j]&&tem<=array[j+1]){
//把第j+1之后的数字往后推一位
for(int k=i;k>j+1;k--){
array[k]=array[k-1];
}
array[j+1]=tem;
break;
}
}
}
}
}
return array;
}
//希尔排序: 设定一定间距增量gap,每gap个抽出来排序,
//然后减小gap,再按gap抽出数据排序,直到gap为1位置
public int [] hill(int array []){
System.out.print("希尔排序(从大到小): ");
int length=array.length ;
for(int gap=length/2;gap>0;gap=gap/2){
int flag;
do{//直到相应gap间距的数字已排好序,flag不为1结束
flag=0;
for(int i=0;i<length-gap;i++){
int j=i+gap;
int temp;
if(array[j]>array[i]){
temp=array[j];
array[j]=array[i];
array[i]=temp;
flag=1;
}
}
}while(flag==1);
}
return array;
}
我们可i以创建一个动态数组(自定义队列),就可以弥补数组一旦定义长度固定不能改变的缺点。
其中用到了泛型,可以使动态数组只能添加指定数据类型。
以下是自定义队列接口:
//E就表示泛型,泛型实际上表示的是泛指Java中任意的一种数据类型,
//如果指定了对应的数据类型,那么就只能存储该种数据类型的数据
public interface Mylist<E> {
public void add(E e);
public void add(E e,int index);
public boolean remove(int index);
public boolean remove(E e);
public Object get(int index);
public int size();
}
然后定义一个接口类,实现方法:
//自定义队列接口类
public class MyListImp<E> implements Mylist<E>{
//定义一个属性,用来存储元素的总数
private int size=0;
//定义一个属性,用来存储数据的数组
private Object array [];
public MyListImp(){
array = new Object[0];
}
@Override//在动态数组后添加一个对象
public void add(E e) {
Object temp []=new Object[array.length +1];
for(int i=0;i<array.length;i++){
temp[i]=array[i];
}
temp[array.length]=e;
size++;
array=temp;
}
//在指定索引位置添加对象
public void add(E e, int index) {
// TODO Auto-generated method stub
Object [] temp = new Object [size+1];
for(int i=0;i<index;i++){
temp[i]=array[i];
}
for(int i= index;i<size;i++){
temp[i+1]=array[i];
}
size++;
temp[index]=e;
array=temp;
}
//移除索引位置的对象
public boolean remove(int index) {
// TODO Auto-generated method stub
System.out.println(size);
Object [] temp = new Object [size-1];
if(index<0||index>=size)
return false;
else {
for(int i=0;i<index;i++){
temp[i]=array[i];
}
for(int i= index+1;i<size;i++){
temp[i-1]=array[i];
}
size--;
array=temp;
return true;
}
}
//移除某个对象
public boolean remove(E e) {
// TODO Auto-generated method stub
for(int i=0;i<size;i++){
if(this.get(i).equals(e)){
//这里调用了移除索引位置方法
this.remove(i);
return true;
}
}
return false;
}
//得到索引位置所在对象
public Object get(int index) {
// TODO Auto-generated method stub
if(index<0||index>=size){
return null;
}
return array[index];
}
//得到动态数组的元素个数,即长度
public int size() {
// TODO Auto-generated method stub
size=array.length ;
return size;
}
}
编程基础不太好,如有概念等错误欢迎指导!