1、选择排序(Selection Sort)
选择排序 是表现最稳定的排序算法之一 ，因为无论什么数据进去都是O(n2)的时间复杂度 ，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
排序过程简单描述：
首先，找到数组中最小的那个元素，然后，将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。接下来，在剩下的元素中找到剩下最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法称之为选择排序。
理解动画
选择排序.gif
Java实现：
/**
* @author Li DongWei
* 选择排序
*/
public class SearchSort {
public static void main(String[] args) {
int[] arr = {5, -1, 3, 6, 4, 2, 2};
int temp, min, i, j;
for (i = 0; i < arr.length; i++){
min = i;
for (j = i; j < arr.length; j++){
if (arr[j] < arr[min]){
min = j;
}
}
temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
for (int a : arr){
System.out.println(a);
}
}
}
算法分析
性能：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序
最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
2、插入排序(Insertion-Sort)
插入排序的算法描述是一种简单直观的排序算法。就像是我们平时打牌时，刚发到的牌是无序的(需排序的数组)，然后我们通常都是一张一张的来(一个个元素)，将每一张牌(每一个元素)插入到其他已经有序的牌(元素)中的适当位置，这种方法我们称之为插入排序。当我们给无序数组做排序的时候，为了要插入元素，我们需要腾出空间，将其余所有元素在插入之前都向右移动一位。
排序过程简单描述：
1、从数组第2个元素开始抽取元素。
2、把它与左边第一个元素比较，如果左边第一个元素比它大，则继续与左边第二个元素比较下去，直到遇到不比它大的元素，然后插到这个元素的右边。
3、继续选取第3，4，….n个元素,重复步骤 2 ，选择适当的位置插入。
Java实现：
/**
* @author Li DongWei
* 插入排序
*/
public class InsertionSort {
public static void main(String[] args) {
int[] arr= {5, -1, 3, 6, 4, 2, 2};
int temp, compared, i;
for (i = 0; i < arr.length - 1; i++){
compared = arr[i + 1];
temp = i;
while (temp >= 0 && compared < arr[temp]){
arr[temp + 1] = arr[temp];
temp--;
}
arr[temp + 1] = compared;
}
for (int a : arr){
System.out.println(a);
}
}
}
算法分析
性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序
最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
3、冒泡排序(Bubble Sort)
冒泡排序 是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
排序过程简单描述：
把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置….我们对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样一趟比较交换下来之后，排在最右的元素就会是最大的数。除去最右的元素，我们对剩余的元素做同样的工作，如此重复下去，直到排序完成。
Java实现：
/**
* @author Li DongWei
* 冒泡排序
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr= {5, -1, 3, 6, 4, 2, 2};
int temp, i, j;
for (i = 0; i < arr.length; i++){
for (j = 0; j < arr.length - 1 - i; j++){
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int a : arr){
System.out.println(a);
}
}
}
算法分析
性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序
最佳情况：T(n) = O(n)，最差情况：T(n) = O(n2)，平均情况：T(n) = O(n2)
4、希尔排序(Shell Sort)
希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2)的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。
希尔排序是把数组按一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，整个数组恰被分成一组，算法便终止。
排序过程简单描述：
1、取增量 d = 数组长度/2
2、对数组进行增量为d，直接插入排序
3、接下来就是 d = d / 2，重复步骤2
4、依次下去，直到 d =1，整个数组正好排序完成
Java实现：
/**
* @author Li DongWei
* 希尔排序
*/
public class ShellSort {
public static void main(String[] args) {
int[] arr= {5, -1, 3, 6, 4, 2, 2};
int group = arr.length / 2, i, j;
int compared, temp;
while (group > 0){
for (i = 0; i < arr.length - 1; i = i + group){
compared = arr[i + group];
temp = i;
while (temp >= 0 && compared < arr[temp]){
arr[temp + group] = arr[temp];
temp--;
}
arr[temp + group] = compared;
}
group /= 2;
}
for (int a : arr){
System.out.println(a);
}
}
}
算法分析
性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序
最佳情况：T(n) = O(nlog2 n) 最坏情况：T(n) = O(nlog2 n) 平均情况：T(n) =O(nlog2n)
5、归并排序(Merge Sort)
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。归并排序和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。
排序过程简单描述：
通过递归的方式将大的数组一直分割，直到数组的大小为 1，此时只有一个元素，那么该数组就是有序的了，之后再把两个数组大小为1的合并成一个大小为2的，再把两个大小为2的合并成4的 ….. 直到全部小的数组合并起来。
/**
* @author Li DongWei
* 归并排序
*/
public class MergeSort {
public static void main(String[] args) {
int[] arr= {5, -1, 3, 6, 4, 2, 2};
arr = Cut(arr);
for (int a : arr){
System.out.println(a);
}
}
public static int[] Cut(int[] arr){
if (arr.length < 2){
return arr;
}
int[] left = Arrays.copyOfRange(arr, 0, arr.length / 2);
int[] right = Arrays.copyOfRange(arr,arr.length / 2, arr.length);
return Merge(Cut(left), Cut(right));
}
public static int[] Merge(int[] left, int[] right){
int[] temp = new int[left.length + right.length];
int i = 0, j = 0;
for (int index = 0; index
if (i >= left.length){
temp[index] = right[j++];
}else if (j >= right.length){
temp[index] = left[i++];
}else if (left[i] > right[j]){
temp[index] = right[j];
j++;
}else {
temp[index] = left[i];
i++;
}
}
return temp;
}
}
算法分析
1、时间复杂度：O(nlogn) 2、空间复杂度：O(n) 3、稳定排序 4、非原地排序
最佳情况：T(n) = O(n) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)
扫一扫
256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
