java基本排序算法

1.插入排序

/**
 * 直接插入排序  (不优化)
 * 
 * *
 * **
 * ***
 * @author 大护法
 *
 */
public class Demo01 {
	
	public void insertSort(int[] m){
		int std;
		for(int i=1; i<m.length; i++){
			for(int j = i; j>0 && m[j-1]>m[j]; j--){
				std = m[j-1];
				m[j-1] = m[j];
				m[j]  = std;
			}
		}
	}

}

/**
 * 直接插入排序优化以后(优化 不排序，只进行交换)
 * 
 * @author 大护法
 *
 */
public class Demo02 {
	public void insertSort(int[] m){
		
		for(int i=1; i<m.length; i++){
			
			int e = m[i];
			int j;
			for( j= i; j>0 && m[j-1]>e; j--){
				m[j] = m[j-1];
			}
			
			m[j] = e;
			
		}
	}
}

/*
 * 希尔排序（是一种特殊的插入排序 ，和直接插入排序不同的是其规定了比较的间隔位移量， 降低了其排序的时间复杂度）
 * 
 * 时间复杂度 O(n(lbn)*n(lbn))
 * 
 * 由于相同的元素可能出现在不同的分块中所以希尔排序是一种不稳定的排序
 * 
 * 
 */
public class ShellSort {
	public static void shellSort(int[] data){
		int j ,tmp;  //设置数据暂存模板
		int span = data.length/2;  //设置间隔位移量


		//最外层位移量间隔循环
		while(span != 0){




			for(int i=span; i<data.length;i++){
				tmp = data[i];
				j = i-span;
				while(j>=0 && tmp < data[j]){
					data[j+span] = data[j];
					j = j-span;
				}
				data[j+span] = tmp;
			}
			span = span/2;
		}


	}
	public static void main(String[] args) {
		int[] data = {6,5,9,2,4};


		shellSort(data);


		for(int i=0; i<data.length; i++){
			System.out.println("--"+data[i]);
		}
	}
}

2.选择排序

/**
 * 
 * 选择排序的实现
 * 
 * 
 * 每次选择最小的数
 * @author 大护法
 *
 */
public class Demo01 {

	public void selectSort(int[] n){

		
		for(int i=0; i<n.length; i++){
			int minIndex = i;

			for(int j =i+1; j<n.length; j++)
			{
                if(n[j] < n[minIndex])
                	minIndex = j;
			}
			int std = n[minIndex];
			n[minIndex] = n[i];
			n[i] = std;
		
			
		
		}
	}
}

3，交换排序

/*
 * 冒泡排序
 * 
 */
public class DubbleSort {
	public static void dubbleSort(int[] data){
		int temp;   
		int flag = 1;   //标记位
		for(int i=1; i<data.length && flag==1; i++){
			flag = 0;
			for(int j=0; j<data.length-i; j++){
				if(data[j]>data[j+1]){
					flag = 1;
					temp = data[j];
					data[j] = data[j+1];
					data[j+1] = temp; 
				}
			}
		}
	}


	public static void main(String[] args) {
		int[] data = {6,5,9,2,4};


		dubbleSort(data);
		
		for(int i=0; i<data.length; i++){
			System.out.println("--"+data[i]);
		}
	}
}

/*
 * 第一种： 快速排序 （是交换排序的一种，速度快）
 * 
 * --快速排序的步骤 。。。。
 *   假设 ：有数据 a[0],a[1]...a[n];
 *              
 *   步骤:  1:设a[0]为第一个键值 
 *         2:从左到右比较找出第一个键值---条件（a[i]>a[0]）;
 *         3:从右向左比较找出第二个键值---条件（a[j]<a[0]）
 *         4:若 j>i 则将 a[i] 和 a[j] 交换并且继续执行步骤 （2）
 *         5:若 i>j 则将 a[0] 和 a[j] 交换，将数据以 a[j] 为基准点分成左右两部分， 递归执行左右两部分
 *         
 *         
 */


public class QuickSort {
	public static void quickSort(int[] a, int low, int high){
        int i, j;
		int temp;
		i =low;  
		j =high;
		temp = a[low];
		
		while(i<j){
			//在数组的右端进行扫描
			while(i<j && temp<=a[j]) j--;
			if(i<j){
				a[i] = a[j];
				i++;
			}
		    
			
			//在数组的左端进行扫描扫描
			while(i<j && a[i]<temp) i++;
			if(i<j){
				a[j] = a[i];
				j--;
			}
		}
		
        a[i] = temp;
        
        if(low < i) quickSort(a, low, i-1);
        if(i < high) quickSort(a, i+1, high);
	}
	
    public static void main(String[] args) {
    	int[] data = {6,5,9,2,4};


		quickSort(data,0,data.length-1);
		
		for(int i=0; i<data.length; i++){
			System.out.println("--"+data[i]);
		}
	}
}

/**
 * 第二种： 快速排序
 * 
 *
 * @author 大护法
 *
 */
public class Demo01 {
    public void  quickSort(int[] arr){
    	_quickSort(arr,0,(arr.length-1));
    }
    
    
    public void _quickSort(int[] arr, int l, int r){
    	if(l>=r) return ;
    	
    	int p = _partition(arr, l, r);
    	_quickSort(arr, l, p-1);
    	_quickSort(arr, p+1, r);
    }


    
    //对arr[l..r] 部分进行partition操作
    //返回 p, 使得arr[l..p-1 <arr[p]; arr[p+1 ..r]] > arr[p]
	private int _partition(int[] arr, int l, int r) {
	    
		int v = arr[l];
	    int j = l;
		int std;
		for(int i = l+1;  i<=r; i++){
			if(arr[i] < v){	
				std = arr[j+1];
				arr[j+1] = arr[i];
				arr[i] = std;
				j++;
			}
		}
		
		
		std = arr[l];
		arr[l] = arr[j];
		arr[j] = std;
				
		return j;
	}										
}

4.归并排序

/**
 * 第一种归并排序
 * 
 * 自顶向下的归并排序
 * 采用递归的方法实现
 * 
 * 
 * @author 大护法
 *
 */
public class Demo01 {
	
	//归并排序
	public void mergeSort(int[] arr){
		int l =0; 
		int r = arr.length-1;
		_mergeSort(arr, l, r);
	}
	
	//递归使用归并排序，对arr[l....r]的范围进行归并排序
	public void _mergeSort(int[] arr, int l, int r){
		if(l >= r) return;
		
		
		int mid = (l+r)/2;
		_mergeSort(arr, l, mid);  //左边
		_mergeSort(arr, mid+1, r); //右边
		
		_merge(arr, l, mid, r);   //根据merge对分割的部分进行排序
		
		
	}
	
	//排序实现
	public void _merge(int[] arr, int l, int mid, int r){
		
		int[] aux = new int[r-l+1];
		
		for(int i=l; i<=r; i++){
 			aux[i-l] = arr[i];   //为aux这个数组赋值
		}
		
		int i =l; 
		int j = mid+1;
		
		
		for(int k =l; k<=r; k++){
			
			
			//左边界越界
			if(i>mid){
				//System.out.println("arr[k]=" +arr[k] +",aux[j-1]="+aux[j-1]+", k="+k+", j="+j);
				arr[k] = aux[j-l];
				j++;
			}
			
			//右边界越界
			else if(j>r){
				arr[k] = aux[i-l];
				i++;
			}
			
			else if(aux[i-l] < aux[j-l]){
				arr[k] = aux[i-l];
				i++;
			}
			
			else{
				arr[k] = aux [j-l];
				j++;
			}
		}
		
	}
	
	
	public static void main(String[] args){
		int[] data = {6,5,9,2,4,3,45,76,87,98,234};
		new Demo01().mergeSort(data);
		
		for(int i=0; i<data.length; i++){
			System.out.println("--"+data[i]);
		}
	}

}

/**
 * 
 * 第二种归并排序
 * 从下向上通过迭代实现
 * 
 * @author 大护法
 *
 */
public class Demo02 {
	//归并排序
	public void mergeSort(int[] arr){


		int n = arr.length;
		for(int sz =1; sz<=n; sz+=sz)
			for(int i=0; i+sz<n; i+=sz+sz)
				_merge(arr, i, i+sz-1, min(i+sz+sz-1,n-1));
	}




	//排序实现
	public void _merge(int[] arr, int l, int mid, int r){


		int[] aux = new int[r-l+1];


		for(int i=l; i<=r; i++){
			aux[i-l] = arr[i];   //为aux这个数组赋值
		}


		int i =l; 
		int j = mid+1;




		for(int k =l; k<=r; k++){




			//左边界越界
			if(i>mid){
				//System.out.println("arr[k]=" +arr[k] +",aux[j-1]="+aux[j-1]+", k="+k+", j="+j);
				arr[k] = aux[j-l];
				j++;
			}


			//右边界越界
			else if(j>r){
				arr[k] = aux[i-l];
				i++;
			}


			else if(aux[i-l] < aux[j-l]){
				arr[k] = aux[i-l];
				i++;
			}


			else{
				arr[k] = aux [j-l];
				j++;
			}
		}


	}
	
	public int min(int n, int m){
		if(m>n) return n;
		return m;
	}




	public static void main(String[] args){
		int[] data = {6,5,9,2,4,3,45,76,87,98,234};
		new Demo01().mergeSort(data);


		for(int i=0; i<data.length; i++){
			System.out.println("--"+data[i]);
		}
	}
}

/*
 * 
 * 第三种归并排序
 * 
 * 归并排序 是一种稳定的排序算法
 * 时间复杂度为 O(nlgn)
 */
public class MergeSort {

	//一次二路归并排序
	public static void merge(int[] a, int[] swap, int k){
		int n = a.length;
		int m = 0;
		int i, j;
		int u1, u2;  //
		int l1 = 0, l2;  //

		while(l1 + k <= n-1){
			l2 = l1 + k;
			u1 = l2 - 1;
			u2 = (l2+k-1 <= n - 1)? l2+k-1 : n-1;

			for(i=l1 ,j=l2; i<=u1 && j<=u2; m++){
				if(a[i] <= a[j]){
					swap[m] = a[i];
					i++;
				}else{
					swap[m] = a[j];
					j++;
				}
			}

			while(i<=u1){
				swap[m] = a[i];
				m++;
				i++;
			}

			while(j <= u2){
				swap[m] = a[j];
				m++;
				j++;
			}

			l1 = u2 + 1;
		}

		for(i = l1; i<n; i++, m++){
			swap[m] = a[i];
		}
	}

	//二路归并的排序算法
	public static void mergeSort(int[] a){
		int i;
		int n = a.length;
		int k = 1;
		int[] swap = new int[n];

		while(k<n){
			merge(a, swap, k);

			for(i=0; i<n; i++){
				a[i] = swap[i];
			}
			
			k = 2*k;
		}
	}

	public static void main(String[] args){
		int[] data = {6,5,9,2,4,3,45,76,87,98,234};
		mergeSort(data);
		
		for(int i=0; i<data.length; i++){
			System.out.println("--"+data[i]);
		}
	}
}