数据结构和算法之排序算法

插入排序的基本思想

每次将一个待排序的数据元素，按照其关键字大小插入到前面已经排好序的有序的适当位置，使插入以后的数据序列仍然为一个有序数列，直到整个序列称为有序序列为止。

直接插入排序（把待排序元素分成两部分，一部分是没排好序的元素，另一部分是排好序的元素。把没排好序的元素逐一插入以排好序的部分）

折半插入排序（向有序序列中插入元素，插入位置可以不断地平分有序序列，并把待插入的元素的关键字与平分有序序列得到的关键字比较，以确定下一步要评分的序列，直到找到合适的插入位置为之。）

希尔排序（先将整个待排序序列分割成若干子序列，每个子序列由相差一定长度的数据元素组成【这个相差的长度称为增量】）

/**直接插入排序算法
     * @param obj
     * @return
     */
    public static int[] SelectSort(int[] obj) {
        //外层循环决定要遍历数组几轮
        for (int i = 1; i < obj.length; i++) {
            int value = obj[i];
            int temp = i;
            //内层循环决定一轮中的要对比的次数
            while (temp > 0 && value < obj[temp - 1]) {
                obj[temp] = obj[temp - 1];
                obj[temp-1]=value;
                temp--;
            }
            
        }
        return obj;
    }

    /**折半插入排序
     * 
     * @param obj
     * @return
     */
    public static int[] halfSort(int[] obj){
        int len=obj.length;//获取数组的长度
        int value=obj[len-1];//待插入元素
        int min=0;
        int max=len-2;
        while (min<=max) {
            int middle=(min+max)/2;//获取数组中间元素的下标
            if (obj[middle]>value) 
                max=middle-1;    
            else
                min=middle+1;
        }
        for (int i = len-1; i >max+1; i--) {//元素向右移动
            obj[i]=obj[i-1];
        }
        obj[max=1]=value;
        return obj;            
    }
    

    /**希尔排序
     * @param obj
     */
    public static void shellSort(int[] obj){
        int temp ;//零时变量
        int len=obj.length/2;//分割集合的间隔长度，初始值为数组长度的一半
        int pointer; //进行比较的下标位置
        //1按每次减半划分步长，直到步长为0（设置步长增量）
        while (len!=0) {
            //2对各个集合进行比较（根据步长，设置每轮循环次数）
            for (int i = len; i <obj.length; i++) {
                pointer=i-len; //计算要和当前值进行比较的位置
                temp=obj[i];
                //3.将临时变量与集合内的数进行比较
                //按照步长距离，将临时变量里的值和集合内数值一次进行比较
                while (temp<obj[pointer]) {
                    obj[pointer+len]=obj[pointer];
                    pointer=pointer-len;//计算下一个欲进行比较的位置
                    //如果当前下表为值大于或等于当前步长则继续循环，
                    //按步长与墙面个所有数进行比较
                    //直到遇到比当前临时变量小得数为止
                    if (pointer<0) {
                        break;
                    }
                }
                //把临时变量赋值到当前下标所在位置
                obj[pointer+len]=temp;
            }
            len=len/2; //计算下次分割的间隔的步长
        }

交换排序

冒泡排序（比较相邻的两个数据元素的关键字，如果他们之间的大小关系与期望的关系相反，则交换两个元素的位置，否则不交换。）

快速排序

 完全图是每对顶点之间都恰好有一条边的简单图