复杂排序

package suanfa.newchllenage;

import java.util.Arrays;

/**
 * 随机版快速排序
 */
public class QuickSort02 {

    public static void quickSort(int [] a){
        if (a==null||a.length<1){
            return;
        }
        quickSortSore(a,0,a.length-1);
    }

    private static void quickSortSore(int [] a,int start,int end){
        if (start<end){
            int mid=partition(a,start,end);
            if (mid-1>start){
                quickSortSore(a,start,mid-1);
            }
            if (mid+1<end){
                quickSortSore(a,mid+1,end);
            }
        }
    }


    private static int partition(int [] a,int start,int end){
        int randIndex=(int)(Math.random()*(end-start+1)+start);
        int pivot=a[randIndex];
        int left=start;
        int right=end;

        System.out.println(left+"----"+randIndex+"-----"+right);

        while (true){

            while (a[left]<=pivot){
                left++;
                if (left==right){
                    break;
                }
            }

            while (a[right]>pivot){
                right--;
                if (left==right){
                    break;
                }
            }

            if (left>=right){
                break;
            }

            int t=a[left];
            a[left]=a[right];
            a[right]=t;
        }

        int t=a[randIndex];
        a[randIndex]=a[right];
        a[right]=t;
        System.out.println(Arrays.toString(a));
        return right;
    }

    public static void main(String[] args) {
        int [] a={3,2,5,8,4,7,6,9,1};
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }
}

package suanfa.newchllenage;

import java.util.Arrays;

public class HeapSort {

    private static class BTNode{
        int data;
        BTNode left;
        BTNode right;
    }

    public static void heapSort(int [] a){
        BTNode [] q=new BTNode[a.length];
        int front,rear;
        front=rear=-1;
        BTNode root,pa;
        pa=root=new BTNode();
        root.data=a[0];

        //  用数组模拟队列，建立完全二叉树并记录在队列中的位置，供后面进行堆排序
        q[++rear]=root;
        ++front;
        for (int i=1;i<a.length;i++){
           BTNode p=new BTNode();
           p.data=a[i];
           q[++rear]=p;
           if (pa.left==null){
               pa.left=p;
           }else {
               pa.right=p;
               pa=q[++front];
           }
        }

        //  要把rear放在最后一个非叶子节点上，所以在这里进行判断，因为都是双分支时，会跑到第一个叶子节点上
        //  当数组长度为1时，会直接进行最后的a[index++]=q[0].data操作
        if (q[front].left==null&&q[front].right==null){
            front--;
        }

        //  进行堆排序
        int index=0;

        while (front>-1){

            boolean tag=true;
            while (tag){
                tag=false;
                //  当每个非叶子节点调整后都未进行交换，证明该次将最小值放在根节点完成
                for (int j=front;j>-1;j--){
                    BTNode p,pmin;
                    p=pmin=q[j];
                    if (p.left.data<pmin.data){
                        pmin=p.left;
                    }
                    if (p.right!=null&&p.right.data<pmin.data){
                        pmin=p.right;
                    }
                    if (pmin!=p){
                        tag=true;
                        int t=p.data;
                        p.data=pmin.data;
                        pmin.data=t;
                    }
                }
            }

            //  经过调整，最小已经在根节点，此时将根节点与最后一个叶子的值进行替换，并删掉最后一个叶子
            BTNode p=q[rear];
            a[index++]=root.data;
            int t=p.data;
            p.data=root.data;
            root.data=t;
            rear--;

            //  front所在位置是rear对应的父节点
            if (q[front].right!=null){
                q[front].right=null;
            }else {
                q[front].left=null;
                front--;
            }
        }

        //***********************
        //  上次调整已经成一个根节点与一个左节点时，本次在进行上的一次调整后，选出一个最小之后，front--
        //  front的值就成了-1了，此时二叉树上还有一个根节点
       a[index++]=q[0].data;
    }

    static void print(BTNode root){
        if (root!=null){
            System.out.print(root.data+" ");
            print(root.left);
            print(root.right);
        }
    }

    public static void main(String[] args) {
        int [] a={3,2,5,8,4,7,6,9,1};
        int [] a2={1};
        heapSort(a2);

        System.out.println(Arrays.toString(a2));
    }
}

package suanfa.newchllenage;

import java.util.Arrays;

public class Sort02 {

    //  希尔排序
    public static void shellSort(int [] a){
        if (a==null||a.length<1){
            throw new RuntimeException("input data is error");
        }
        if (a.length==1){
            return;
        }

        int dis=a.length;
        do {
            dis=dis/3+1;
            System.out.println(dis);
            for (int i=dis;i<a.length;i+=dis){
                int temp=a[i];
                int j;
                for (j=i-dis;j>-1&&temp<a[j];j-=dis){
                    a[j+dis]=a[j];
                }
                a[j+dis]=temp;
            }
        }while (dis!=1);
    }

    //  计数排序
    public static void countingSort(int [] a){
        if (a==null||a.length<1){
            throw new RuntimeException("input data is error");
        }
        if (a.length==1){
            return;
        }
        int min,max;
        min=max=a[0];
        for (int i=1;i<a.length;i++){
            if (a[i]<min){
                min=a[i];
            }
            if (a[i]>max){
                max=a[i];
            }
        }

        int [] count=new int[max-min+1];
        for (int i=0;i<a.length;i++){
            int index=a[i]-min;
            count[index]++;
        }

        int index=0;
        for (int i=0;i<count.length;i++){
            while (count[i]-->0){
                a[index++]=i+min;
            }
        }
    }



    public static void main(String[] args) {
        int [] a={3,2,5,8,4,12,6,9,2};
        int [] a2={3,0};
        //shellSort(a2);
        countingSort(a);
        System.out.println(Arrays.toString(a));
    }
}

package suanfa.newchllenage;

import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;

/**
 * 仅用一个栈来辅助另一个栈进行排序
 */

public class StackSort {

    public static void stackSort(Deque<Integer> stack){
        Deque<Integer> help=new ArrayDeque<>();

        while (!stack.isEmpty()){
            int temp=stack.pop();
           if (!help.isEmpty()&&temp>=help.peek()){
               while (!help.isEmpty()&&temp>help.peek()){
                   stack.push(help.pop());
               }
           }
            help.push(temp);
        }
        while (!help.isEmpty()){
            stack.push(help.pop());
        }
    }
    public static void main(String[] args) {
        int [] data={3,2,5,8,4,7,6,9,1};
        Deque<Integer> stack=new ArrayDeque<>();
        for (int i : data){
            stack.push(i);
        }
        System.out.println("sort before :"+ Arrays.toString(data));
        stackSort(stack);
        System.out.println("sort after :");
        for (int  i : stack){
            System.out.print(stack.pop()+"   ");
        }
    }
}