java面试中的各种排序

插入排序

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[]  nums={2,5,3,2,1};
		insertSort(nums);
		for(int tmp:nums){
			System.out.println(tmp);
		}
	}
	//稳定的排序
	public static void insertSort(int[] nums){
		int i,j;
		for( i=0;i<nums.length;i++){
			int tmp=nums[i];
			for(j=i;j>0&&tmp<nums[j-1];j--){
				nums[j]=nums[j-1];
			}
			nums[j]=tmp;
		}
	}
	public static void swap(int[] nums,int a,int b){
		int tmp=nums[a];
		nums[a]=nums[b];
		nums[b]=tmp;
	}

希尔排序

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[]  nums={2,5,3,2,1};
		shellSort(nums);
		for(int tmp:nums){
			System.out.println(tmp);
		}
	}
	public static void shellSort(int[] nums){
		int length=nums.length;
		int distance,i,j;
		for(distance=length;distance>0;distance/=2){
			for(i=0;i<length;i++){
				int tmp=nums[i];
				for( j=i;j>=distance&&tmp<nums[j-distance];j-=distance){
					nums[j]=nums[j-distance];
				}
				nums[j]=tmp;
			}
		}
	}

 直接选择排序

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[]  nums={2,5,3,2,1};
		SelectSort(nums);
		for(int tmp:nums){
			System.out.println(tmp);
		}
	}
	public static void SelectSort(int[] nums){
		int i,j,min,index=0;
		for(i=0;i<nums.length;i++){
			min=nums[i];
			for(j=i+1;j<nums.length;j++){
				
				if(nums[j]<min){
					min=nums[j];
					index=j;
				}
			}
			nums[index]=nums[i];
			nums[i]=min;
		}
	}
	public static void swap(int[] nums,int a,int b){
		int tmp=nums[a];
		nums[a]=nums[b];
		nums[b]=tmp;
	}

堆排序

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[]  nums={2,5,3,4,6,9,8,10,1,11,12};
		nums=heapSort(nums);
		for(int tmp:nums){
			System.out.println(tmp);
		}
	}
	  public static int[] heapSort(int[] nums){
			nums=buildMaxHeap(nums);
			for(int i=0;i<nums.length;i++){
				int tmp=nums[0];// 交换堆顶元素array[0]和堆中最后一个元素array[array.length-1-i]
				nums[0]=nums[nums.length-1-i];
				nums[nums.length-1-i]=tmp;
				 // 每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整
				adjustDownToUpMax(nums, 0, nums.length-i-1);
			}
			return nums;
	    }
	public static int[] buildMaxHeap(int[] nums){
		for(int i=(nums.length-1)/2;i>=0;i--){
			adjustDownToUpMax(nums, i, nums.length);
		}
		return nums;
	}
	//建堆，基于当前的节点调整该节点的子树的位置
//length为数组的长度，不是长度减1！！！！！！！！！！！！！！！！！
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	public static void adjustDownToUpMax(int[] array,int k,int length){
		 int temp = array[k];   
	        for(int i=2*k+1; i<length; i=2*i+1){    //i为初始化为节点k的左孩子，沿节点较大的子节点向下调整
	            if(i+1<length && array[i]>array[i+1]){  //取节点较大的子节点的下标
	                i++;   //如果节点的右孩子>左孩子，则取右孩子节点的下标
	            }
	            if(temp<=array[i]){  //根节点 >=左右子女中关键字较大者，调整结束
	                break;
	            }else{   //根节点 <左右子女中关键字较大者
	                array[k] = array[i];  //将左右子结点中较大值array[i]调整到双亲节点上
	                k = i; //【关键】修改k值，以便继续向下调整
	            }
	        }
	        array[k] = temp;  //被调整的结点的值放人最终位置
	}
	//删除堆顶元素
	public int[] deletemax(int[] array){
		//将堆的最后一个元素与堆顶元素交换，堆底元素设为-9999
		array[0]=array[array.length-1];
		array[array.length-1]=-99999;
		//对此时的根节点进行向下调整
		adjustDownToUpMax(array, 0, array.length);
		return array;
	}
	//插入操作
	public int[] insertData(int[] array,int data){
		array[array.length-1]=data;
		int k=array.length-1;
		int parent=(k-1)/2;
		while(parent>=0&&data>array[parent]){
			array[k]=array[parent];
			k=parent;
			if(parent!=0){
				parent=(parent-1)/2;
			}else{
				break;
			}
		}
		array[k]=data;
		return array;
	}