JAVA数据结构基础--排序

冒泡算法

	public static void bubbleSort(int arr[]){
		int n = arr.length;
		for(int i = 0;i<n;i++) {
			for(int j=n-1;j>i;j--) {
				if(arr[j-1]>arr[j]) {
					int temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
				}
			}
		}
	}

思想核心：
可以把排序数看作一个一个气泡。最小的数在每次循环中会往数组前窜，就像气泡往上冒。
一，最外层for循环，循环n次，即要排序数的个数。每次排序将最小的数排到最前边，将此最小的数确定位置，继续下一轮最小值的寻找和前窜。
二，第二层for循环，从后往前比较元素，小的值前移。

插入排序

找到合适位置将下一元素放入，该在此元素右边的全部右移一格。再将该元素放在该放入的位置。

	public static void insertSort(int arr[],int left,int right) {
		int temp,j;
		for(int i = left+1;i<=right;i++) {//n个元素依次插入
			if(arr[i]<arr[i-1]) {
				temp = arr[i];
				j = i-1;
				do {
					arr[j+1] = arr[j];//后移
					j--;
				}while(j>=left&&temp<arr[j]);
				arr[j+1]=temp;
			}
		}
	}

归并算法

	public static void mergeSort(int arr[],int left,int right) {
		if(arr == null) {
			return;
		}
		if(left < right) {
			int mid = (left+right)/2;//找中间基准
			mergeSort(arr, left, mid);//左划分
			mergeSort(arr, mid+1, right);//右划分
			merge(arr,left,mid,right);//合并
		}
	}

	private static void merge(int[] arr, int left, int mid, int right) {
	//合并函数
		int Lstart = left,Rstart = right,index=left;
		int Array[] = new int[arr.length];
		while(Lstart<=mid && Rstart<=right) {//当左划分数组和右划分数组还有元素
			if(arr[Lstart]<arr[Rstart]) {
				Array[index++]=arr[Lstart++];
			}else {
				Array[index++]=arr[Rstart++];
			}
		}
		while(Lstart<=mid) {//当左划分数组还有元素，而右划分数组无元素
			Array[index++]=arr[Lstart++];
		}
		while(Rstart<=mid) {//当左划分数组无元素，而右划分数组有元素
			Array[index++]=arr[Rstart++];
		}
	}

划分合并总体过程

合并过程：

选择排序

	public static void selectSort(int arr[],int left,int right) {
		for(int i = left;i<right;i++) {
			int k = i;
			for(int j=i+1;j<=right;j++) {//找最小元素下标
				if(arr[j]<arr[k]) {
					k=j;
				}
			}
			if(k!=i) {//交换位置，
				int temp = arr[i];
				arr[i] = arr[k];
				arr[k] = temp;
			}
		}
	}

核心思想：
每轮循环找到最小值，并从前往后按序放置最小值。

希尔算法

	public static void shellSort(int arr[], int left, int right) {
		int gap = right - left + 1;// 保证增量大于等于1
		int temp = 0, j = 0;
		do {
			gap = gap / 3 + 1;// 计算下一增量
			for(int i =left+gap;i<=right;i++) {//从前往后，i后移一位两两比较
				if(arr[i]<arr[i-gap]) {//如果需要调整位置
					temp = arr[i];
					j=i-gap;//获取前一个元素下标
					do {
						arr[j+gap]=arr[j];//交换元素
						j = j-gap;//j前移
					}while(j>=left&&temp<arr[j]);//当j还在数组内，且满足交换条件
					arr[j+gap] = temp;//将temp填充进去
				}
			}
		} while (gap > 1);
	}

快速排序

	public static void quickSort(int arr[],int left,int right) {
		if(left<right) {
			int pivotpos=Partition(arr,left,right);
			quickSort(arr,left,pivotpos-1);
			quickSort(arr,pivotpos+1,right);
		}
	}

	private static int Partition(int[] arr, int left, int right) {
		int pivotpos = left;//基准
		int pivot = arr[left];//获取基准元素
		for(int i = left+1;i<=right;i++) {//从左至右，依次比较
			if(arr[i]<pivot) {//若当前元素小于基准元素
				pivotpos++;//基准++
				if(i!=pivotpos) {//交换两元素
					int temp = arr[i];
					arr[i] = arr[pivotpos];
					arr[pivotpos] = temp;
				}
			}
			arr[left] = arr[pivotpos];//最左端与基准交换位置
			arr[pivotpos] = pivot;
		}
		return pivotpos;//返回基准
	}