JAVA中数组、链表实现的队列的增加，返回长度，插入，删除

JAVA中数组、链表实现的队列的增加，返回长度，插入，删除

 

数组：

 

数组是java中最基本的一中数据结构，数组一旦定义，它的长度就是固定的。数组也是一种对象，数组的对象本身的类型就是数组类型。定义数组时，一定要知名组中元素的类型。

 

数组有三种定义方式：

 

1.定义时指定数组长度，这样会使内存空间创建数组对象，但数组中每个位置的元素是默认值。原始类型，则为0，引用类型，则为null。

2.创建数组的时候就转给元素赋值。

3.仅定义一个数组变量名，然后来赋值。

 

Eg1： int[]  ia = new int[10];

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

  ia[i]=i*100;}

Eg2: //仅定义了一个int类型的数组变量并没有指向数组对象，这时ia的值null

      int[] ia;

//将数组变量名指向一个数组对象，数组中的每个位置默认值是0

  ia= new int[5];

//字符串数组，定义时数组中的原值赋值

  String[] sa = new String[]{“apple”,”orange”,”pineapple”};

 

用数组实现的队列 ：

/**  
 * 定义一个数组转化为的队列  
 */  
public class Array{   
    private int length=100;   
    private int add=20;   
    int count=0;   
       
// 用于传递数组初始长度和每次增加长度的构造器  
   
    public Array(int length,int add){   
        this.length=length;   
        this.add=add;   
    }   
       
 
//初始化数组   
    Object[] str = new Object[length];    
       
// 向数组中添加元素  
  
    public void add(E e){   
        count++;   
        if(count>str.length){   
            Object[] tem= new Object[str.length+add];   
            str=tem;   
        }   
        str[count-1]=e;   
    }   
       
// 获得数组长度
  
    public int size(){   
        return count;   
    }   
       
//  向数组中插入元素  
 
    public void insert(int index,E e){   
        if(index>count||index<0){   
            System.out.println("下角标越界");   
            return;   
        }    
        for(int i=count-1;i>=0;i--){   
            if(i!=index-1){   
             str[i+1]=str[i];   
                continue;   
            }   
            str[index]=e;   
            count++;   
            return;   
        }   
    }   
       
// 删除数组中指定的元素  

    public void delete(int index){   
        if(index>count||index<0){   
            System.out.println("下角标越界");   
            return;   
        }    
        for(;index<count;index++){   
            initstr[index]=initstr[index+1];   
        }   
        count--;   
    }           
}  

 

链表：

     链表是一种物理存储单元上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现。相对于线性表顺序结构，链表比较放表插入和删除。

      队列也是一个存放东西的容器。但队列的使用比数组、链表更加灵活。一个完善的队列可以很方便的实现添加、删除、更改、获得长度、插入、查找等操作。因此通过把数组和链表转化为队列，可以实现对数组和链表的优化，增强其实用性。

 

一个简单链表的实现首先定义一个结点类：

 

/**
 * 定义一个结点类
 */
public classMyNode {

	private E data;
	private MyNode next;
	
	public void setdata(E e){
		this.data=e;
	}
	
	public void setnext(MyNode next){
		this.next=next;
	}
	
	public E getdata(){
		return data;
	}
	
	public MyNode getnext(){
		return next;
	}
}

 

 

 

 

 

定义一个以链表为基础的队列

 

 

 

 

 

/**  
 * 定义一个以链表为基础的队列  
 */  
public class LinkList{   
   
    MyNode root;   
    private MyNode last;   
       
    public void setroot(MyNode e){   
        root=e;   
    }   
       
//  向链表中添加元素  
 
    public void add(E e){   
        if(root==null){   
            root=new MyNode();   
            root.setdata(e);   
            last=root;   
        }else{   
            MyNode tem=new MyNode();   
            tem.setdata(e);   
            last.setnext(tem);   
            last=tem;   
        }   
    }   
       
// 获得链表的长度  
    public int size(){   
        if(root!=null) {   
            int t=1;   
            MyNode tem=root.getnext();   
            while(tem!=null){   
                tem=tem.getnext();   
                t++;   
            }   
            return t;   
        }   
        return 0;   
    }   
       
//  在指定位置插入结点  
    public void insert(int index,E e){   
       MyNode newNode=new MyNode();   
        if(index==1){   
            newNode.setdata(e);   
            newNode.setnext(root);   
            root=newNode;   
        }else{   
            MyNode  tem=root;   
            for(int i=2;i<index;i++){   
                tem=tem.getnext();   
            }   
            newNode.setdata(e);   
            newNode.setnext(tem.getnext());   
            tem.setnext(newNode);   
        }   
           
    }   
       
// 删除指定位置的结点  
    public void delete(int index){   
        if(index==1) root=root.getnext();   
        else{   
            MyNode tem=root;   
            for(int i=2;i<index;i++){   
                tem=tem.getnext();   
            }   
            tem.setnext(tem.getnext().getnext());   
        }   
    }          
}  

 

 

 

so,that's all.thank you for browsing!