【数据结构】排序算法（一）之直接插入排序，冒泡排序

    排序算法在面试中是常见的,尤其是（插入排序，冒泡排序和快速排序），就抽个时间再复习一下排序算法吧

    插入排序的基本方法是：每步将一个待排序的记录按其关键字的大小插入到前面已经排序的序列中的适当位置，直到每个记录都插入完毕为止。

    1：直接插入排序   这是一种最简单的排序方法，它的基本思想是将待排序的记录分成两个部分，第一个部分已经排好序，第二个部分未排序好。排序中，每次都是从第二个部分中取出一条记录，将其插入到第一个部分，并且让它排好序。初始化时，任取一条记录作为第一个部分，而其他的数据作为第二个部分。然后随着排序的进行，第一个部分的数据会越来越多，第二部分越来越少。总有那么一次，第二部分会变为0，而第一部分会包含所有的数据并且是有序的。

    下面直接看排序过程图：(本例是显示从小到大的排序)

    初始化：[98] 45 13 47 58 34 09 73

     i=2     :  [45 98] 13 47 58 34 09 73

     i=3     :  [13 45 98] 47 58 34 09 73

     i=4     :  [13 45 47 98] 58 34 09 73

     i=5     :  [13 45 4758 98] 34
09 73

     i=6     :  [1334 45
47 58 98] 09 73

     i=7     :  [09 13 34 45
47 58 98]  73

     i=8     : [09 13 34 45
47 58 73 98] 

 
    下面用计算机程序去考虑直接插入排序：

 
    private static void Sort(int a[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = i; j < n; j++) {
if (a[j] < a[i]) {
int k = a[j];
a[j] = a[i];
a[i] = k;
}
}
}

}

 这个排序算法是稳定的，时间复杂度都是O(n^2)。从空间上面来看，它只需要记录的辅助的空间，该Demo是K。

 
2：下面就是冒泡排序，这个排序方法在面试中是非常常见的排序题目之一；

 
   冒泡排序是属于交换排序的范畴，类似于水泡从水中往上冒。具体的方法是：先将第一个记录的键值和第二个的键值相比较，如果a[0]>a[1],那么进行交换。然后比较第二个和第三个的键值，依次进行类推直到a[n-2]和a[n-1]记录进行比较完成，这个过程就可以形象的称为冒泡。这样一次冒泡之后，那么最大的就是第n大的传到第n个位置。然后对前面n-1个数据继续冒泡。第n-1大的数据拍到n-1个位置，重复以上的过程，每次排好一个数据，最多需要n-1次，就相当于把n个数据排序好

 
 下面看举例排序过程图:(本例是显示从小到大的排序)

 
第一趟冒泡的过程为:初始化数据为：98 45 13 47 58 34 09 73

 
  [45 98] 13 47 58 34 09 73  //98和45比较，交换

 
  45 [13 98] 47 58 34 09 73  //98和13比较，交换

 
  45 13 [47 98] 58 34 09 73  //98和47比较，交换

 
  45 13 47 [58 98] 34 09 73  //98和58比较，交换

 
  45 13 47 58 [34 98] 09 73  //98和34比较，交换

 
  45 13 47 58 34 [09 98] 73  //98和09比较，交换

 
  45 13 47 58 34 09 [73  98] //98和73比较，交换

 
这样最大的98被交换到最后，接下继续进行冒泡，每趟的结果如下:

 
 第二趟：13,45,47,34,9,58,73,98

 
 第三趟： 13,45,34,9,47,58,73,98

   第四趟：13,34,9,45,47,58,73,98

   第五趟:   13,9,34,45,47,58,73,98

   第六趟： 9,13,34,45,47,58,73,98

   第七趟： 9,13,34,45,47,58,73,98

 下面用计算机程序去考虑直接插入排序：

  private
static void Bubble_Sort(int a[], int n) {
for (int i = n - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (a[j] > a[j + 1]) {
int k = a[j];
a[j] = a[j + 1];
a[j + 1] = k;
}
}
System.out.println("\n");
Printf(a);
}
}

 
 两层嵌套，复杂度是O(n^2)

  

  下面进行上面的冒泡算法的改进，仔细分析上面的算法，我们发现每次冒泡都是很机械的从头比较到尾部，其实每次冒泡之后，后面的数据已经排序OK了，我们只要每次记录一下已经排序好的终点，改变每次冒泡排序比较的终点，这样效率会提高很多，尤其对于已经排序将近完成的记录进行排序。

 private static void Bubble_Sort_Improve(int a[], int n) {
int k = n - 1;
while (k > 0) {
int kk = 0;
for (int i = 0; i < k; i++) {
if (a[i] > a[i + 1]) {
int t = a[i];
a[i] = a[i + 1];
a[i + 1] = t;
kk = i;
}
}
k = kk;
}
}

 
   这样效率会提高一些，不过复杂度还是O(n^2)

 好了今天就先复习一下直接插入排序和冒泡排序

 
 Demo下载链接地址：http://download.csdn.net/detail/jiangqq781931404/4032051