java排序总结 笔记

package com.hqy.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Sort {
	private int[] array;
    private int currentsize;
	
	public Sort(int max){
		array=new int[max];
        currentsize=0;
	}
	
	public void increatment(){
		currentsize++;
	}
	
	/**   
	 * @Description: 1.冒泡排序原理：它重复地走访过要排序的数列，一次进行相邻两个元素的比较，如果他们的顺序错误就把他们交换过来。
	 *                          每一次排序都选出一个未排序序列中最大的元素。
	 *   
	 */
	public void bubbelSort(){
		int temp;
		for(int out=array.length-1;out>0;out--){
			for(int in=0;in<out;in++){
				if(array[in]>array[in+1]){
					temp=array[in];
					array[in]=array[in+1];
					array[in+1]=temp;
				}
			}
		}
	}
	
	
	/**   
	 * @Description: 2.插入排序：对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
	 *                 步骤： 
				1、从第一个元素开始，该元素可以认为已经被排序 
				2、取出下一个元素，在已经排序的元素序列中从后向前扫描 
				3、如果该元素（已排序）大于新元素，将该元素移到下一位置 
			        4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 
			        5、将新元素插入到该位置中 
			        6、重复步骤2
	 */
	public void insertSort(){
		int temp,in,out;
		for(out=1;out<array.length;out++){
			temp=array[out];
			in=out;
			while(in>0&&array[in-1]>temp){
				array[in]=array[in-1];
				in-=1;
			}
			array[in]=temp;
		}
	}
	
	
	/**   
	 * @Description: 3.选择排序：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，
	 *             然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。
	 *   
	 */
	public void selectSort(){
		int min,temp,in,out;
		for(out=0;out<array.length;out++){
			min=out;
			for(in=out;in<array.length;in++){
				if(array[in]<array[min]){
					min=in;
				}
			}
			temp=array[min];
			array[min]=array[out];
			array[out]=temp;
		}
	}
	
	
	
	/**   
	 * @Description: 4.快速排序：主要是找”枢纽“，运用递归进行排序
	 *   
	 */
	public void quickSort(){
		requickSort(0,array.length-1);
	}
	
	public void requickSort(int low,int high){
		if(high-low<1){
			return;
		}
		int povit=getPovit(low,high,array[high]);
		requickSort(low, povit-1);
		requickSort(povit+1, high);
	}
	

	private int getPovit(int low, int high, int povit) {
		// TODO Auto-generated method stub
		int lowptr=low-1;
		int highptr=high;
		int temp;
		while(true){
			while(array[++lowptr]<povit);
			while(highptr>0&&array[--highptr]>povit);
			
			if(lowptr>=highptr)break;
			
			temp=array[lowptr];
			array[lowptr]=array[highptr];
			array[highptr]=temp;
		}
		temp=array[lowptr];
		array[lowptr]=array[high];
		array[high]=temp;
		return lowptr;
	}
	
	
	
	/**   
	 * @Description: 5.希尔排序：也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。 
	 * 
			希尔排序是基于插入排序的以下两点性质而提出改进方法的：  
		          1、插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率  
		          2、但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位 
	 *   
	 */
	public void shellSort(){
		int in,out,h,temp;
		h=1;
		
		while(h<array.length/3){
			h=3*h+1;
		}
	
		while(h>0){
			for(out=h;out<array.length;out++){	
				in=out;
				while(in>h-1&&array[in]<array[in-h]){
					temp=array[in];
					array[in]=array[in-h];
					array[in-h]=temp;
					in-=h;
				}				
			}
			h=(h-1)/3;
		}	
	}
	
	
	
	/**   
	 * @Description: 6.归并排序：归并排序（Merge sort，也称：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 
	 * 
			步骤：  
				1、申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列  
				2、设定两个指针，最初位置分别为两个已经排序序列的起始位置  
				3、比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置  
				4、重复步骤3直到某一指针达到序列尾  
				5、将另一序列剩下的所有元素直接复制到合并序列尾  
	 *   
	 */
	public void mergeSort(){	
		int a[]=new int[array.length];
		remergeSort(a, 0,array.length-1);
	}

	private void remergeSort(int[] a, int left, int right) {
		// TODO Auto-generated method stub
		if(left==right){
			return;
		}
		int mid=(left+right)/2;
		remergeSort(a, left, mid);
		remergeSort(a,mid+1,right);
		merge(a,left,mid+1,right);
		
	}


	private void merge(int[] a, int left, int highptr, int right) {
		// TODO Auto-generated method stub
		int i=0;
		int leftptr=left;
		int mid=highptr-1;
		int n=right-left+1;
		
		while(leftptr<=mid && highptr<=right){
			if(array[leftptr]<array[highptr]){
				a[i++]=array[leftptr++];
			}else{
				a[i++]=array[highptr++];
			}
		}
		
		while(leftptr<=mid){
			a[i++]=array[leftptr++];
		}
		
		while(highptr<=right){
			a[i++]=array[highptr++];
		}
		
		for(int k=0;k<n;k++){
			array[left+k]=a[k];
		}
	}
	
	
	
	
	/**   
	 * @Description: 7.堆排序：堆积排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。
	 *         堆是一个近似完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 
	 *   
	 */
	public void heapSort(){
		//建堆
		for(int i=currentsize/2-1;i>=0;i--){
			trickdown(i);
		}
		
		//排序
		for(int k=array.length-1;k>=0;k--){
			int temp=remove();
			array[k]=temp;
		}
		
	}
	
	
	public int remove(){
		int temp=array[0];
		array[0]=array[--currentsize];
		trickdown(0);
		return temp;
	}
	
	
	public void trickdown(int index){
		int largeChild;
		int temp=array[index];
		while(index<currentsize/2){
			int leftChild=index*2+1;
			int rightChild=leftChild+1;
			
			//注意if语句里rightChild的范围：即如果largeChild=rightChild；必须在if条件成立的语句块中，因为rightChild可能越界
			if(rightChild<currentsize && array[leftChild]<array[rightChild]){
				largeChild=rightChild;
			}else{
				largeChild=leftChild;
			}
		//	System.out.println("smallChild:"+smallChild);
			if(temp>=array[largeChild]){
				break;
			}
			
			array[index]=array[largeChild];
			index=largeChild;
		}
		array[index]=temp;
	}
	


	public void display(){
		for(int i=0;i<array.length;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		int max=10;
		Sort sort=new Sort(max);
		System.out.println("冒泡排序：");
		for(int i=0;i<10;i++){
			sort.array[i]=(int)(java.lang.Math.random()*100);
		}
		sort.display();
		sort.bubbelSort();
		sort.display();
		System.out.println("******************************");
		
		System.out.println("插入排序：");
		for(int i=0;i<max;i++){
			sort.array[i]=(int)(java.lang.Math.random()*100);
		}
		sort.display();
		sort.insertSort();
		sort.display();
		System.out.println("******************************");
		
		System.out.println("选择排序：");
		for(int i=0;i<max;i++){
			sort.array[i]=(int)(java.lang.Math.random()*100);
		}
		sort.display();
		sort.selectSort();
		sort.display();
		System.out.println("******************************");
		
		
		System.out.println("快速排序：");
		for(int i=0;i<max;i++){
			sort.array[i]=(int)(java.lang.Math.random()*100);
		}
		sort.display();
		sort.quickSort();
		sort.display();
		System.out.println("******************************");
		
		
        Sort sort2=new Sort(12);
		System.out.println("希尔排序：");
		for(int i=0;i<12;i++){
			sort2.array[i]=(int)(java.lang.Math.random()*100);
		}
		sort2.display();
		sort2.shellSort();
		sort2.display();
		System.out.println("******************************");
		

        Sort sort3=new Sort(10);
		System.out.println("归并排序：");
		for(int i=0;i<10;i++){
			sort3.array[i]=(int)(java.lang.Math.random()*100);
		}
		sort3.display();
		sort3.mergeSort();
		sort3.display();
		System.out.println("******************************");
		
		
		 Sort sort4=new Sort(10);
			System.out.println("堆排序：");
			for(int i=0;i<10;i++){
				sort4.array[i]=(int)(java.lang.Math.random()*100);
				sort4.increatment();
			}
			sort4.display();
			sort4.heapSort();
			sort4.display();
			System.out.println("******************************");
		
		
		
	}
	
	public static String getString() throws IOException{
		InputStreamReader inputStreamReader=new InputStreamReader(System.in);
		BufferedReader bfBufferedReader=new BufferedReader(inputStreamReader);
		String string=bfBufferedReader.readLine();
		return string;
	}
	
	public static int getInt() throws  IOException{
		String string=getString();
		return Integer.parseInt(string);
	}

}