几种排序算法java实现

没有配图，过几天补上

package com.sort;

public class Sort {

	
	
	/**
	 * 插入排序
	 * 原理：往有序的子数组选择一个合适的位置插进去
	 * */

	public void insertSort(int sort[]) {
		int temp;
		int j;

		for (int i = 1; i < sort.length; i++) {//循环每个数
			temp = sort[i];//要插入数
			for (j = i - 1; j >= 0 && temp < sort[j]; j--) {//前面的子序列都是有序，查找合适的位置，腾出空位
				sort[j + 1] = sort[j];
			}
			sort[j + 1] = temp;//插入数
		}
	}

	
	/***
	 * 选择排序
	 * 原理：每次循环找出最小的或者最大的
	 * 
	 * */
	public void selectSort(int sort[]) {

		int min;
		int temp;

		for (int i = 0; i < sort.length; i++) {//循环一次
			min = i;//假设当前最小
			for (int j = i + 1; j < (sort.length - 1); j++) {//查找最小的数组下标
				if (sort[min] > sort[j])
					min = j;
			}
			if (i != min) {//要不是自己所想的那样就交换
				temp = sort[min];
				sort[min] = sort[i];
				sort[i] = temp;
			}
		}
	}

	
	/**
	 * 冒泡排序基本排版
	 * 原理：每次循环，通过与前面的一一比较，遇到比它大或者小的就交换
	 * 
	 * */
	public void bubbleSor(int[] sort) {

		int temp;

		for (int i = 0; i < sort.length; i++)//从数组下界0到length开始遍历
			for (int j = (sort.length - 1); j > i; j--) {//每一次从最后往前面开始冒
				if (sort[j] > sort[j - 1]) {
					temp = sort[j];
					sort[j] = sort[j - 1];
					sort[j - 1] = temp;

				}
			}
	}

	// 冒泡排序优化
	public void superDubbleSort(int[] sort) {

		int temp;
		boolean flag = true;//设置变量，记录上一次有没有进行交换

		for (int i = 0; i < sort.length && flag; i++) {
			flag = false;

			for (int j = (sort.length - 1); j > i; j--) {
				if (sort[j] > sort[j - 1]) {

					temp = sort[j];
					sort[j] = sort[j - 1];
					sort[j - 1] = temp;
					flag = true;//表示交换过
				}
			}
		}
	}

	
	/**
	 * 希尔排序:插入排序的进阶版
	 * 原理：希尔排序是基于数组基本有序的前提下进行，所谓基本排序是指小的那些在前面，大的那些后面，
	 *     然后设置一把尺子，尺子不断变小，直至最后到1，这样每次比较范围的就逐渐变小了
	 * 
	 * */
	public void shellSort(int sort[]) {

		int temp;
		int increament = sort.length;

		while (increament > 1) {

			increament = increament / 3 + 1;// 变化的尺子
			for (int i = increament; i < sort.length; i++) {//以尺子的增量进行遍历

				if (sort[i - increament] > sort[i]) {//在尺子的两端比较两个数
					temp = sort[i];
					int j;
					for (j = i - increament; j >= 0 && temp < sort[j]; j -= increament) {//将之前排好的序列造出一个合适的位置
						sort[j + increament] = sort[j];
					}
					sort[j + increament] = temp;//插入进去
				}
			}
		}
	}

	/**
	 * 堆排
	 * 原理：堆排是基于大顶堆或者小顶堆进行排序的。每一次循环就交换最大数或者最小数放到排好的序列中
	 * 要解决的问题：如果构造大顶堆或者小顶堆，这里用来二叉的树的基本性质就是如果一个结果有孩子那就孩子的节点为i 和 i + 1 
	 * 过程：第一步是构造一个顶堆（这里是大顶堆）
	 *     第二步：循环数组，每一次把子数组的中最大值挑出来，然后再构造顶堆，如些循环
	 * */
	public void heapSort(int sort[]) {

		int i;
		for (i = sort.length / 2; i > 0; i--)
			heapAdjust(sort, i, sort.length - 1);// 先构造大顶堆 ， 代码往下来

		int temp;
		for (i = (sort.length - 1); i > 1; i--) {//把最大数放在最后一个

			temp = sort[i];
			sort[i] = sort[1];
			sort[1] = temp;
			heapAdjust(sort, 1, i - 1);//把n - 1个的数组构成顶堆

		}
	}

	// 构造大顶堆
	private void heapAdjust(int[] head, int s, int m) {

		int temp, j;
		temp = head[s];

		for (j = 2 * s; j <= m; j *= 2) {//二叉树的性质
			if (j < m && head[j] < head[j + 1])//比较父节点与两个子节点的大小
				++j;
			if (temp >= head[j])
				break;
			head[s] = head[j];
			s = j;
		}
		head[s] = temp;
	}

	/***
	 * 归并排序
	 * 原理：把一个数组不断分，分到只有一个为止，然后递归回来的时候不断的合并
	 * 
	 * */ 
	
	
	public void merginSort(int sort[]) {

		mSort(sort, 0, sort.length - 1);//往下看

	}

	private void mSort(int[] data, int left, int right) {

		if (left < right) {

			int center = (left + right) / 2;//一分为二

			mSort(data, left, center);//前面到中间的递归
			mSort(data, center + 1, right);//中午到最后的递归
			merge(data, left, center, right);//每一次都合并，合并往下看

		}
	}
	// 归并
	private void merge(int[] data, int left, int center, int right) {

		int[] tmpArr = new int[data.length];//一个临时数组

		int mid = center + 1;

		int thrid = left;
		int temp = left;

		while (left <= center && mid <= right) {//每一次挑一个出来，直到到前到的到中间或者后面的部分到了最后面
			if (data[left] <= data[mid]) {
				tmpArr[thrid++] = data[left++];
			} else {
				tmpArr[thrid++] = data[mid++];
			}

		}

		while (mid <= right) {//后面的数继续添加到临时数组
			tmpArr[thrid++] = data[mid++];
		}

		while (left <= center) {//前面部分没添加的继续添加到临时数组
			tmpArr[thrid++] = data[left++];
		}

		while (temp <= right) {//用有序的替换到无序的
			data[temp] = tmpArr[temp++];
		}

	}

	
	/***
	 * 快排：以一个选定的值分成大小两部分进行递归
	 * 
	 * 
	 * */
	public void quickSort(int[] sort) {

		qSort(sort, 0, sort.length - 1);//往下看
	}

	private void qSort(int[] sort, int low, int high) {

		int privot;//特定值
		if (low < high) {

			privot = partition(sort, low, high);//特值部分进行排序，往后看

			qSort(sort, low, privot - 1);
			qSort(sort, privot + 1, high);
		}

	}

	private int partition(int[] sort, int low, int high) {

		int privotkey;

		privotkey = sort[low]; // 这里是选取子数组中的第一个元素

		while (low < high) {//每一次都形成以中间值的为基准，左右都是基本有序

			while (low < high && sort[high] >= privotkey)//从后面开始望前比较，遇到比指定的值小的就跳出来
				high--;

			swap(sort, low, high);//交换

			while (low < high && sort[low] <= privotkey)//然后从前面往后面比较，遇到比指定的小大小就跳出来
				low++;

			swap(sort, low, high);//交换
		}

		return low;

	}
   //交换函数
	private void swap(int[] a, int numA, int numB) {

		int temp = a[numA];
		a[numA] = a[numB];
		a[numB] = temp;

	}

	

}