java排序方法

public class Sort {
	
	private static int[] data = new int[] {100,33,1,25,13,56,14,21,6,17,1};
	
	public static void main(String[] args) {
		
		shellSort();
		System.out.println(Arrays.toString(data));
		
		
		
	}
	
	
	/**
	 *  简单选择排序 每一次取得最小值 然后进行交换
	 */
	public static void select_sort() { 
		int min = 0;
		int length = data.length;
		
		for(int i=0;i<length;i++) {
			min = i;
			for(int j = i+1;j<length ;j++) {
				if(data[min] > data[j]) {
					min = j;
				}
			}
			if(i != min) {
			   int temValue = data[min];
			   data[min] = data[i];
			   data[i] = temValue;
			   
			}
		}
		
	}
	
	/**
	 *  直接插入排序  如果后面的数 小于前面的数 就开始就行比较 然后赋值 
	 * 
	 */
	public static void insertSort() { 
	
		int length = data.length;
		int j =0;
		int temp = 0;
		for(int i=1;i<length;i++) {
			if(data[i] < data[i-1] ) {
				temp = data[i];
				// 例如：4 5 1  当temp =1 ；j = 2-1= 1； a[1] = 5; 5大于 1 所以数组为 4 5 5这时 a[2] 已经移了一位 并且把5的数 赋给了a[1] 
				//然后进行比较 a[0]= 4 大于 1 所以 把a[0]的值 给ap[1] ，数组为 4 4 5，最后让 a[0]赋值temp 即安排原a[2]的值
				for( j = i-1;j>=0&&data[j]>temp;j--) {
					data[j+1] = data[j];
				}
				data[j+1] = temp;
			}
		}
		
	}
	
	

	
	
	/**
	 * 希尔排序 每次通过增量来进行排序  每次比较的值都是 a[0]  a[0+d] ,a[1] a[1+d] ...进行比较 ，最后一次 increment =1 就是插入排序了
	 */
	public static void shellSort() {
		int length = data.length;
		int temp = 0;
		int j = 0;
		for(int increment = length /2;increment > 0; increment /=2) {
			System.out.println("increment:"+increment);
			for(int i=increment;i<data.length;i++) {
				temp = data[i];
				for(j =i-increment;j>=0; j -=increment) {
					if(temp < data[j]) {
						data[j+increment] = data[j];
					}else {
						break;
					}
				}
				data[j+increment] = temp;
			}
			
		}
		
		
	}
	
}

堆排序

public class HeapSort {
    private static void heapSort(int[] arr) {
        int len = arr.length -1;
        //int i = (len-1)/2 得到节点 这个是根据 完全二叉树的性质来决定的
        //int i = (len-1)/2 ; i >=0; i -- 这个意思寻找没一个节点的父节点
        //通过左节点 右节点 父节点 3个互相比较 最大的为父节点 
        for(int i = (len-1)/2 ; i >=0; i --){ //堆构造
            heapAdjust(arr,i,len);
        }
        System.out.println("\n排序之后：");
        for(int element : arr){
            System.out.print(element+" ");
        }
        
        while (len >=0){
            swap(arr,0,len--);    //将堆顶元素与尾节点交换后，长度减1，尾元素最大  每次替换后的元素 不会再参加排序
            heapAdjust(arr,0,len);    //再次对堆进行调整
        }
        
    }
 
public static  void heapAdjust(int[] arr,int i,int len){
    int left,right,j ;
    //根据完全二叉树的性质 来算出 左右节点 因为完全二茶树 按照层序编号 如果没有左节点 就肯定没有右节点
    while((left = 2*i+1) <= len){    //判断当前父节点有无左节点（即有无孩子节点，left为左节点）
        right = left + 1;  //右节点
        j = left;   //j"指针指向左节点"
        if(right <= len && arr[left] < arr[right])    //右节点大于左节点
            j ++;     //当前把"指针"指向右节点
        if(arr[i] < arr[j])    //将父节点与孩子节点交换（如果上面if为真，则arr[j]为右节点，如果为假arr[j]则为左节点）
            swap(arr,i,j);
        else         //说明比孩子节点都大，直接跳出循环语句
            break;
        i = j; //哪一个节点换了   就把该节点 当做父节点 如何保证 左节点 右节点 父节点  最大的为父节点 
    }
}
    public static  void swap(int[] arr,int i,int len){
             int temp = arr[i];
              arr[i] = arr[len];
             arr[len] = temp;
    }
    public static void main(String[] args) {
        int array[] = {20,50,20,40,70,10,80,30,60,30};
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element+" ");
        }
        heapSort(array);
        System.out.println("\n排序之后：");
        for(int element : array){
            System.out.print(element+" ");
        }
    }
}

归并排序

public class MyMergeSort {
	public static void main(String[] args) {
		  int []arr = {9,8,7,15,23,4,120,2,1,23,43,67,434};
		  sort(arr,0,arr.length-1);
		  System.out.println(Arrays.toString(arr));
	}
	
	public static void sort(int[] data,int start,int end) {
		if(start < end) {
			int mid = (start + end) /2;
			sort(data,start,mid);//用递归进行分组
			sort(data,mid+1,end);//用递归进行分组
			//每次比较直 然后进行排序
			merge(data,start,mid,mid+1,end);
			
		}
	}
	
	public  static void merge(int[] data,int start1,int end1,int start2,int end2) {
		int[] tem1 = new int[data.length]; 
		int j = 0;
		int begin = start1;
		int end = end2;
		//把2遍的值进行一一比较 因为一开始是1个值 和1个值 进行比较 所以比较的2个数组是有序的
		while(start1 <= end1 && start2 <= end2) {
			if(data[start1] > data[start2]) {
				tem1[j++] = data[start2++];
			}else {
				tem1[j++] = data[start1++];
			}
		}
		//因为数组有序，如果 还有数据 依次添加
		while(start1 <= end1) {
			tem1[j++] = data[start1++];
		}
		//因为数组有序，如果 还有数据 依次添加
		while(start2 <= end2) {
			tem1[j++] = data[start2++];
		}
		//进行赋值
		j = 0;
		for(int i=begin ;i<=end;i++) {
			data[i] = tem1[j++];
		}
		
	}
	
}

快速排序

public class MyQuickSort {
	
	public static void main(String[] args) {
		
		int i;
        int a[] = { 30, 40, 60, 10, 20, 50,33,45,28,23,50,0,1,1,0,100,23,45,87 };

        System.out.printf("before sort:");
        for (i = 0; i < a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");

        sort(a, 0, a.length - 1);

        System.out.printf("after  sort:");
        for (i = 0; i < a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");
		
	}
	
	public static void sort(int[] data,int start,int end) {
		
		if(start < end) {
			int left = start;
			int right = end;
			int compareValue = data[start];
			while(left < right) {
				//从左边寻找小于compareValue1的值
				while(right > left && data[right] > compareValue ) {
					right--;
				}
				if(right > left) {
					//和左边的数据进行交换
					data[left++] = data[right];
				}
				//在右边寻找大于compareValue的值
				while(left < right && data[left] < compareValue) {
					left++;
				}
				
				if(left < right) {
					//和右边的数据 进行交换 ，如果没有进行交换数据 那么data[right]一开始的数据 就重复了
					//在上面的条件left < right可以看出 此时 left = right的
					//所以下面data[right] = compareValue 用来赋值 保证数据的正确性
					data[right--] = data[left];
				}
			
			}
			data[right] = compareValue;
		
			sort( data, start, right-1) ;
			sort( data, right+1, end) ;
		}
		
	}
	
}