---------------------------稳定的

--------------------------------------------------------------冒泡算法

 1 /**
 2  * 冒泡排序算法的运作如下: 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
 3  * 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 
 4  * 针对所有的元素重复以上的步骤,除了最后一个。
 5  * 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较
 6  * @param arr int[] 需要排序的数组
 7  * @return arr排序完成的数据
 8  */
 9 public int[] sort(int[] arr) {
10     int temp = 0;
11     for (int i = arr.length - 1; i > 0; --i) {
12         for (int j = 0; j < i; ++j) {//从开始第一对到结尾的最后一对
13             if (arr[j] > arr[j + 1]) {
14                 temp = arr[j];
15                 arr[j] = arr[j + 1];
16                 arr[j + 1] = temp;
17             }
18         }
19     }
20     return arr;
21 }

-------------------------------------------------------------------直接插入排序

 1 /**
 2  * 直接插入排序
 3  * (1)设置监视哨r[0],将待插入纪录的值赋值给r[0]; 
 4  * (2)设置开始查找的位置j; 
 5  * (3)在数组中进行搜索,搜索中将第j个纪录后移,直至r[0].key≥r[j].key为止; 
 6  * (4)将r[0]插入r[j+1]的位置上。
 7  * @param arr 需要排序的数组
 8  * @return 排序完成的数组
 9  */
10 public int[] sort(int[] arr) {
11     for (int i = 1; i < arr.length; i++) {
12         int temp = arr[i];
13         int j = i-1;
14         for (; j >= 0; j--) {
15             if(temp<arr[j]) {
16                 arr[j+1] = arr[j];
17             } else {
18                 break;
19             }
20         }
21         arr[j+1] = temp;
22     }
23     return arr;
24 }

-----------------------------------------------------------------------二分插入排序(折半插入排序)

 1 /**
 2  * 折半排序算法 
 3  * 在将一个新元素插入已排好序的数组的过程中,寻找插入点时, 将待插入区域的首元素设置为a[low],末元素设置为a[high],
 4  * 则轮比较时将待插入元素与a[m],其中m=(low+high)/2相比较,
 5  * 如果比参考元素小,则选择a[low]到a[m-1]为新的插入区域(即high
 6  * =m-1),否则选择a[m+1]到a[high]为新的插入区域(即low=m+1),
 7  * 如此直至low<=high不成立,即将此位置之后所有元素后移一位 ,并将新元素插入a[high+1]。
 8  * @param arr 需要排序的数组
 9  * @return 排序完成的数组
10  * ?如果是递归应该怎么做?
11  */
12 public int[] sort(int[] arr) {
13     for (int i = 1; i < arr.length; i++) {
14         int temp = arr[i];
15         int low = 0;
16         int high = i - 1;
17         while (low <= high) {
18             int mid = (low + high) / 2;
19             if (temp < arr[mid]) {
20                 high = mid - 1;
21             } else {
22                 low = mid + 1;
23             }
24         }
25         for (int j = i; j >= low + 1; j--) {
26             arr[j] = arr[j - 1];
27         }
28         arr[high+1] = temp;
29     }
30     return arr;
31 }

-----------------------不稳定的

--------------------------------------------------------------------------选择排序

 1 /**
 2  * 选择排序
 3  * 对着一群数组说,你们谁最小出列,站到最后边
 4  * 然后继续对剩余的无序数组说,你们谁最小出列,站到最前边
 5  * 再继续刚才的操作,一直到最后一个,继续站到最前边,现在数组有序了,从小到大
 6  * @param arr 需要排序的数组
 7  * @return 排序完成的数组
 8  */
 9 public int[] sort(int[] arr) {
10     int minIndex = 0;
11     int temp = 0;
12     for (int i = 0; i < arr.length - 1; i++) {
13         minIndex = i;// 无序区的最小数据数组下标
14         for (int j = i + 1; j < arr.length; j++) {
15             // 在无序区中找到最小数据并保存其数组下标
16             if (arr[j] < arr[minIndex]) {
17                 minIndex = j;
18             }
19         }
20         if (minIndex != i) {
21             // 如果不是无序区的最小值位置不是默认的第一个数据,则交换之。
22             temp = arr[i];
23             arr[i] = arr[minIndex];
24             arr[minIndex] = temp;
25         }
26     }
27     return arr;
28 }

--------------------------------------------------------------------------希尔排序

 1 /**
 2  * 希尔排序 先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
 3  * 先在各组内进行直接插入排序;然后,取第二个增量d2=d1-1重复上述的分组和排序,直至所取的增量 =1,
 4  * 即所有记录放在同一组中进行直接插入排序为止。
 5  * @param arr 需要排序的数组
 6  * @return 排序完成的数组
 7  */
 8 public int[] sort(int[] arr) {
 9     int d = arr.length / 2;
10     while (true) {
11         for (int i = 0; i < d; i++) {// 分成几组,循环几次
12             for (int j = i; j + d < arr.length; j += d) {// 组内成员两两比较,从小到大排列
13                 int temp;
14                 if (arr[j] > arr[j + d]) {
15                     temp = arr[j];
16                     arr[j] = arr[j + d];
17                     arr[j + d] = temp;
18                 }
19             }
20         }
21         if (d == 1) {
22             break;
23         }
24         d--;
25     }
26     return arr;
27 }

--------------------------------------------------------------------------快速排序

 1 /**
 2  * 1.i =L; j = R; 将基准数挖出形成第一个坑a[i]。
 3  * 2.j--由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。
 4  * 3.i++由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。
 5  * 4.再重复执行2,3二步,直到i==j,将基准数填入a[i]中。
 6  * @param arr 需要排序的数组
 7  * @param low 首元素
 8  * @param high 末元素
 9  * @return 排序完成的数组
10  */
11 public int[] sort(int[] arr, int l, int r) {
12     if (l < r) {
13         int i = l, j = r, x = arr[l];
14         while (i < j) {
15             while (i < j && arr[j] >= x)
16                 // 从右向左找第一个小于x的数
17                 j--;
18             if (i < j)
19                 arr[i++] = arr[j];
20             while (i < j && arr[i] < x)
21                 // 从左向右找第一个大于等于x的数
22                 i++;
23             if (i < j)
24                 arr[j--] = arr[i];
25         }
26         arr[i] = x;
27         arr = sort(arr, l, i - 1); // 递归调用
28         arr = sort(arr, i + 1, r);
29     }
30     return arr;
31 }

--------------------------------------------------------------------------

 posted on 2015-09-02 11:03  码农xk  阅读(167)  评论(0编辑  收藏  举报