算法导论小结（一）

用了几个月磕磕绊绊的总算把《算法导论》一书看完了，在此写篇博客总结一下学习到的知识。

首先先放上《算法导论》的思维导图：

算法导论思维导图

由于本人的理解能力有限，故部分较难懂的内容没有加入到该思维导图中。

1.排序

排序问题是我们日常生活中经常遇到的一个问题，因此算法导论也把排序作为整个算法介绍的入门篇。在这么多排序算法里面，目前经典的排序算法有以下几种：

1.插入排序

对于少量元素的排序，插入排序是一个有效的算法。它的工作方式就像我们排序扑克牌一样，每次把一张新的扑克牌插入到已经排好序的序列中。假设排序序列的长度为n，由于插入排序每次加入一个新的元素都需要遍历几乎整个排好序的序列，故他的时间复杂度为O(n^2)。
以下为插入排序的Java代码：
[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = {5, 2, 4, 6, 1, 3};  
  5.           
  6.         InsertionSort(A);  
  7.           
  8.         for(int num : A)  
  9.             System.out.println(num);  
  10.     }  
  11.   
  12.     // 插入排序  
  13.     public static void InsertionSort(int A[]) {  
  14.         for (int i = 1; i < A.length; i++) {  
  15.             int key = A[i];  
  16.             int j = i-1;  
  17.             while(j >= 0 && A[j] > key) {  
  18.                 A[j+1] = A[j];  
  19.                 j--;  
  20.             }  
  21.             A[j+1] = key;  
  22.         }  
  23.     }  
  24.       
  25. }  

插入排序还有一种变种，称为希尔排序，即Shell Sort，也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本，是一种非稳定排序算法。希尔排序是把数组按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，整个数组恰被分成一组，算法便终止。由于希尔排序的时间复杂度与增量的选取有关，在此不作深入讨论。

希尔排序的Java代码如下所示：

[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = { 5, 2, 4, 1, 3, 6 };  
  5.         int ds[] = { 4, 2, 1 }; // 最后为1使得排序最终成功  
  6.   
  7.         ShellSort(A, ds);  
  8.   
  9.         for (int num : A)  
  10.             System.out.println(num);  
  11.     }  
  12.   
  13.     /** 
  14.      * 希尔排序 
  15.      *  
  16.      * @param nums 
  17.      *            待排序数组 
  18.      * @param ds 
  19.      *            增量数组 
  20.      */  
  21.     public static void ShellSort(int nums[], int ds[]) {  
  22.         for (int d : ds) {  
  23.             // 分为d组  
  24.             for (int i = 0; i < d; i++) {  
  25.                 // 插入排序  
  26.                 for (int j = 0; j + d < nums.length; j += d) {  
  27.                     int key = nums[j + d];  
  28.                     int k = j;  
  29.                     while (k >= 0 && key < nums[k]) {  
  30.                         nums[k+d] = nums[k];  
  31.                         k -= d;  
  32.                     }  
  33.                     nums[k+d] = key;  
  34.                 }  
  35.             }  
  36.         }  
  37.     }  
  38. }  


2.冒泡排序

冒泡排序与插入排序类似，也是一种较为简单的排序算法。冒泡排序会重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，因此越大的元素会经由交换慢慢“浮”到数列的顶端，这就是这种排序方法命名的原因。由于需要两层循环遍历数组，所以冒泡排序的时间复杂度为O(n^2)。
以下为冒泡排序的Java代码：
[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = {5, 2, 4, 6, 1, 3};  
  5.           
  6.         BubbleSort(A);  
  7.           
  8.         for(int num : A)  
  9.             System.out.println(num);  
  10.     }  
  11.   
  12.     // 冒泡排序  
  13.     public static void BubbleSort(int A[]) {  
  14.         for (int i = 0; i < A.length; i++) {  
  15.             for (int j = 1; j < A.length - i; j++) {  
  16.                 // 如果前面的元素比后面的大，则发生交换  
  17.                 if (A[j-1] > A[j]) {  
  18.                     int temp = A[j];  
  19.                     A[j] = A[j-1];  
  20.                     A[j-1] = temp;  
  21.                 }  
  22.             }  
  23.         }  
  24.     }  
  25. }  

实际上面的冒泡排序代码还可以进行一点小优化，要是循环中没有发生交换则可直接退出：
[java] view plain copy
 
  1. // 冒泡排序(优化)  
  2.     public static void BubbleSortII(int A[]) {  
  3.         boolean swap = false; // 是否发生过交换  
  4.         for (int i = 0; i < A.length; i++) {  
  5.             swap = false;  
  6.             for (int j = 1; j < A.length - i; j++) {  
  7.                 // 如果前面的元素比后面的大，则发生交换  
  8.                 if (A[j-1] > A[j]) {  
  9.                     swap = true;  
  10.                     int temp = A[j];  
  11.                     A[j] = A[j-1];  
  12.                     A[j-1] = temp;  
  13.                 }  
  14.             }  
  15.             // 没有发生过交换，已经排序完毕，可跳出循环  
  16.             if (swap == false)  
  17.                 break;  
  18.         }  
  19.     }  

3.归并排序

要提到归并排序就不得不讲到分治法（Divide and Conquer），分治法的思想是：把原问题分解成为几个规模较小，但类似于原问题的子问题，递归的去求解这些子问题，然后再合并这些子问题的解来建立原问题的解。归并排序就是是采用分治法的一个非常典型的应用。它是建立在归并操作上的一种有效的排序算法,该算法将已有序的子序列合并，得到完全有序的序列。用扑克牌来举例：在排序一副扑克牌的时候，我们现将其分成两叠大小相近的扑克牌，分别排序，然后我们再把这两叠已经排好序的扑克牌合并成一副更大的排好序的扑克牌，此时只需要每次比较两叠扑克牌的第一张牌即可。归并排序的图解如下：
归并排序
设序列中有N个元素需要排序，则由上图易得可以把排序过程分为logN（以2为低的对数）次处理，每次循环N次，故归并排序的时间复杂度为O(N*logN)。
归并排序的Java代码如下：
[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = {5, 2, 4, 6, 1, 3};  
  5.           
  6.         MergeSort(A, 0, A.length-1);  
  7.           
  8.         for(int num : A)  
  9.             System.out.println(num);  
  10.     }  
  11.   
  12.     public static void MergeSort(int A[], int start, int end) {  
  13.         if (start < end) {  
  14.             // 中点  
  15.             int mid = (start+end)/2;  
  16.             // 子序列分别排序  
  17.             MergeSort(A, start, mid);  
  18.             MergeSort(A, mid+1, end);  
  19.             // 合并  
  20.             // 把子序列存到新数组中  
  21.             int leftLen = mid-start+1, rightLen = end-mid;  
  22.             int leftCounter = 0, rightCounter = 0, numCounter = start;  
  23.             int L[] = new int[leftLen], R[] = new int[rightLen];  
  24.             for (int i = 0; i < leftLen; i++)  
  25.                 L[i] = A[start+i];  
  26.             for (int i = 0; i < rightLen; i++)  
  27.                 R[i] = A[mid+1+i];  
  28.             // 比较子序列第一项元素  
  29.             while(leftCounter < leftLen && rightCounter < rightLen) {  
  30.                 if(L[leftCounter] < R[rightCounter])  
  31.                     A[numCounter++] = L[leftCounter++];  
  32.                 else  
  33.                     A[numCounter++] = R[rightCounter++];  
  34.             }  
  35.             // 把剩余的子序列加到后面  
  36.             while(leftCounter < leftLen)  
  37.                 A[numCounter++] = L[leftCounter++];  
  38.             while(rightCounter < rightLen)  
  39.                 A[numCounter++] = R[rightCounter++];  
  40.         }  
  41.     }  
  42. }  
 
更新非递归版本的归并排序：
[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = { 5, 2, 4, 1, 3, 6};  
  5.   
  6.         MergeSort(A);  
  7.   
  8.         for (int num : A)  
  9.             System.out.println(num);  
  10.     }  
  11.   
  12.     public static void MergeSort(int A[]) {  
  13.         int len = A.length;  
  14.         int temp[] = new int[len];  
  15.         int leftMin, leftMax, rightMin, rightMax; // leftMin ～ leftMax, rightMin  
  16.                                                     // ～ rightMax  
  17.         for (int i = 1; i < len; i *= 2) {  
  18.             leftMin = leftMax = rightMin = rightMax = 0;  
  19.             while (leftMin < len) {  
  20.                 rightMin = leftMax = leftMin + i;  
  21.                 rightMax = rightMin + i;  
  22.                 if (rightMax > len)  
  23.                     rightMax = len;  
  24.                 if (rightMin > rightMax)  
  25.                     leftMax = rightMin = rightMax;  
  26.                 int counter = 0;  
  27.                 while (leftMin < leftMax && rightMin < rightMax)  
  28.                     temp[counter++] = A[leftMin] > A[rightMin] ? A[rightMin++]  
  29.                             : A[leftMin++];  
  30.   
  31.                 while (leftMin < leftMax)  
  32.                     A[--rightMin] = A[--leftMax];  
  33.   
  34.                 while (counter > 0)  
  35.                     A[--rightMin] = temp[--counter];  
  36.                 leftMin = rightMax;  
  37.             }  
  38.         }  
  39.     }  
  40. }  


4.堆排序

首先我们来看看什么是堆：
堆结构
如上图所示（二叉）堆是一个数组，它可以被看成一个近似的完全二叉树，树上每一个结点对应数组中的一个元素。除了最底层外，该树是完全充满的，而且是从左到右填充。在堆中，给定一个结点下标i（对于起始下标为1而言），则它的父节点为i/2，它的左孩子下标为i*2，右孩子下标为i*2+1。堆中结点的高度被定义为该结点到叶结点的最长简单路径，由数学公式可得含N个元素的堆高度为logN。
二叉堆可以分为两种形式：最大堆和最小堆，他们除了满足堆的基本性质外，最大堆满足：除了根结点外，所有结点的值小于等于父节点，最小堆反之。在堆排序算法中，我们使用最大堆，最小堆通常用于构造优先队列。
以下为Java的堆排序：
[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = { 5, 2, 4, 6, 1, 3 };  
  5.   
  6.         HeapSort(A);  
  7.   
  8.         for (int num : A)  
  9.             System.out.println(num);  
  10.     }  
  11.   
  12.     public static void HeapSort(int A[]) {  
  13.         BuildMaxHeap(A);  
  14.         for (int i = A.length - 1; i > 0; i--) {  
  15.             // 把根结点和最后的结点对调  
  16.             int temp = A[i];  
  17.             A[i] = A[0];  
  18.             A[0] = temp;  
  19.             // 对根结点进行最大堆性质维护  
  20.             MaxHeapify(A, i, 0);  
  21.         }  
  22.     }  
  23.   
  24.     /** 
  25.      * 建立最大堆 
  26.      *  
  27.      * @param A 
  28.      *            数组 
  29.      */  
  30.     private static void BuildMaxHeap(int A[]) {  
  31.         int heapSize = A.length;  
  32.         // heapSize/2 ~ heapSize-1 均为叶结点，对非叶结点调用维护最大堆性质方法即可  
  33.         for (int i = heapSize / 2 - 1; i >= 0; i--)  
  34.             MaxHeapify(A, heapSize, i);  
  35.     }  
  36.   
  37.     /** 
  38.      * 维护最大堆的性质，调整下标为i的结点位置 
  39.      * @param A 数组 
  40.      * @param heapSize 堆大小 
  41.      * @param index 结点下标 
  42.      */  
  43.     private static void MaxHeapify(int A[], int heapSize, int index) {  
  44.         int left = index*2+1, right = index*2+2, largest = index;  
  45.         // 选取父结点，左结点，右结点中值最大的当父结点  
  46.         if (left < heapSize && A[left] > A[index])  
  47.             largest = left;  
  48.         if (right < heapSize && A[right] > A[largest])  
  49.             largest = right;  
  50.         // 若子结点充当了父结点，对子结点递归调用方法维护最大堆性质  
  51.         if (largest != index) {  
  52.             int temp = A[largest];  
  53.             A[largest] = A[index];  
  54.             A[index] = temp;  
  55.             MaxHeapify(A, heapSize, largest);  
  56.         }  
  57.     }  
  58. }  


 
 
首先来看看MaxHeapify方法，该方法是用于维护最大堆性质的方法。若方法调整的结点发生了交换，则对其子结点递归的调用该方法继续维护最大堆性质，故该方法的调用次数与堆的高度有关，时间复杂度为O(h) = O(logN)。
再来看看BuildMaxHeap方法，该方法用于把一个无序的数组构造成一个最大堆。该方法自底向上对非叶结点调用MaxHeapify，咋看其时间复杂度为O(N*logN)，但由数学推导可得其紧确时间复杂度为线性时间，此处不给出证明。
最后再来看HeapSort方法，堆排序首先把一个数组构造成最大堆，然后每次让堆的根结点（堆最大的元素）和堆最后的结点交换，并减少堆的大小，然后再对根结点调用MaxHeapify方法调整其位置。堆排序总共调用了N次MaxHeapify方法，故其时间复杂度为O(N*logN)

5.快速排序

快速排序也被称为霍尔排序，虽然快速排序的最坏时间复杂度为O(N^2)，但是快速排序通常是实际排序应用中最好的选择，因为他的平均性能很好，期望时间复杂度为O(N*lgN)。快速排序与归并排序类似，都使用了分治思想。快速排序每次从数组中选择一个元素作为主元，把比主元小的元素放在其前面，把比主元大的元素方法主元的后面，然后再对其前后两个子数组进行相同的操作。
快速排序的Java代码如下所示：
[java] view plain copy
 
  1. public class Algorithm {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int A[] = {5, 2, 4, 6, 1, 3};  
  5.           
  6.         QuickSort(A, 0, A.length-1);  
  7.           
  8.         for(int num : A)  
  9.             System.out.println(num);  
  10.     }  
  11.   
  12.     public static void QuickSort(int A[], int start, int end) {  
  13.         if (start < end) {  
  14.             // 主元  
  15.             int key = A[end];  
  16.             int i = start-1;  
  17.             for (int j = start; j < end; j++) {  
  18.                 // 比key小的数放在前面  
  19.                 if (A[j] < key) {  
  20.                     i++;  
  21.                     int temp = A[j];  
  22.                     A[j] = A[i];  
  23.                     A[i] = temp;  
  24.                 }  
  25.             }  
  26.             i++;  
  27.             A[end] = A[i];  
  28.             A[i] = key;  
  29.             // 对子数组进行同样的操作  
  30.             QuickSort(A, start, i-1);  
  31.             QuickSort(A, i+1, end);  
  32.         }  
  33.     }  
  34. }  

上面的代码固定选取当前数组的最后一个元素作为主元，如果想要快速排序的平均性能更好，可以随机选取数组中的元素作为主元来减少出现最坏情况的概率。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/KingIceMou/p/6984136.html