排序算法 JAVA

                                                     

插入排序：

public class InsertionSort {
	int[] arr;
	public InsertionSort(int[] arr){
		this.arr = arr;
	}
	
	public void Sort(){
		int i,j,key;
		for(i=1;i<arr.length;i++){
			key = arr[i];
			j=i-1;
			//arr[j]比当前值大时，向后移动一位
			while(j>=0&&arr[j]>key){
				arr[j+1]=arr[j];//arr[j]值后移
				j--;//j前移
			}
			arr[j+1]=key;//将当前值插入
			printArr(arr);
		}
		
	}
}

希尔排序：

public class ShellSort {
	int[] arr;
	public ShellSort(int[] arr){
		this.arr =arr;
	}
	
	public void Sort(){
		int len = arr.length;
		for(int gap=len/2;gap>0;gap/=2){
			for(int i=gap;i<len;i++){
				for(int j=i-gap;j>=0;j-=gap){
					int key = arr[j];
					if(key>arr[j+gap]){
						arr[j] = arr[j+gap];
						arr[j+gap] = key;
					}
				}
			}
		}
		printArr(arr);
	}	
}

冒泡排序：

public class BubbleSort {
	int[] arr;
	public BubbleSort(int[] arr){
		this.arr = arr;
	}
	
	public void Sort(){
		int i,j;
		for(i=0;i<arr.length;i++){
			for(j=arr.length-2;j>=i;j--){
				if(arr[j]>arr[j+1]){
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		printArr(arr);
	}
	//
	public void Sort_Improve(){
		int i,j;
		boolean flag = true;
		for(i=0;i<arr.length && flag;i++){
			flag=false;
			for(j=arr.length-2;j>=i;j--){
				if(arr[j]>arr[j+1]){			
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
					flag = true;
				}
			}
		}
		printArr(arr);
	}
}

选择排序：

public class SelectionSort {
	int[] arr;
	public SelectionSort(int[] arr){
		this.arr =arr;
	}
	
	public void Sort(){
		int i,j,min;
		for(i=0;i<arr.length-1;i++){
			min = i;
			for(j=i+1;j<arr.length;j++){
				if(arr[min]>arr[j]){
					min=j;
				}
			}
			if(i!=min){
				int temp = arr[min];
				arr[min]=arr[i];
				arr[i]=temp;			
			}
		}
		printArr(arr);
	}
  }

快速排序：

public class QuickSort {
	public void Sort(int[] arr,int low,int high){
		int l = low;
		int h = high;
		int povit= arr[low];
		while(l<h){
			while(l<h&&arr[h]>=povit)
				h--;
			if(l<h){
				int temp = arr[h];
				arr[h] = arr[l];
				arr[l] = temp;
				l++;
			}
			while(l<h&&arr[l]<=povit)
				l++;
			if(l<h){
				int temp = arr[h];
				arr[h]=arr[l];
				arr[l]=temp;
				h--;
			}
			if(l>low)Sort(arr,low,h-1);
			if(h<high)Sort(arr,l+1,high);
		}
		
		printArr(arr);
	}
}

堆排序：

public class HeapSort {
	int[] arr;
	int heapsize;
	
	public int partent(int i){
		return i/2;
	}
	
	public int leftchild(int i){
		return 2*i;
	}
	
	public int rightchild(int i){
		return 2*i+1;
	}
	
	public HeapSort(int[] arr){
		this.arr = arr;
		this.heapsize = arr.length;
	}
	
	public void max_heapify(int[] arr,int i){
		int leftchild = leftchild(i);
		int rightchild = rightchild(i);
		int largest = 0;
		if(leftchild<heapsize&&arr[i]<arr[leftchild]){
			largest = leftchild;
		}else{
			largest = i;
		}
		if(rightchild<heapsize&&arr[largest]<arr[rightchild]){
			largest = rightchild;
		}
		if(largest == i){
			return;
		}else{
			int temp = arr[i];
			arr[i] = arr[largest];
			arr[largest] = temp;
			max_heapify(arr,largest);
		}
	}
	
	public void build_max_heap(int[] arr){
		for(int i=arr.length/2;i>=1;i--){
			max_heapify(arr,i);
		}
	}
	
	public void Sort(){
		build_max_heap(arr);
		printArr(arr);
		for(int i =arr.length-1;i>=1;i--){
			int temp = arr[0];  
	        arr[0] = arr[i];  
	        arr[i] = temp;
	        heapsize--; 
	        max_heapify(arr, 0);  
	        printArr(arr);
		}
		printArr(arr);
	}
}

归并排序：

public class MergeSort {	
    public int[] sort(int[] nums, int low, int high) {  
        int mid = (low + high) / 2;  
        if (low < high) {  
            // 左边  
            sort(nums, low, mid);  
            // 右边  
            sort(nums, mid + 1, high);  
            // 左右归并  
            merge(nums, low, mid, high);  
        }  
        return nums;  
    }  
  
    public void merge(int[] nums, int low, int mid, int high) {  
        int[] temp = new int[high - low + 1];  
        int i = low;// 左指针  
        int j = mid + 1;// 右指针  
        int k = 0;  
  
        // 把较小的数先移到新数组中  
        while (i <= mid && j <= high) {  
            if (nums[i] < nums[j]) {  
                temp[k++] = nums[i++];  
            } else {  
                temp[k++] = nums[j++];  
            }  
        }  
  
        // 把左边剩余的数移入数组  
        while (i <= mid) {  
            temp[k++] = nums[i++];  
        }  
  
        // 把右边边剩余的数移入数组  
        while (j <= high) {  
            temp[k++] = nums[j++];  
        }  
  
        // 把新数组中的数覆盖nums数组  
        for (int k2 = 0; k2 < temp.length; k2++) {  
            nums[k2 + low] = temp[k2];  
        }  
    }  
}