고전 정렬 자바 버 전

	public void sort(int[] arr){
		for(int i =0 ;i<arr.length -1 ;i++){
			for(int j = 0 ; j < arr.length -1 - i ; j++){
				int temp =0;
				if(arr[j] > arr[j+1]){
					temp = arr[j] ;
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}

public void sort(int[] arrs) {
		for (int i = 1; i < arrs.length; i++) {
			for (int j = i; j > 0 && arrs[j] < arrs[j - 1]; j--) {
				int temp =0;
				temp = arrs[ j] ;
				arrs[j] = arrs[j-1];
				arrs[j-1] = temp; 
			}
		}
	}

	public void sort(int[] arr){
		for(int i = 0 ; i < arr.length-1 ; i++){
			int temp = 0;
			for(int j =0;j<=arr.length -1 - i ;j++){
				if(arr[j] >= arr[temp]){
					temp = j;
				}
			}
			int t = arr[arr.length-1 -i] ;
			arr[arr.length -1- i] = arr[temp];
			arr[temp] = t;
		}
	}

public int AdjustArray(int s[], int l, int r){
	    int i = l, j = r;
	    int x = s[l]; //s[l] s[i]      
		while (i < j) {
			//        x    s[i]
			while (i < j && s[j] >= x)
				j--;
			if (i < j) {
				s[i] = s[j]; //  s[j]  s[i] ，s[j]         
				i++;
			}

			//           x    s[j]
			while (i < j && s[i] < x)
				i++;
			if (i < j) {
				s[j] = s[i]; //  s[i]  s[j] ，s[i]         
				j--;
			}
		}
		//    ，i  j。 x      。
		s[i] = x;
		return i;
	}
	//      
	void quick_sort1(int s[], int l, int r) {
		if (l < r) {
			int i = AdjustArray(s, l, r);//          s[]
			quick_sort1(s, l, i - 1); //     
			quick_sort1(s, i + 1, r);
		}
	}

private static void buildMaxHeapify(int[] data) {
		//               ，           
		int startIndex = getParentIndex(data.length - 1);
		//           ，        
		for (int i = startIndex; i >= 0; i--) {
			maxHeapify(data, data.length, i);
		}
	}

	/**
	 *      
	 * 
	 * @param data
	 * @param heapSize
	 *                      ，   sort     ，         ，           
	 * @param index
	 *                        
	 */
	private static void maxHeapify(int[] data, int heapSize, int index) {
		//            
		int left = getChildLeftIndex(index);
		int right = getChildRightIndex(index);

		int largest = index;
		if (left < heapSize && data[index] < data[left]) {
			largest = left;
		}
		if (right < heapSize && data[largest] < data[right]) {
			largest = right;
		}
		//             ，     ，             ，      
		if (largest != index) {
			int temp = data[index];
			data[index] = data[largest];
			data[largest] = temp;
			maxHeapify(data, heapSize, largest);
		}
	}

	/**
	 *   ，       ，data      ，          
	 * 
	 * @param data
	 */
	private static void heapSort(int[] data) {
		//       ，        
		for (int i = data.length - 1; i > 0; i--) {
			int temp = data[0];
			data[0] = data[i];
			data[i] = temp;
			maxHeapify(data, i, 0);
		}
	}

	/**
	 *      
	 * 
	 * @param current
	 * @return
	 */
	private static int getParentIndex(int current) {
		return (current - 1) >> 1;
	}

	/**
	 *     position     ，       
	 * 
	 * @param current
	 * @return
	 */
	private static int getChildLeftIndex(int current) {
		return (current << 1) + 1;
	}

	/**
	 *     position
	 * 
	 * @param current
	 * @return
	 */
	private static int getChildRightIndex(int current) {
		return (current << 1) + 2;
	}

	private static void print(int[] data) {
		int pre = -2;
		for (int i = 0; i < data.length; i++) {
			if (pre < (int) getLog(i + 1)) {
				pre = (int) getLog(i + 1);
				System.out.println();
			}
			System.out.print(data[i] + " |");
		}
	}

	/**
	 *  2     
	 * 
	 * @param param
	 * @return
	 */
	private static double getLog(double param) {
		return Math.log(param) / Math.log(2);
	}