排序算法

算法的稳定性：

经过排序后相同的元素前后位置改变了就是不稳定的算法，反之就是稳定的！得出结论: 选择排序、快速排序、希尔排序、堆排序是不稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法

时间复杂度：

冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

　　冒泡排序算法的运作如下:

1.  比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.  对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.  针对所有的元素重复以上的步骤，除了最后一个。
4.  持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

   public class BubbleSort
   {
       public void sort(int[] a)
       {
           int temp = 0;
           for (int i = a.length - 1; i > 0; --i)
           {
               for (int j = 0; j < i; ++j)
               {
                   if (a[j + 1] < a[j])
                   {
                       temp = a[j];
                       a[j] = a[j + 1];
                       a[j + 1] = temp;
                   }
               }
           }
       }
   }

   #include <stdio.h>
   #define SIZE 8
    
   void bubble_sort(int a[], int n);
    
   void bubble_sort(int a[], int n)
   {
       int i, j, temp;
       for (j = 0; j < n - 1; j++)
           for (i = 0; i < n - 1 - j; i++)
           {
               if(a[i] > a[i + 1])
               {
                   temp = a[i];
                   a[i] = a[i + 1];
                   a[i + 1] = temp;
               }
           }
   }
    
   int main()
   {
       int number[SIZE] = {95, 45, 15, 78, 84, 51, 24, 12};
       int i;
       bubble_sort(number, SIZE);
       for (i = 0; i < SIZE; i++)
       {
           printf("%d", number[i]);
       }
       printf("\n");
   }

   
   
   快速排序 ：
   1）设置两个变量i、j， 排序开始的时候：i=0，j=N-1；
   2）以第一个数组元素作为关键数据，赋值给 key，即 key=A[0]；
   3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于 key的值A[j]，将A[j]和A[i]互换；
   4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于 key的A[i]，将A[i]和A[j]互换；
   5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于 key,4中A[i]不大于 key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

   void sort(int *a, int left, int right)
   {
       if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
       {
           return ;
       }
       int i = left;
       int j = right;
       int key = a[left];
        
       while(i < j)                               /*控制在当组内寻找一遍*/
       {
           while(i < j && key <= a[j])
           /*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
           序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/ 
           {
               j--;/*向前寻找*/
           }
            
           a[i] = a[j];
           /*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
           a[left]，那么就是给key）*/
            
           while(i < j && key >= a[i])
           /*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
           因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
           {
               i++;
           }
            
           a[j] = a[i];
       }
        
       a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
       sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
       sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
                          /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
   }

 function quickSort(array){
                function sort(prev, numsize){
                    var nonius = prev;
                    var j = numsize -1;
                    var flag = array[prev];
                    if ((numsize - prev) > 1) {
                        while(nonius < j){
                            for(; nonius < j; j--){
                                if (array[j] < flag) {
                                    array[nonius++] = array[j];　//a[i] = a[j]; i += 1;
                                    break;
                                };
                            }
                            for( ; nonius < j; nonius++){
                                if (array[nonius] > flag){
                                    array[j--] = array[nonius];
                                    break;
                                }
                            }
                        }
                        array[nonius] = flag;
                        sort(0, nonius);
                        sort(nonius + 1, numsize);
                    }
                }
                sort(0, array.length);
                return array;
            }

选择排序

对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则用一个变量k来记住他的位

置，接着第二次比较，前面“后一个元素”现变成了“前一个元素”，继续跟他的“后一个元素”进行比较如果后面

的元素比他要小则用变量k记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最小的那个数

的下标了，然后进行判断，如果这个元素的下标不是第一个元素的下标，就让第一个元素跟他交换一下值，这

样就找到整个数组中最小的数了。然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类

推。 选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元

素选择第二小的，依次类推。

图文过程：

//交换data1和data2所指向的整形  
void DataSwap(int* data1, int* data2)  
{  
    int temp = *data1;  
    *data1 = *data2;  
    *data2 = temp;  
}  
  
/******************************************************** 
*函数名称：SelectionSort 
*参数说明：pDataArray 无序数组； 
*          iDataNum为无序数据个数 
*说明：    选择排序 
*********************************************************/  
void SelectionSort(int* pDataArray, int iDataNum)  
{  
    for (int i = 0; i < iDataNum - 1; i++)    //从第一个位置开始  
    {  
        int index = i;  
        for (int j = i + 1; j < iDataNum; j++)    //寻找最小的数据索引   
            if (pDataArray[j] < pDataArray[index])  
                index = j;  
  
        if (index != i)    //如果最小数位置变化则交换  
            DataSwap(&pDataArray[index], &pDataArray[i]);  
    }  
}  

function selectSort(pDataArray){
                var iDataNum = pDataArray.length;
                for (var i = 0; i < iDataNum - 1; i++){
                    //从第一个位置开始
                    var index = i;
                    for (var j = i + 1; j < iDataNum; j++)  {
                        //寻找最小的数据索引
                        if (pDataArray[j] < pDataArray[index]){
                            index = j;
                        }
                    }
                    if (index != i){
                        //如果最小数位置变化则交换
                        var c = pDataArray[index];
                        pDataArray[index] = pDataArray[i];
                        pDataArray[i] = c;
                    }
                }
                return pDataArray;
            }