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

插入排序的基本思想

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

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

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

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

 1 /**直接插入排序算法
 2      * @param obj
 3      * @return
 4      */
 5     public static int[] SelectSort(int[] obj) {
 6         //外层循环决定要遍历数组几轮
 7         for (int i = 1; i < obj.length; i++) {
 8             int value = obj[i];
 9             int temp = i;
10             //内层循环决定一轮中的要对比的次数
11             while (temp > 0 && value < obj[temp - 1]) {
12                 obj[temp] = obj[temp - 1];
13                 obj[temp-1]=value;
14                 temp--;
15             }
16
17         }
18         return obj;
19     }

直接插入排序算法

 1     /**折半插入排序
 2      *
 3      * @param obj
 4      * @return
 5      */
 6     public static int[] halfSort(int[] obj){
 7         int len=obj.length;//获取数组的长度
 8         int value=obj[len-1];//待插入元素
 9         int min=0;
10         int max=len-2;
11         while (min<=max) {
12             int middle=(min+max)/2;//获取数组中间元素的下标
13             if (obj[middle]>value)
14                 max=middle-1;
15             else
16                 min=middle+1;
17         }
18         for (int i = len-1; i >max+1; i--) {//元素向右移动
19             obj[i]=obj[i-1];
20         }
21         obj[max=1]=value;
22         return obj;
23     }
24     

折半插入排序

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

希尔排序

交换排序

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

快速排序