排序方法基本介绍（2）

第四次博客：
排序方法基本介绍（2）：
稳定的
冒泡排序（bubble sort） — O(n^2）
鸡尾酒排序(Cocktail sort，双向的冒泡排序) — O(n^2）
插入排序（insertion sort）— O(n^2)
桶排序（bucket sort）— O(n); 需要 O(k) 额外空间
计数排序(counting sort) — O(n+k); 需要 O(n+k) 额外空间
合并排序（merge sort）— O(nlog n); 需要 O(n) 额外空间
原地合并排序— O(n^2)
二叉排序树排序 （Binary tree sort） — O(nlog n)期望时间； O(n^2)最坏时间； 需要 O(n) 额外空间
鸽巢排序(Pigeonhole sort) — O(n+k); 需要 O(k) 额外空间
基数排序（radix sort）— O(n·k); 需要 O(n) 额外空间
Gnome 排序— O(n^2)
图书馆排序— O(nlog n) with high probability，需要 （1+ε)n额外空间
不稳定的
选择排序（selection sort）— O(n^2)
希尔排序（shell sort）— O(nlog n) 如果使用最佳的现在版本
组合排序— O(nlog n)
堆排序（heapsort）— O(nlog n)
平滑排序— O(nlog n)
快速排序（quicksort）— O(nlog n) 期望时间，O(n^2) 最坏情况； 对于大的、乱数列表一般相信是最快的已知排序
Introsort— O(nlog n)
耐心排序— O(nlog n+ k) 最坏情况时间，需要 额外的 O(n+ k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）
不实用的
Bogo排序— O(n× n!) 期望时间，无穷的最坏情况。
Stupid sort— O(n^3); 递归版本需要 O(n^2) 额外存储器
珠排序（Bead sort） — O(n) or O（√n)，但需要特别的硬件
Pancake sorting— O(n)，但需要特别的硬件
stooge sort——O（n^2.7）很漂亮但是很耗时
学习c、c++、java、数据结构中遇到的排序方法有插入排序
冒泡排序、选择排序、快速排序、插入排序、堆排序、归并排序、基数排序、希尔排序其中插入排序包括：直接插入排序，二分插入排序（又称折半插入排序），链表插入排序，希尔排序（又称缩小增量排序）。
今天介绍的是插入排序的另外两种与堆排序。
链表插入排序：
基本思想：假设前面n-1个结点有序，将第n个结点插入到前面结点的适当位置，使这n个结点有序。
实现方法：
将链表上第一个结点拆下来，成为含有一个结点的链表(head1)，其余的结点自然成为另外一个链表(head2)，此时head1为含有一个结点的有序链表；
将链表head2上第一个结点拆下来，插入到链表head1的适当位置，使head1仍有序，此时head1成为含有两个结点的有序链表；
依次从链表head2上拆下一个结点，插入到链表head1中，直到链表head2为空链表为止。最后，链表head1上含所有结点，且结点有序。
public class LinkedInsertSort {
static class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
next = null;
}
}

public static ListNode insertionSortList(ListNode head) {
    if(head==null||head.next==null)    return head;

    ListNode pre = head;//pre指向已经有序的节点
    ListNode cur = head.next;//cur指向待排序的节点

    ListNode aux = new ListNode(-1);//辅助节点
    aux.next = head;

    while(cur!=null){
        if(cur.val<pre.val){
          //先把cur节点从当前链表中删除，然后再把cur节点插入到合适位置
            pre.next = cur.next;

            //从前往后找到l2.val>cur.val,然后把cur节点插入到l1和l2之间
            ListNode l1 = aux;
            ListNode l2 = aux.next;
            while(cur.val>l2.val){
                l1 = l2;
                l2 = l2.next;
            }
            //把cur节点插入到l1和l2之间
            l1.next = cur;
            cur.next = l2;//插入合适位置

            cur = pre.next;//指向下一个待处理节点

        }else{
            pre = cur;
            cur = cur.next;
        }
    }
    return aux.next;
}

}
希尔排序
希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
public static void main(String [] args)
{
int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
System.out.println(“排序之前：”);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" “);
}
//希尔排序
int d=a.length;
while(true)
{
d=d/2;
for(int x=0;x<d;x++)
{
for(int i=x+d;i<a.length;i=i+d)
{
int temp=a[i];
int j;
for(j=i-d;j>=0&&a[j]>temp;j=j-d)
{
a[j+d]=a[j];
}
a[j+d]=temp;
}
}
if(d==1)
{
break;
}
}
System.out.println();
System.out.println(“排序之后：”);
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+” ");
}
}
堆排序
堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
public class HeapSorting {
public static void main(String[] args) {
int[] a=new int[]{0,9,8};
Sort(a,a.length-1);
for(int i:a){
System.out.println(i);
}
}
public static void MaxHeapify(int[] a,int index,int size){
int l=2index;
int r=2index+1;
int largest=index;
if(l<=size && a[l]>a[index]){
largest=l;
}
if(r<=size && a[r]>a[largest]){
largest=r;
}
if(largest!=index){
int temp=a[largest];
a[largest]=a[index];
a[index]=temp;
MaxHeapify(a,largest,size);
}
}
public static void HeapBuild(int[] a,int size){
for(int i=size/2;i>=1;i–){
MaxHeapify(a,i,size);
}
}
public static void Sort(int[] a,int size){
HeapBuild(a,size);
for(int i=size;i>=2;i–){
int temp=a[i];
a[i]=a[1];
a[1]=temp;
MaxHeapify(a,1,i-1);
}
}
}