八大内部排序算法（上）-冒泡、直接插入、简单选择、快速

八大内部排序算法（上）冒泡、直接插入、简单选择、快速

排序分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

我们这里说说八大排序就是内部排序。

1.直接插入排序

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

直接插入实现如下：

        /*
	 * 1.插入排序
	 * 思想：每遍历一次，都把数组中下表为当前遍历次数的数字插入到已经排好的顺序当中去
	 * 插入排序中，总是先寻找插入位置，然后在实行挪动和插入过程；寻找插入位置采用顺序查找的方式（从前向后或者从后向前），
	 * 既然需要插入的数组已经是有序的，那么可以采用二分查找方法来寻找插入位置，提高算法效率，但算法的时间复杂度仍为O(n2)。
	 */
	public void insertSort(Integer []array){
		int size=array.length;
		int temp;
		System.out.println("插入排序结果：");
		for(int i=1;i<size;i++){
			if(array[i]<array[i-1]){
				for(int j=i;j>0;j--){
					if(array[j]<array[j-1]){
						temp = array[j-1];
						array[j-1] = array[j];
						array[j] = temp;
					}
				}
				//=========输出排序详情
				System.out.print("第" + (i) +"次:");
				for (int j = 0; j < array.length; j++) {
					System.out.print(array[j] + " ");
				}
				System.out.println();
			}
		}
	}

2.简单选择排序

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。具体实现如下

<span style="white-space:pre">	</span>/*
	 * 2.简单选择排序
	 * 思想:遍历数组剩余数字，每次选择最小的一个数和当前的遍历次数位置数字替换
	 */
	public void choiceSort(Integer []array){
		int size=array.length;
		System.out.println("\n选择排序：");
		for (int i = 0; i < size; i++) {
			int temp = array[i],min=i;
			for (int j = size-1; j >=i; j--) {
				if(array[j] <temp){
					temp = array[j];
					min=j;
				}
			}
			if(min!=i){
				array[min]=array[i];
				array[i]=temp;
			}
			//=========输出排序详情
			System.out.print("第" + (i+1) +"次:");
			for (int j = 0; j < array.length; j++) {
				System.out.print(array[j] + " ");
			}
			System.out.println();
		}
	}

3.冒泡排序

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

//3.冒泡排序
    public void Bubble_Sort(Integer []array){
        int size = array.length;
        int tmp;
        System.out.println("冒泡排序结果：");
        for(int i=0;i<size;i++){
            for(int j=size-1;j>i;j--){
                if(array[j]<array[j-1]){
                    tmp=array[j-1];
                    array[j-1]=array[j];
                    array[j]=tmp;
                }
            }
            //=========输出排序详情
            System.out.print("第" + (i+1) +"次:");
            for (int j = 0; j < array.length; j++) {
                System.out.print(array[j] + " ");
            }
            System.out.println();
        }
    }

4.快速排序

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

具体实现如下：

/*
     * 4.快速排序
     */
    public void QuickSort(Integer []array, int low, int high){
        int i=low,j=high;
        if(i<j){
            int po = array[low];
            while(i<j){
                while(i<j && po<array[j]){
                    j--;
                }
                if(i<j){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    i++;
                }
                while(i<j && po>array[i]){
                    i++;
                }
                if(i<j){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    j--;
                }
            }
            QuickSort(array,low,j-1);
            QuickSort(array,j+1,high);
        }
    }

测试：

package com.devin.sequence;
/**
 *
 * @JavaTest
 * @author  刘帝伟
 * @date    创建时间：2015年4月14日 下午3:19:35
 * @version 2015年4月14日
 *
 */
public class Test {

	public static void main(String[] args) {
		Integer [] array = {1,33,3,14,5,71,6,88};

		Test t = new Test();
		//t.Bubble_Sort(array);
		System.out.println();
//		t.insertSort(array);
		//t.choiceSort(array);
		//快速排序
		t.QuickSort(array, 0, array.length-1);
		System.out.println();
		for (int j2 = 0; j2 < array.length; j2++) {
			System.err.print (array[j2]+" ");
		}
	}
}