소 담 대열

소 담 대열
 
배열 은 저장 과 접근 속도 가 가장 빠 른 데이터 구조 이지 만 생 성 시 길이, 저장 유형 이 고정 적 으로 제한 되 어 있 습 니 다.이 를 위해 우 리 는 동적 으로 데 이 터 를 저장 하 는 데이터 구조 인 대기 열 을 도입 합 니 다.대열 에 대해 말하자면 실제 생활 에는 식당 에서 요 리 를 하 는 학생, 슈퍼마켓 에서 계산 을 기다 리 는 고객, 극장 에서 줄 을 서서 표를 사 는 관객 들 이 적지 않다. 현실 생활 에 서 는 항상 줄 을 서 는 현상 이 존재 한다.우리 가 대기 열 을 컴퓨터 로 옮 기 고 JAVA 프로그램 으로 옮 길 때, 우 리 는 대기 열의 특성 을 찾 아야 한다.
줄 을 설 때마다 사람들 은 스스로 뒤에서 대열 에 들어간다. 물론 새치기 를 좋아 하지 않 고 다른 사람 이 싫어 하 는 시선 을 개의 치 않 는 사람들 도 있다.보통 가장 먼저 줄 을 서 는 사람 이 가장 먼저 업무 처 리 를 받 고 처리 가 끝나 면 대열 을 나 가 고 중간 에 일이 있어 서 팀 에서 물 러 나 는 인물 도 있다.이러한 특성 을 발견 하고 우 리 는 기본적으로 대열 의 몇 가지 일반적인 방법 을 명 확 히 했다.다음은 대열 의 배열 구현 코드 입 니 다.

import java.util.Arrays;


/**
 *          ，       
 * @author Daily
 *
 */
public class MyQueque <E>{
	//      
	private int size;			//     
	private Object [] array;	//     
	
	/**
	 *    MyQueque      （      ）
	 */
	public MyQueque(){
		
	}

	/**
	 *    MyQueque      （    ，      ）
	 *  @param ob	      
	 */
	public MyQueque(E ob){
		add(ob);
	}
	
	/**
	 * 	    
	 *            （                  ）
	 * @param ob	      
	 */
	public void add(E ob){
		//         
		Object [] newarray = new Object[size+1];
		//        size-1   
		for (int i=0; i < size; i++){
			newarray[i] = array[i];
		}
		newarray[size] = ob;
		// size  1   
		size++;
		//                    
		array = newarray;
	}
	
	/**
	 *            （          ）
	 * @param index	     
	 * @param ob	      
	 */
	public boolean add(int index, E ob){
		if (index > size){
			return false;
		}
		//         
		Object [] newarray = new Object[size+1];
		//        size-1   
		for (int i=0; i < index; i++){
			newarray[i] = array[i];
		}
		newarray[index] = ob;
		for (int i=index+1; i<size+1; i++){
			newarray[i] = array[i-1];
		}
		// size  1   
		size++;
		//                    
		array = newarray;
		return true;
	}
	
	/**
	 *        （            ）
	 * @return		     
	 */
	public E delete(){
		//         
		Object [] newarray = new Object[size-1];
		//        size-1   
		for (int i=1; i < size; i++){
			newarray[i-1] = array[i];
		}
		Object copy = array[0];
		// size  1   
		size--;
		//                    
		array = newarray;
		//        
		return (E)copy;
	}
	
	/**
	 *          ，    
	 * @param index	    
	 * @return		     
	 */
	public E delete(int index){
		if (index > size || index < 0){
			return null;
		}
		//         
		Object [] newarray = new Object[size-1];
		if (size-1>0){
			//        size-1   
			for (int i=0; i < size-index; i++){
				newarray[i] = array[i];
			}
			for (int i=index+1; i<size; i++){
				newarray[i-1] = array[i];
			}	
		}
		Object copy = array[index];
		// size  1   
		size--;
		//                    
		array = newarray;
		//        
		return (E)copy;
	}
	
	/**
	 *       ，        （PS：  Integer      ，                )
	 * @param ob	      
	 * @return		      
	 */
	public boolean delete(E ob){
		int count = 0;
		boolean bl = false;
		for (int i=0; i<size; i++){
			if (array[i].equals(ob)){
				count++;
				bl = true;
			}
		}
		//         
		Object [] newarray = new Object[size-count];
		int u=0;
		//        size-1   
		for (int i=0; i < size; i++){
			if (!array[i].equals(ob)){
				newarray[u] = array[i];
				u++;
			}
		}
		// size  count   
		size = size -count;
		//                    
		array = newarray;
		//             
		return bl;
	}
	
	/**
	 *            
	 * @param index	       
	 * @param ob	     
	 * @return		      
	 */
	public boolean modify(int index,E ob){
		array[index] = ob;
		return true;
	}
	
	/**
	 *            
	 * @param index	       
	 * @return		      
	 */
	public E get(int index){
		return (E)array[index];
	}
	
	/**
	 *             
	 * @param index	       
	 * @return		      
	 */
	public int [] get(Object ob){
		int count = 0; 
		for (int i=0; i<size; i++){
			if (array[i].equals(ob)){
				count++;
			}
		}
		int [] flag = new int [count];
		int u=0;
		for (int i=0; i<size; i++){
			if (array[i].equals(ob)){
				flag[u] = i;
				u++;
			}
		}
		return flag;
	}
	
	/**
	 *         
	 * @return	     
	 */
	public int getSize(){
		return size;
	}
	
	/**
	 *         
	 * @return	        
	 */
	public E [] getSort(){
		Arrays.sort(array);
		return (E[])array;
	}
}

 PS: 모든 유형 이 Object 형식의 하위 클래스 이기 때문에 요 소 를 넣 어 Object 형식의 대상 으로 정의 하여 배열 이 서로 다른 유형의 기능 을 저장 할 수 없 도록 합 니 다.대기 열 은 한 요 소 를 추가 하거나 삭제 할 때마다 해당 데 이 터 를 저장 하 는 배열 을 새로 만들어 데이터 의 동적 저장 을 실현 합 니 다.대기 열 에 있 는 모든 데 이 터 를 같은 유형 으로 규정 하기 위해 서 나 는 범 형 을 사용 했다.