几个简单的排序算法（java版）

前言

几个简单的排序算法（java版），这里主要介绍冒泡算法、选择排序、插入排序算法及简单的java代码实现。

内容

1.   冒泡排序算法

冒泡排序是最简单的排序算法，基本的算法思想：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

算法步骤如下：

1）  假设有待排序的队列元素N个；

2）  设置参数out = N-1 ;

3）  设置参数 i = 0;

4）  将Ni(第i个元素)与Ni+1(第i+1个元素)作比较，如果Ni>Ni+1则交换位置；

5）  i加1，重复4）步，直到i= out – 1;

6）  置out = N – 2,重复3）、4）、5）步骤，直到out = 1，算法结束；

java实现代码如下：

package learn.sort;
/**
* @Description: 冒泡排序
* @author 柯颖波
* @date Jul 31, 2013 3:25:46 PM 
* @version v1.0
 */
public class BubbleSort {
	private int datas[];// 存放排序数的数组
	private int index;// 数组索引

	public BubbleSort(int max) {
		datas = new int[max];
		index = 0;
	}

	// 插入单个数据
	public void insertData(int data) {
		datas[index++] = data;
	}

	// 打印数组
	public void display() {
		for (int i = 0; i < index; i++) {
			System.out.print(" " + datas[i]);
		}
		System.out.println("");
	}

	// 执行排序,指定升序或降序
	public void sort() {
		for (int i = index - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if (datas[j] > datas[j + 1]) {
					int temp = datas[j];
					datas[j] = datas[j + 1];
					datas[j + 1] = temp;
				}
			}
		}
	}

	public static void main(String[] args) {
		BubbleSort arr = new BubbleSort(10);
		arr.insertData(2);
		arr.insertData(3);
		arr.insertData(5);
		arr.insertData(6);
		arr.insertData(1);
		arr.insertData(8);
		arr.insertData(6);
		arr.insertData(6);
		arr.insertData(9);
		
		System.out.println("排序前：");
		arr.display();
		arr.sort();
		System.out.println("排序后：");
		arr.display();
	}
}

2.   选择排序算法

选择排序的算法思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

算法步骤如下：

1）  假设有待排序的队列元素N个；

2）  设置参数out = N-1 ;

3）  设置参数 i = 0;

4）  设置参数 max = Ni,maxIndex = I;

5）  将Ni(第i个元素)与Ni+1(第i+1个元素)作比较，如果Ni+1>Ni则max =Ni+1;maxIndex = i+1；

6）  in加1，重复5）步，直到i = out – 1则N(out)与N(maxIndex)元素作交换;

7）  置out = N – 2,重复3）、4）、5）步骤，直到out = 1，算法结束；

java实现代码如下：

package learn.sort;
/**
* @Description: 选择排序
* @author 柯颖波
* @date Jul 31, 2013 3:25:46 PM 
* @version v1.0
 */
public class SelectionSort {
	private int datas[];// 存放排序数的数组
	private int index;// 数组索引

	public SelectionSort(int max) {
		datas = new int[max];
		index = 0;
	}

	// 插入单个数据
	public void insertData(int data) {
		datas[index++] = data;
	}

	// 打印数组
	public void display() {
		for (int i = 0; i < index; i++) {
			System.out.print(" " + datas[i]);
		}
		System.out.println("");
	}

	// 执行排序,指定升序或降序
	public void sort() {
		for (int i = index - 1; i > 0; i--) {
			int max = datas[i];
			int maxindex = i;
			for (int j = 0; j < i; j++) {
				if (datas[j] > max) {
					max = datas[j];
					maxindex = j;
				}
			}
			datas[maxindex] = datas[i];
			datas[i] = max;
		}
	}

	public static void main(String[] args) {
		SelectionSort arr = new SelectionSort(10);
		arr.insertData(2);
		arr.insertData(3);
		arr.insertData(5);
		arr.insertData(6);
		arr.insertData(1);
		arr.insertData(8);
		arr.insertData(6);
		arr.insertData(6);
		arr.insertData(9);
		
		System.out.println("排序前：");
		arr.display();
		arr.sort();
		System.out.println("排序后：");
		arr.display();
	}
}

3.   插入排序算法

插入排序算法思想：将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素。在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的位置。

算法步骤：

1）  从有序数列和无序数列{a2,a3，…，an}开始进行排序；

2）  ⒉处理第i个元素时（i=2,3，…，n），数列{a1,a2，…，ai-1}是已有序的，而数列{ai,ai+1，…，an}是无序的。用ai与ai-1，a i-2，…，a1进行比较，找出合适的位置将ai插入；

3）  ⒊重复第二步，共进行n-i次插入处理，数列全部有序。

java实现代码如下：

package learn.sort;

import java.util.Random;

import sun.misc.Sort;

import com.sun.rsasign.a0;

/**
 * @Description: 插入排序
 * @author 柯颖波
 * @date Jul 31, 2013 3:25:46 PM
 * @version v1.0
 */
public class InsertSort {
	private int datas[];// 存放排序数的数组
	private int index;// 数组索引

	public InsertSort(int max) {
		datas = new int[max];
		index = 0;
	}

	// 插入单个数据
	public void insertData(int data) {
		datas[index++] = data;
	}

	// 打印数组
	public void display() {
		for (int i = 0; i < index; i++) {
			System.out.print(" " + datas[i]);
		}
		System.out.println("");
	}

	// 执行排序
	public void sort() {
		// 方式1
		/*for (int i = 1; i < index; i++) {
			int insertIndex = i;
			int temp = datas[i];
			for (int j = 0; j < i; j++) {
				if (datas[j] > datas[i]) {
					insertIndex = j;
					break;
				}
			}
			for (int j = i; j > insertIndex; j--) {
				datas[j] = datas[j - 1];
			}
			datas[insertIndex] = temp;
		}*/
		// 方式2
		for (int i = 1; i < index; i++) {
			int insertIndex = i;
			int temp = datas[i];
			while (insertIndex > 0 && datas[insertIndex - 1] > temp) {
				datas[insertIndex] = datas[insertIndex - 1];
				//System.out.println("交换");
				insertIndex--;
			}
			datas[insertIndex] = temp;
		}
	}

	public static void main(String[] args) {
		int max = 100;
		InsertSort arr = new InsertSort(max);
		for (int i = 0; i < max; i++) {
			arr.insertData((int)Math.random()*(max -1));
		}
		arr.sort();
		arr.display();
		System.out.println("end");
	}
}