java 数据结构学习之（二） 简单排序

冒泡排序最经典：

public void BubbleSort1(){

		for (int i = nElement - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if(arr[j] > arr[j+1]){
					swap(j,j+1);
				}
			}
		}
	}

private void swap(int a,int b){
	    arr[a] = arr[a] + arr[b];
		arr[b] = arr[a] - arr[b];
		arr[a] = arr[a] - arr[b];
	}

 

以下是冒泡排序排序的改进版本：

 

/**（优化后的冒泡排序）
	 * 双向冒泡排序 
	 * ps: 获取最大的数放在最右边后，回头获取最小的数放在最左边。以此类推，外层循环次数 n / 2，貌似比单向冒泡快一点。
	 */
	public void BubbleSort2(){
		int i,j,k,left = 0,right = nElement - 1;
		for (i = nElement/2; i > 0; i--) {
			for (j = left; j < right; j++) {
				if(arr[j] > arr[j+1]){
					swap(j,j+1);
				}
			}
			for (k = right - 1; k > left; k--) {
				if(arr[k] < arr[k - 1] ){
					swap(k,k - 1);
				}
			}
			left++;
			right--;
		}
	}
	
	/**（优化后的冒泡排序）
	 * ps:如果 有一次比较没有做任何数据移动，说明已经排好序了，可以结束比较了。
	 */
	public void BubbleSort3(){
		boolean isSorted = false;
		for (int i = nElement - 1; i > 0 && !isSorted; i--) {
			isSorted = true;//假设已经排好序
			for (int j = 0; j < i; j++) {
				if(arr[j] > arr[j + 1]){
					swap(j,j + 1);
					isSorted = false;
				}
			}
		}
	}
	
	/**（优化后的冒泡排序）
	 * ps:记录最后一次交换位置，这样就可以确定到底那些区域还没有排好序，缩小比较范围。
	 */
	public void BubbleSort4(){
		int lastIndex = nElement - 1,j=0;
		while(lastIndex > 0){
			for (int i = j = 0; i < lastIndex; i++) {
				if(arr[i] > arr[i + 1]){
					swap(i, i+1);
					j = i;
				}
			}
			lastIndex = j;
		}
	}

 

其中BubbleSort2减少了每次比较的次数，提高了效率。而3，4这两个方法也是同样的原理，减少了可能会做的无用功。

 

下面是选择排序，这个排序是通过减少移动数组的次数来提高效率的。

 

public void selectSort() {
		for (int i = 0; i < nElement - 1; i++) {
			int k = i;
			for (int j = i + 1; j < nElement; j++) {
				if (arr[k] > arr[j]) {
					k = j;
				}
			}
			if (k != i) {
				swap(k, i);
			}
		}
	}

 

最后是选择排序，这个排序比冒泡排序应该要快一倍，比选择排序要快一点。如果是倒序排序的话，则可能没有优势，在基本有序的情况下还是可以的。

 

public void insertSort(){
		int repeat = 0,t = 0;
		for (int i = 1; i < nElement; i++) {
			int j = i;
			while (j > t && arr[i] <= arr[j - 1]){
				//发现重复值 设置为-1
				if(arr[i]==arr[j - 1]){
					arr[i] = -1;
					repeat++;
				}
				--j;
			}
			t = repeat;
			if(j < i){
				int temp = arr[i];
				for (int k = i; k > j; k--) {
					arr[k] = arr[k - 1];
				}
				arr[j] = temp;
			}
		}
		if(repeat > 0){
			nElement = nElement - repeat;
			for (int i = 0; i < nElement; i++) {
				arr[i] = arr[i + repeat];
			}
		}
		
	}

上面这个排序还加了个删除重复值的功能。

 

另外一种实现，感觉没有上面的效率高

 

public void insertSort2(){
		for (int i = 1; i < nElement; i++) {
			int j = i;
			int temp = arr[i];
			while(j > 0 && temp < arr[j - 1]){
				arr[j] = arr[--j];
			}
			arr[j] = temp;
		}
	}

效率没有第一种高的环境是在倒序的情况下，因为这个环境下移动的次数比较多，原来分开移动没有一次性移动快。其他情况下是差不多的。

下面贴出所有的代码

 

package sort;

public class Sort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Sort o = new Sort(10000);
		for (int i = 10; i > 0; i--) {
			o.insert(i);
		}
		o.insert(9);
		o.insert(8);
		/*for (int i = 0; i < 10000; i++) {
			o.insert(i);
		}*/
		long begin = System.currentTimeMillis();
		o.insertSort();
		long end = System.currentTimeMillis();
		System.out.println("time="+(end - begin));
		o.display();
	}

	private int[] arr = null;
	private int nElement = 0;//当前数组的实际长度
	public Sort(int size){
		this.arr = new int[size];
		this.nElement = 0;
	}
	
	public int[] getArr(){return this.arr;}
	
	/**插入
	 * @param c
	 */
	public void insert(int c){
		arr[nElement++] = c;
	}
	
	public void BubbleSort1(){
		for (int i = nElement - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if(arr[j] > arr[j+1]){
					swap(j,j+1);
				}
			}
		}
	}
	
	/**（优化后的冒泡排序）
	 * 双向冒泡排序 
	 * ps: 获取最大的数放在最右边后，回头获取最小的数放在最左边。以此类推，外层循环次数 n / 2，貌似比单向冒泡快一点。
	 */
	public void BubbleSort2(){
		int i,j,k,left = 0,right = nElement - 1;
		for (i = nElement/2; i > 0; i--) {
			for (j = left; j < right; j++) {
				if(arr[j] > arr[j+1]){
					swap(j,j+1);
				}
			}
			for (k = right - 1; k > left; k--) {
				if(arr[k] < arr[k - 1] ){
					swap(k,k - 1);
				}
			}
			left++;
			right--;
		}
	}
	
	/**（优化后的冒泡排序）
	 * ps:如果 有一次比较没有做任何数据移动，说明已经排好序了，可以结束比较了。
	 */
	public void BubbleSort3(){
		boolean isSorted = false;
		for (int i = nElement - 1; i > 0 && !isSorted; i--) {
			isSorted = true;//假设已经排好序
			for (int j = 0; j < i; j++) {
				if(arr[j] > arr[j + 1]){
					swap(j,j + 1);
					isSorted = false;
				}
			}
		}
	}
	
	/**（优化后的冒泡排序）
	 * ps:记录最后一次交换位置，这样就可以确定到底那些区域还没有排好序，缩小比较范围。
	 */
	public void BubbleSort4(){
		int lastIndex = nElement - 1,j=0;
		while(lastIndex > 0){
			for (int i = j = 0; i < lastIndex; i++) {
				if(arr[i] > arr[i + 1]){
					swap(i, i+1);
					j = i;
				}
			}
			lastIndex = j;
		}
	}
	
	/**
	 * 奇偶排序 
	 * 第一次比较奇数对，第二次比较偶数对。
	 * 听说如果是多处理器这样排序效率高 
	 */
	public void OddEvenSort(){
		boolean isSorted = false;int i=0;
		while(!isSorted){
			i++;
			isSorted = OddOrEventSort(0) || OddOrEventSort(1);
		}
		System.out.println(i);
	}
	
	private boolean OddOrEventSort(int i){
		boolean isSorted = true;
		for (int j = i; j < nElement - 1; j+=2) {
			if(arr[j] > arr[j+1]){
				swap(j, j+1);
				isSorted = false;
			}
		}
		return isSorted;
	}
	
	public void insertSort(){
		int repeat = 0,t = 0;
		for (int i = 1; i < nElement; i++) {
			int j = i;
			while (j > t && arr[i] <= arr[j - 1]){
				//发现重复值 设置为-1
				if(arr[i]==arr[j - 1]){
					arr[i] = -1;
					repeat++;
				}
				--j;
			}
			t = repeat;
			if(j < i){
				int temp = arr[i];
				for (int k = i; k > j; k--) {
					arr[k] = arr[k - 1];
				}
				arr[j] = temp;
			}
		}
		if(repeat > 0){
			nElement = nElement - repeat;
			for (int i = 0; i < nElement; i++) {
				arr[i] = arr[i + repeat];
			}
		}
		
	}
	
	public void insertSort2(){
		for (int i = 1; i < nElement; i++) {
			int j = i;
			int temp = arr[i];
			while(j > 0 && temp < arr[j - 1]){
				arr[j] = arr[--j];
			}
			arr[j] = temp;
		}
	}
	
	public static void insertSort(int[] elements){ 
        for(int i = 1;i <elements.length; i++){ 
            int j = -1; 
            while(j <= i && elements[i] > elements[++j]);//找到element[i]应该摆放的位置，此处可以利用查找算法进行优化 
            if(j < i){ 
                //将j之后的数据移动一位，然后把elements[i]移动到j处 
                int temp = elements[i]; 
                for(int k = i-1;k >= j;k--){ 
                    elements[k+1] = elements[k]; 
                } 
                elements[j] = temp; 
            } 
        } 
}
	
	public void selectSort() {
		for (int i = 0; i < nElement - 1; i++) {
			int k = i;
			for (int j = i + 1; j < nElement; j++) {
				if (arr[k] > arr[j]) {
					k = j;
				}
			}
			if (k != i) {
				swap(k, i);
			}
		}
	}
	public void display(){
		for (int i = 0; i <nElement; i++) {
			System.out.println(arr[i]);
		}
	}
	
	private void swap(int a,int b){
	    arr[a] = arr[a] + arr[b];
		arr[b] = arr[a] - arr[b];
		arr[a] = arr[a] - arr[b];
	}
}