java语言描述数据结构与算法之——冒泡排序，插入排序，选择排序，希尔排序，快速排序，归并排序，二分查找

package com.demo.test;

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

public class TestDemo{
public static void main(String[] args) {
//随机输入n个数,存放在数组a中
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int a[]=new int[n];
//这是第一种输入方法
/for (int i=0;i<n;i++) {
a[i]=scanner.nextInt();
}/
//这是第二种输入方法
int k=0;
while(true) {
if(k<n) {
a[k]=scanner.nextInt();
k++;
}else {
break;
}
}

	int[] b=choicSort(a);
	for (int j=0;j<b.length;j++) {
		System.out.print(b[j]+"  ");
	}
}


//冒泡排序
private static int[] bubbleSort(int[] array) {
	for (int i=1;i<array.length;i++) {
		for (int j=0;j<array.length-i;j++) {
			if (array[j]>array[j+1]) {
				int temp=array[j];
				array[j]=array[j+1];
				array[j+1]=temp;
			}
		}
	}
	return array;
}

//插入排序
private static int[] insertSort(int[] array) {
	for (int i=1;i<array.length;i++) {
		int j=i;
		int temp=array[i];
		while (j>0&&array[j-1]>temp) {
			array[j]=array[j-1];
			j--;
		}
		array[j]=temp;
	}
	return array;
}

//选择排序
private static int[] choicSort(int[] array) {
	
	for (int i=0;i<array.length-1;i++) {
		int min=i;
		for (int j=i+1;j<array.length;j++) {
			if (array[j]<array[min]) {
				min=j;
			}
		}
		if (min!=i) {
			int temp=array[i];
			array[i]=array[min];
			array[min]=temp;
		}
	}
	
	return array;
}

//希尔排序
private static int[] shellSort(int[] array) {
	int step=(array.length-1)/2;
	while (step>0) {
		for (int i=step;i<array.length;i++) {
			int j=i;
			int temp=array[i];
			while(j>(step-1)&&array[j-step]>=temp) {
				array[j]=array[j-step];
				j=j-step;
			}
			array[j]=temp;
		}
		step=step/2;
	}
	return array;
}

//快速排序
private static void quickSort(int[] array) {
	reQuickSort(array,0,array.length-1);
}
private static void reQuickSort(int[] array,int left,int right) {
	if (left>=right) {
		return ;
	}else {
		int partition=partitionIt(array,left,right);
		reQuickSort(array,left,partition-1);
		reQuickSort(array,partition+1,right);
	}
}

private static int partitionIt(int[] array,int left,int right) {
	int i=left;
	int j=right+1;
	int povit=array[left];
	while (true) {
		while (i<right&&array[++i]<povit) {}
		while (j>0&&array[--j]>povit) {}
		if (i<j) {
			swap(array,i,j);
		}else {
			break;
		}
	}
	swap(array,left,j);
	return j;
}

private static void swap(int[] array,int i,int j) {
	int temp=array[i];
	array[i]=array[j];
	array[j]=temp;
}


//归并排序
private static int[] sort(int[] a,int low,int high){
    int mid = (low+high)/2;
    if(low<high){
        sort(a,low,mid);
        sort(a,mid+1,high);
        //左右归并
        merge(a,low,mid,high);
    }
    return a;
}
 
private static void merge(int[] a, 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(a[i]<a[j]){
            temp[k++] = a[i++];
        }else{
            temp[k++] = a[j++];
        }
    }
    // 把左边剩余的数移入数组 
    while(i<=mid){
        temp[k++] = a[i++];
    }
    // 把右边边剩余的数移入数组
    while(j<=high){
        temp[k++] = a[j++];
    }
    // 把新数组中的数覆盖nums数组
    for(int x=0;x<temp.length;x++){
        a[x+low] = temp[x];
    }
}

//二分查找
private static int binarySerach(int[] array,int left,int right,int value) {
	int i=left;
	int j=right;
	int mid=(i+j)/2;
	if (i>=j) {
		return -1;
	}
	if (array[mid]>value) {
		return binarySerach(array,0,mid-1,value);
	}else if(array[mid]<value){
		return binarySerach(array,mid+1,right,value);
	}else {
		return mid;
	}
	
}

}