java7大排序算法

1、冒泡排序

package lizicong;

import java.util.Scanner;

public class BubbleSort {
	/*
	 * 属于交换排序；稳定
	 * 排序原理：相邻的两个元素依次比较，相互交换
	 * 时间复杂度：最好o(n)，最差o(n^2),平均o(n^2)
	 * 辅助空间：o(1)
	 * 
	 */
	public void bubbleSort(int[] a){
		int n = a.length;
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n-i-1; j++){
				if(a[j] > a[j+1]){
					int tmp = a[j];
					a[j] = a[j+1];
					a[j+1] = tmp;
				}
			}
		}
	}
	public void print(int[] a){
		for( int i = 0; i < a.length; i++){
			System.out.print(a[i] + " ");
		}
	}
	
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		BubbleSort b = new BubbleSort();
		int[] a = new int[5];
		while(in.hasNextInt()){
			for( int i = 0; i < a.length; i++){
				a[i] = in.nextInt();
			}
			b.bubbleSort(a);
			b.print(a);
		}
	}
}

2、插入排序

package lizicong;

import java.util.Scanner;

public class InsertSort {
	/*属于插入排序类,稳定
	 * 插入排序思想：假设前面的元素是排好序的，找到一个元素，依次与前面的元素相比较直到找到一个比它小的数为止，
	 * 保存当前元素，然后元素依次后移，然后插入这个元素.
	 * 时间复杂度：最坏o(n^2)，最好O(n)已排好序，平均O(n^2)
	 * 辅助空间：o(1)
	 * */
	public static void sort(int[] arr){
		int i,j;
		int tmp;
		int len = arr.length;
		for(i = 1; i < len; i++){
			j = i;
			tmp = arr[i];
			while(j > 0 && arr[j-1] > tmp ){
				arr[j] = arr[j-1];
				j--;
			}
			arr[j] = tmp;
		}
	}
	
	public static void resvert_sort(int[] arr){
		int i,j;
		int tmp;
		int len = arr.length;
		for(i = 1; i < len; i++){
			j = i;
			tmp = arr[i];
			while(j > 0 && arr[j-1] < tmp){
				arr[j] = arr[j-1];
				j--;
			}
			arr[j] = tmp;
		}
		
	}
	public static void main(String[] args){
		//int[] arr = {23,43,3,12,13,124,2344,231,12,1};
		Scanner in = new Scanner(System.in);
		in.useDelimiter(" |,");
		int[] arr;
		while(in.hasNextInt()){
			arr = new int[6];
			for(int i = 0; i < 6; i++){
				arr[i] = in.nextInt();
			}
			sort(arr);
			for(int i = 0; i < 6; i++){
				System.out.printf("%d,",arr[i]);
			}
			System.out.println();
			resvert_sort(arr);
			for(int i = 0; i < 6; i++){
				System.out.printf("%d,",arr[i]);
			}
		}
		
		System.out.println("223");
		
	}
}

3、希尔排序

package lizicong;

import java.util.Scanner;

public class ShellSort {

	/*属于插入排序,不稳定
	 * 排序原理：将数组按指定的增量dk分成几小段，然后分别对这几小段进行排序，重复该步奏直到增量为1的时候再进行最后一次直接插入排序。
	 * 时间复杂度，没有一个公认的定论,估测：最好O(n^1.3),最坏o(n^2),平均o(nlogn)~O(n^2)
	 * 辅助空间o(1)
	 * 
	 * */
	private void shellInsertSort(int[] arr, int dk){
		for(int i = dk; i < arr.length; i++){
			if(arr[i] < arr[i-dk]){
				int j;
				int tmp = arr[i];
				for( j = i-dk; j >= 0 && tmp < arr[j]; j-=dk ){
					arr[j+dk] = arr[j];
				}
				arr[j+dk] = tmp;
			}
		}
	}
	
	private void shellSort(int[] arr){
		int dk = arr.length/2;
		while(dk >= 1){
			shellInsertSort(arr, dk);
			dk /=2;
		}
	}
	
	public void print(int[] arr){
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i] + " ");
		}
	}
	public static void main(String[] args){
		ShellSort  shell = new ShellSort();
		Scanner in = new Scanner(System.in);
		int[] a = new int[5];
		while(in.hasNextInt()){
			for(int i = 0; i < a.length; i++){
				a[i] = in.nextInt();
			}
			shell.shellSort(a);
			shell.print(a);
		}
	}
}

4、简单选择排序

package lizicong;

import java.util.Scanner;

public class SimpleSelectSort {
	/*属于选择排序，稳定
	 * 排序原理：从第一个元素开始，一次与后面的元素比较，找出最小值，然后与开始的元素交换
	 * 时间复杂度：最好o(n^2),最坏：o(n^2),平均o(n^2)
	 * 辅助空间复杂度o(1)
	 * 
	 * */
	public void selectSort(int[] a){
		for(int i = 0; i < a.length; i++){
			int k = i;
			for(int j = i+1; j < a.length; j++){
				if(a[k] > a[j]){
					k = j;
				}
			}
			swap(a, i, k);
		}
	}
	
	private void swap(int[] a,int i, int j){
		if(i == j){
			return;
		}
		a[i] = a[i] + a[j];
		a[j] = a[i] - a[j];
		a[i] = a[i] - a[j];
	}
	
	public void print(int[] a){
		for(int i = 0; i < a.length; i++){
			System.out.print(a[i] + " ");
		}
	}
	
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		SimpleSelectSort s = new SimpleSelectSort();
		int[] a = new int[5];
		
		while(in.hasNextInt()){
			for(int i = 0; i < a.length; i++){
				a[i] = in.nextInt();
			}
			s.selectSort(a);
			s.print(a);
		}
	}
}

5、快速排序

package lizicong;

import java.util.Scanner;

public class QuickSort {
	/*属于交换排序，不稳定
	 * 排序算法：选一个元素，将小于该元素的放在该元素左边，大于该元素的放在该元素右边，递归
	 * 时间复杂度：最好o(nlog2n),最坏o(n2),平均o(nlog2n)
	 * 空间复杂度o(nlog2n)
	 * 
	 * */
	
	public static int getMiddle(int[] numbers, int low, int high){
		int temp = numbers[low];
		while(low < high){
			while(low < high && numbers[high] > temp){
				high--;
			}
			numbers[low] = numbers[high];
			while(low < high && numbers[low] < temp){
				low++;
			}
			numbers[high] = numbers[low];
		}
		numbers[low] = temp;
		return low;
	}
	
	public static void quickSort(int[] numbers, int low, int high){
		if(low < high){
			int middle = getMiddle(numbers, low, high);
			quickSort(numbers, low, middle - 1);
			quickSort(numbers, middle + 1, high);
		}
	}
	public static void print(int[] a){
		for( int i = 0; i < a.length; i++){
			System.out.print(a[i] + " ");
		}
	}
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int[] a = new int[5];
		while(in.hasNextInt()){
			for(int i = 0; i < a.length; i++){
				a[i] = in.nextInt();
			}
			quickSort(a, 0, a.length - 1);
			print(a);
		}
		
	}
}

6、归并排序

package lizicong;

import java.util.Scanner;

public class MergeSort {
	/*
	 * 属于归并排序，稳定
	 * 算法：将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
	 * 时间复杂度：都是o(nlog2n)
	 * 辅助空间：o(1);
	 * */
	public static void 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);
		}
		
	}
	public static 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++];
		}
		for(int k2 = 0; k2 < temp.length; k2++){
			nums[k2 + low] = temp[k2];
		}
	}
	public static void print(int[] a){
		for( int i = 0; i < a.length; i++){
			System.out.print(a[i] + " ");
		}
	}
	
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int[] a= new int[5];
		while(in.hasNextInt()){
			for(int i = 0; i < a.length; i++){
				a[i] = in.nextInt();
			}
			sort(a, 0, a.length - 1);
			print(a);
		}
	}
}

7、堆排序

package lizicong;

import java.util.Arrays;
import java.util.Scanner;

public class HeapSort {
	/* 属于选择排序，不稳定
	 * 算法：:初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个 堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆
	 * 时间复杂度： 都是o(nlog2n)
	 * 辅助空间：o(1)
	 * */
	public static void sort(int[] a){
		int len = a.length;
		for(int i = 0; i < len; i++){
			bulidMaxHeap(a, len-1-i);
			swap(a, 0, len-1-i);
		}
		System.out.println(Arrays.toString(a));
	}
	public static void bulidMaxHeap(int[] data, int lastIndex){
		for(int i = (lastIndex - 1)/2; i >= 0; i--){
			int k = i;
			while(k*2 + 1 <= lastIndex){
				//如果当前k节点的子节点存在  
				int biggerIndex = 2 * k + 1;
				//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
				if(biggerIndex < lastIndex){
					if(data[biggerIndex] < data[biggerIndex + 1]){
						//biggerIndex总是记录较大子节点的索引  
						biggerIndex++;
					}
				}
				//如果k节点的值小于其较大的子节点的值 ,交换他们
				if(data[k] < data[biggerIndex]){
					swap(data, k, biggerIndex);
					k = biggerIndex;
				}else{
					break;
				}
			}
		}
	}
	private static void swap(int[] data, int i, int j) {  
        int tmp=data[i];  
        data[i]=data[j];  
        data[j]=tmp;  
    } 
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int[] a= new int[5];
		while(in.hasNextInt()){
			for(int i = 0; i < a.length; i++){
				a[i] = in.nextInt();
			}
			sort(a);
		}
	}
}