排序算法总结

排序算法总结

排序是将无序列的记录调整为有序列记录的一种操作，分为外排序和内排序

内排序：等待排序的序列完全放在内存中

外排序：排序过程中还要访问外存，常用归并排序

常用的排序方法

1 直接插入排序

2冒泡排序

3.希尔排序

4快速排序

5堆排序

-------------------------------------------------------------------------------------->

直接插入排序

思想原理：

（1）设待排序的记录存放在一个数组中，r[1]是一个有序序列

（2） 循环n-1次 每次使用顺序查找方法，在已经排好序的序列中找到插入的位置进行插入，然后将r[i]插入表长为i-1的有序序列中 最后得到一个表长为n 的有序序列

算法特点

是稳定排序，算法简单，适用顺序存储和链表存储，

当N比较大的时候此算法复杂度比较高

时间复杂度为 O（n^2）

package 直接插入排序算法;

public class insertionSort {

public static void insertionSort(int[] a){

int tmp;

for (int i = 1; i < a.length; i++) {

for(int j=i;j>0;j--){

if (a[j]<a[j-1]) {

tmp=a[j-1];

a[j-1]=a[j];

a[j]=tmp;

}

}

}

}

public static void main(String[] args) {

int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };

insertionSort(a);

for (int i : a)

System.out.print(i + " ");

}

}

-------------------------------------------------------------------------------------->

希尔排序

希尔排序实质上是采用分组插入的方法，先将待排记录分隔成几组，从而减少与直接插入排序的数量，对每组分别进行直接插入排序，然后增加每组的数据量，重新分组，经过几次分组排序后，整个序列中的记录基本有序，再对全体记录进行一次直接插入 比如第一次分d为5 就是相隔5的数进行一次排序 第二次将取d为2 就是将相隔为2的数进行一次排列

时间复杂度： O(N^(3/2))

算法是不稳定的 只能用在顺序表中

package 希尔排序算法;

public class shellsort {

public static void sort(int []arr){

if(arr==null||arr.length==1){

System.out.println("不用找");

return;

}

int increamentNum=arr.length/2;

while (increamentNum>=1) {//当d 大于一次的时候执行

for(int i=0;i<arr.length;i++){//当从第一个开始进行分组的插入排序

//进行插入排序

for(int j=i;j<arr.length-increamentNum;j=j+increamentNum){

if (arr[j]>arr[j+increamentNum]) {

int temle=arr[j];

arr[j]=arr[j+increamentNum];

arr[j+increamentNum]=temle;

}

}

}

increamentNum=increamentNum/2;

}

}

-------------------------------------------------------------------------------------->

冒泡排序

思想原则

冒泡排序，通过两两之间相邻记录的相关字的比较，如果发现逆序，就进行交换，所以关键字小的记录如气泡一样往上飘，或者让关键字比较大的数像石头一样堕落

（1）设待排序的记录存放在数组r[1.....n]中 首先将第一个记录的关键字和第二个数的关键字进行比较，如果为逆序那么交换位置，然后比较第二个记录和第三个记录的关键字，以此类推直到第n-1个数和第n个记录的关键字进行比较为止 上述为第一次排序，排序的结果是将最大的数放在了最后

（2）进行第二个排序 排序的方法和上面一样 次大的关键字被安置在第n-1个个位置上

（3）如果有一次是没有进行交换记录的操作 那么就结束排序

时间复杂度 O（n^2）

空间复杂度 O（1）

算法的特点

（1）算法是稳定的 （2）可以用于链式存储 （3）当n 比较大的时候移动次数太多不适合用

1. package 冒泡排序;
2. public class BubbleSort {
3. public static void sort(int[] arr){
4. for (int i = 0; i < arr.length; i++) {
5. for (int j = 0; j < arr.length-i-1; j++) {
6. if (arr[j]>arr[j+1]) {
7. int tem=arr[j+1];
8. arr[j+1]=arr[j];
9. arr[j]=tem;
10. }
11. }
12. }
13. for (int i = 0; i < arr.length; i++) {
14. int j = arr[i];
15. System.out.println(j+",");
16. }
17. }
18. public static void main(String[] args) {
19. int[] arr={6,3,8,2,9,1};
20. sort(arr);
21. }
22. }
23. 
    

-------------------------------------------------------------------------------------->

快速排序

在待排序的n个记录中去一个记录一般取第一个作为支点，设其关键字为pivotkey,经过一趟排序后将所有小于支点的记录交换到前面，把所有大于支点的记录交换到后面，结果把待排序记录分成两个子表，最后将支点放在分界处的位置，然后分别对左右子表进行同样的操作，直到子表中只有一个记录，那么排序完成。

（1）附设两个指针low 和hight 初始化时分别指向表的上下界，设支点记录的关键字为pivotkey

(2)从表的最右侧位置，依次向左搜索小于pivotkey的记录和支点记录交换 即是

当low<hight时 若hight所指记录大于等于pivotkey，则向左移动指针，，否则将hight所指记录与支点交换

（3）然后从表的左边开始 搜索大于pivotkey 的值 当low<hight 若low所指记录小于pivotkey，那么移动low指针，否则 low与支点交换位置

（4）不断重复2 和3 直到low=hight

算法的时间复杂度为O(nlog2n) 空间复杂度为O(n)

特点

1. 是不稳定的排序

2. 只能用在顺序结构中

3.内部排序中最快的一种 适合n比较大的时候

package 快速排序;

public class QuickySort {

public static void quickySort(int[] array,int low,int hig){

if (low>=hig) {

return;

}

int mid=getMid(array,low,hig);

quickySort(array,low,mid-1);

quickySort(array,mid+1,hig);

}

public static int getMid(int[] array,int low,int hig){

int key=array[low];

while(low<hig){

while(array[hig]>=key&&hig>low){

hig--;

}

array[low]=array[hig];

while(array[low]<key&&hig>low){

low++;

}

array[hig]=array[low];

}

array[low]=key;

return low;

}

public static void main(String[] args) {

int[] arr={6,3,8,2,9,1};

getMid(arr,0,arr.length-1);

for (int i = 0; i < arr.length; i++) {

int j = arr[i];

System.out.println(j+",");

}

}

}

简单选择排序

选择排序的基本思想 每一趟从待排序的记录中选出关键字最小的记录，按顺序放到已经排序的记录的最后，直到全部排完

（1）设待排序的记录存放在数组r[1.....n],第一趟从r[1]开始，通过n-1次比较，从n记录中选出关键字最小的记录 记为r[k] 交换r[1]和r[k]

(2) 从第二个开始通过n-2次比较 从n-1个记录中国选出关键字最小的记录，记录为k[r] 交换 r[2]和r[k]

（3）依次类推 经过n-1次后排序完成

时间复杂度O（n^2） 空间复杂度为O(1)

不稳定的排序 移动记录次数比较少

package 选择排序;

import javax.naming.ldap.SortControl;

public class SelectSort {

public static void Sort(int [] values){

int temp;

for(int i=0;i<values.length;i++){

temp=values[i];

int offset=0;

for(int j=i+1;j<values.length;j++){

if (temp>values[j]) {

temp=values[j];

offset=j;

}

}

if (offset>i) {

values[offset]=values[i];

values[i]=temp;

}

}

}

public static void main(String[] args) {

int [] values={5,2,4,1,3};

Sort(values);

for (int i = 0; i < values.length; i++) {

int j = values[i];

System.err.println(j+",");

}

}

}

堆排序

堆排序是一种树型选择排序，在排序过程中，将待排序的记录r[1...n] 看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点之间的内在关系在在当前无序列表中选择关键字最大的记录