자바 서언 의 배열 정렬 (거품, 선택, 2 분 찾기)

배열
1 차원 배열 과 2 차원 배열 및 다 차원 배열 을 정의 합 니 다.
1 차원: int [] array = new int [];    int [ ] array = { };   int [ ] array = new int [ ] { };이런 글 씨 는 배열 요소 의 수 를 채 울 수 없다.
2 차원: int [] array = new int [] [];int [ ] [ ] array = { { },{ },{ } }; int [ ] [ ] array = new int [ ] [ ]{ { }, { },{ }};배열 요소 수 를 쓸 수도 없고.
색인 에 따라 배열 의 요 소 를 찾 습 니 다.
수요: 사용자 가 입력 한 1 에 따라 1, 입력 한 2, 2 로 돌아 갈 수 있 습 니 다.
사고: 기 존의 조건 (색인, 배열), 배열 요소 출력 문 구 를 직접 이용 하여 배열 에 대응 하 는 요 소 를 구 합 니 다.
코드 구현:

	public static char fanhui(int a) {
		char []print= {' ',' ',' ',' ',' ',' ',' '};
		return print[a-1];
	}

제 공 된 배열 의 요소 에 따라 색인 을 찾 습 니 다.
필요: 배열 int [] array = {1, 2, 3, 4} 이 있 습 니 다. 배열 에 있 는 3 개의 각 표 위 치 를 구 합 니 다.
분석: 이 기능 을 함수 로 봉 하여 배열 과 찾 을 요 소 를 매개 변수 로 입력 하면 찾 을 수 있 습 니 다.
코드 구현:

	public static int weizhi(int n,int []a) {
		//      ，index    
		//         ，           ，      ，            
		int index = -1;
		for(int x=0;x

소결: 코드 중 int index = - 1;return index；빈 배열 의 상황 을 방지 할 수 있다.
배열 자체 요소 의 반전
수요: int [] array = {1, 4, 2, 5, 3, 6};이 배열 의 반전 을 실현 하 다.
분석: 배열 길이 의 중간 값 을 취하 고 이 중간 값 을 조건 으로 For 순환 에서 배열 을 반전 시 킬 수 있 습 니 다.

	public static void change(int[] array) {
		int number = array.length / 2;
		for (int x = 0; x < number; x++) {
			 int c;
			 c = array[x];
			 array[x] = array[array.length - 1 - x];
			 array[array.length - x - 1] = c;
			//          ，       ，           （        ）
			//kk(array[x], array[array.length - 1 - x]);
		}
		System.out.println(Arrays.toString(array));
	}

소결: 여기 서 두 개의 수 치 를 교환 할 때 이 기능 을 패키지 하 는 함 수 를 호출 할 수 없습니다. 두 함 수 는 스 택 의 서로 다른 공간 이기 때문에 다른 함수 에서 수치 교환 은 다른 함수 에 영향 을 주지 않 습 니 다.
배열 의 거품 정렬
정의: 배열 에 인접 한 두 요소 간 비교
핵심: 인접 한 원소 비교
분석: 거품 정렬 의 결 과 는 오름차 순 입 니 다. 매번 에 마지막 비트 의 최대 치 를 얻 을 수 있 고 외부 순환 으로 비교 하 는 횟수 를 제어 할 수 있 습 니 다. 내부 순환 으로 모든 비교 횟수 를 제어 할 수 있 습 니 다.
코드 구현:

	public static void sort(int []a) {
		for(int x = 0; x < a.length-1; x++) {
			for( int y = 0; y a[y+1] ) {
					int c = a[y];
					a[ y ] = a[y+1];
					a[ y + 1] =  c;
				}
			}
		}
	}

분석: 외부 순환 중: 배열 의 첫 번 째 수 는 자신 과 비교 할 필요 가 없 기 때문에 비교 횟수 는 x = a. length - 1 이다.
           내부 순환 중: - 1: 1 을 추가 하지 않 을 때 a [y] 는 a. length - 1 을 얻 을 수 있 습 니 다. 그러면 a [y + 1] = a. length 는 오류 가 발생 합 니 다.
                             -x: 매번 순환 하 는 횟수 가 감소 하고 감소 하 는 값 은 매번 외부 순환 하 는 x 의 크기 입 니 다.
배열 선택 정렬
정의: 배열 의 모든 요소 와 그 후의 모든 요 소 를 비교 합 니 다.
분석: 정렬 을 선택 하 는 것 은 오름차 순 입 니 다. 매번 순환 할 때마다 첫 번 째 위치의 최소 값 을 얻 을 수 있 습 니 다. 외부 순환 으로 순환 누 워 있 는 수 를 제어 하고 내부 순환 으로 모든 비교 횟수 를 제어 합 니 다.
코드 구현:

	public static void main(String[] args) {
		int []num= {1,3,4,32,2,43,5};
		//x

소결: 외부 순환 중: - 1: 마지막 수 는 자신 과 비교 하지 않 아 도 되 기 때문에 비교 횟수 는 x = num. length - 1 이다.
           내부 순환 중: x + 1: 매번 내부 순환 은 비교 요소 뒤의 요소 에서 순서대로 뒤로 비교 합 니 다.
배열 의 절반 찾기
정의: 하나의 수 를 정 하고 배열 에서 찾 습 니 다. 배열 중간 에 있 는 커서 가 속 한 수치 와 계속 비교 하여 범 위 를 좁 히 고 결 과 를 빨리 얻 을 수 있 습 니 다.
구현 코드:

		int min = 0;
		int max = array.length-1 ;
		int mid = (max + min) / 2;
		//       
		int key = 11;
		//    ，           
		//     while  ？                   
		//key         ，        
		while(key != array[mid]) {
			if(key > array[mid]) {
				min = mid + 1;
			}else if(key < array[mid]) {
				max = mid-1;
			}
			//       
			//     max=min,         
			mid = ( max+min )/2;
			
			//          ，      ，           
			if(min>max) {
				//          
				mid = -1;//         
				break;
			}
		}
		System.out.println("  "+mid);

2 차원 배열
명명 규범: int [] [] array = new int [x] [y];  int [ ] [ ] array={ { },{ },{ }};
이상 의 명명 방식 중 하나: x: 2 차원 배열 의 1 차원 배열 갯 수 를 대표 합 니 다: 각 1 차원 배열 의 요소 갯 수 를 대표 합 니 다.
필요: 2 차원 배열 옮 겨 다 니 기
코드 구현:

		System.out.println(array1.length);//               
		for(int x=0; x