基础知识(排序算法)

今年任务很繁重，找工作应是重中之重。。。在此记录下复习基础知识的过程。

排序是程序开发中一种非常常见的操作，是对任意的一组数据经过排序操作后，就可以把他们变成一组按关键字排列的有序序列。对一个排序算法来说，一般从如下3个方面衡量算法的优劣：

时间复杂度：主要是分析关键字的比较次数和记录的移动次数。

空间复杂度：分析排序算法中需要多少辅助内存。

稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种算法是稳定的；反之，就是不稳定的。

 排序算法大致有直接插入排序、折半插入排序、Shell排序、归并排序、直接选择排序、堆排序、冒泡排序、快速排序、桶式排序、基数排序等这些种，各个算法都有其优异性，大家不妨自己看看。下面贴上每个算法的简单讲解和实现。

1.直接选择排序（DirectSelectSort）：其关键就是对n个数据要进行n-1趟比较，每趟比较的目的就是选择出本趟比较中最小的数据，并将选择出的数据放在本趟中的第一位。实现如下： 

public static void directSelectSort(int[] data){
        int minData = 0 ;
        int index = 0;
        for(int i = 0;i < data.length-1; i++){
            minData = data[i];
            index = i;
            for(int j = i+1;j<data.length;j++){
                if(minData >= data[j]){
                    minData = data[j];
                    index = j;
                }                    
            }
            data[index] = data[i];
            data[i]=minData;
            
        }
    }

 

2.堆排序（HeapSort）:先说下堆的概念，假设有n个数据元素的序列k0,k1,k2,k3,...,kn-1,当且仅当满足下列关系时，可以将这组数据称为小顶堆，即ki <= k2i+1且 ki<= k2i+2(其中i=0,2,4,...,(n-1)/2);或者，满足如下关系成为大顶堆，即ki >= k2*i+1且 ki >= k2*i+2(其中i=0,2,...,(n-1)/2)。如果将堆排成一棵完全二叉树，则小顶堆的特点是：树中所有节点的值都小于其左右节点的值，且根节点的值最小；而大顶堆相反。堆排序的关键在于：1.建堆（大顶堆或小顶堆）2.拿堆的根节点和最后一个节点交换。

    public static void heapSort(int[] data){
        for(int i = 0;i < data.length-1;i++){
            buildMaxHeap(data,data.length-1-i);
            swap(data,0,data.length-i-1);
        }
    }
    
    public static void buildMaxHeap(int[] data,int lastIndex){
        for(int i=(lastIndex-1)/2;i>=0;i--){
            //k为父亲节点
            int k = i;
            while (k*2+1 <= lastIndex){
                int biggerIndex = k*2+1;
                //求孩子节点最大的一个
                if(biggerIndex < lastIndex){
                    if(data[biggerIndex] < data[biggerIndex+1]){
                        biggerIndex++;
                    }
                }
                if(data[k] < data[biggerIndex]){
                    swap(data,k,biggerIndex);
                    k = biggerIndex;
                }
                else{
                    break;
                }            
            }
        }            
    }
    
    public static void swap(int[] data,int i,int j){
        int temp = data[i];
        data[i]=data[j];
        data[j]=temp;
    }

 

3. 冒泡排序（BubbleSort）:冒泡排序是最简单的排序算法之一，实现起来也比较简单，其原理就是进行n-1趟比较并交换，小数往上冒，大数往下沉，经过n-1趟之后形成了有序的数列。

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

 

4.快速排序（QuickSort）: 快速排序死对 冒泡排序的一种改进，基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

    public static void quickSort(int[] data,int start,int end){
        if(start < end){
            int middleIndex = start;
            int i = start;
            int j = end + 1;
            while(true){
                while(i<end && data[++i] <= data[middleIndex]);
                while(j>start && data[--j] >= data[middleIndex]);
                if(i<j){
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
                else{
                    break;
                }
            }
            int temp = data[middleIndex];
            data[middleIndex] = data[j];
            data[j] = temp;
            quickSort(data,0,j-1);
            quickSort(data,j+1,end);
        }
    }

5.直接插入排序（DirectInsertSort）:直接插入排序的思路很简单，就是依次将带排序的数据元素按其关键字排序的大小插入前面的有序序列。

    public static void directInsertSort(int[] data){
        for(int i = 1;i<data.length;i++){
            for(int j = 0;j<i;j++){
                if(data[i] < data[j]){
                    int temp = data[i];
                    for(int m = i;m>j;m--){
                        data[m]=data[m-1];
                    }
                    data[j]=temp;
                }
            }
        }
    }

  6.折半插入排序（BinaryInsertSort）:折半插入排序是对直接插入排序的改进，具体操作为：在将一个新元素插入已排好序的数组的过程中，寻找插入点时，将待插入区域的首元素设置为a[low],末元素设置为a[high]，则轮比较时将待插入元素与a[m],其中m=(low+high)/2相比较,如果比参考元素小，则选择a[low]到a[m-1]为新的插入区域(即high=m-1)，否则选择a[m+1]到a[high]为新的插入区域（即low=m+1），如此直至low<=high不成立，即将此位置之后所有元素后移一位，并将新元素插入a[high+1]。

    public static void binaryInsertSort(int[] data){
        for(int i = 1;i<data.length;i++){
            int low = 0;
            int high = i-1;
            int temp = data[i];
            while(low<=high){
                int mid =(low+high)/2;
                if(data[mid] < temp){
                    low = mid + 1;
                }
                else{
                    high = mid -1;
                }
            }
            for(int m = i;m>low;m--){
                data[m]=data[m-1];
            }
            data[low] = temp;
        }
    }