排序算法源码（JAVA）

 

public class Test {

    public static void main(String[] args){
        Sort sort = new Sort();
        sort.sortTest();
    }

}

public class Sort {

    public  void sortTest() {

        int[] r = new int[]{,,,,,,,,};
        int[] r1 = new int[]{-,,,,,,,,,};

        insertSortTest(r);
        shellSortTest(r);
        bubbleSortTest(r);
        quickSortTest(r);
        selectSortTest(r);
        heapSortTest(r1);
        mergeSortTest(r1);

        ElemNode[] elemNodes = new ElemNode[];
        for(int i = ; i < elemNodes.length; i++){
            elemNodes[i] = new ElemNode();
            elemNodes[i].key = 9 - i;
            elemNodes[i].next = ;
        }
        KeyNode[] keyNodes = new KeyNode[]; //key为0-9
for(int j = ;j < keyNodes.length; j++){
            keyNodes[j] = new KeyNode();
        }
        bucketSortTest(elemNodes,keyNodes);

    }

    public void insertSortTest(int[] r){
        insertSort(r);

        System.out.print("Insertion Sort : ");
        for(int i = ; i < r.length; i++){
            System.out.print( r[i] + " ");
        }
        System.out.println();
    }

    public void shellSortTest(int[] r){
        shellSort(r);

        System.out.print("Shell Sort : ");
        for(int i = ; i < r.length; i++){
            System.out.print( r[i] + " ");
        }
        System.out.println();
    }

    public  void bubbleSortTest(int[] r){
        bubbleSort(r);

        System.out.print("Bubble Sort : ");
        for(int i = ; i < r.length; i++){
            System.out.print(r[i] + " ");
        }
        System.out.println();
    }

    public void quickSortTest(int[] r){
        quickSort(r, , r.length - );

        System.out.print("Quicksort : ");
        for(int i = ; i < r.length; i++){
            System.out.print(r[i] + " ");
        }
        System.out.println();
    }

    public void selectSortTest(int[] r){
        selectSort(r);

        System.out.print("Selection Sort : ");
        for(int i = ; i < r.length; i++){
            System.out.print( r[i] + " ");
        }
        System.out.println();
    }

    //下标从1开始
public void heapSortTest(int[] r){
        heapSort(r, r.length - ); //下标从1开始

System.out.print("Heap Sort : ");
        for(int i = ; i < r.length; i++){
            System.out.print( r[i] + " ");
        }
        System.out.println();
    }

    //下标从1开始
public void mergeSortTest(int[] r){
        int[] r1 = new int[r.length];
        mergeSort(r, r1, r.length - ); //下标从1开始

System.out.print("Merge Sort : ");
        for(int i = ; i < r.length; i++){
            System.out.print(r[i] + " ");
        }
        System.out.println();
    }

    public void bucketSortTest(ElemNode[] r, KeyNode[] q){
        int index = bucketSort(r, r.length, q, q.length);

        System.out.print("Bucket Sort : ");

        for(int i = ; i < r.length; i++){
            System.out.print(r[index].key + " ");
            index = r[index].next;
        }
        System.out.println();
    }

    //////////////////////////////////////////具体实现////////////////////////////////////////////

    //////////////////////////////////////////直接插入排序////////////////////////////////////////////

public  void insertSort(int[] r){

        int temp, i ,j;

        for( i = ; i < r.length; i++){
            temp = r[i];
            for(j = i - ; j >= 0 && temp < r [j]; j-- )
                r[j+] = r[j];
            r[j+] = temp;
        }
    }

    //////////////////////////////////////////希尔实现////////////////////////////////////////////

public void shellSort(int[] r){

        int temp, d, i , j;

        for(d = r.length/; d >= ; d = d/){
            for(i = d ; i < r.length; i++){
                temp = r[i];
                for(j = i - d; j >= 0 &&  temp < r[j]; j = j-d)
                    r[j+d] = r[j];
                r[j+d] = temp;
            }
        }
    }

    //////////////////////////////////////////冒泡排序////////////////////////////////////////////

public void bubbleSort(int[] r){

        int exchange = r.length - ;//动态记录过程
int bound = r.length - ;//冒泡边界初始化

while (exchange != -){
            bound = exchange;//冒泡排序边界
exchange = -; //交换过程记录

for(int i = ; i < bound; i++){
                if (r[i] > r[i+]){
                    int temp = r[i];
                    r[i] = r[i+];
                    r[i+] = temp;

                    exchange = i;
                }
            }
        }

    }

    //////////////////////////////////////////快速排序////////////////////////////////////////////

public int partition(int[] r, int first, int end){

        int i = first, j = end ,temp;

        while (i < j){
            while (i < j && r[i] < r[j]) j--;
            if (i < j ) {
                temp = r[i];
                r[i] = r[j];
                r[j] = temp;

                i++;
            }

            while (i < j && r[i] < r[j]) i++;
            if(i < j){
                temp = r[i];
                r[i] = r[j];
                r[j] = temp;

                j--;
            }
        }
        return i;
    }

    public void quickSort(int[] r, int first, int end){
        if (first < end){
            int p = partition(r,first, end);
            quickSort(r,first,p - );
            quickSort(r,p + ,end);
        }
    }

    //////////////////////////////////////////选择排序////////////////////////////////////////////

public void selectSort(int[] r){

        int index;//记录临时最小值序号

for(int i = ;i < r.length - ; i++){

            index = i; //初始化最小序号为当前位置序号

for(int j = i + ; j < r.length; j++)//从当前序号后（无序区）选最小值
if(r[j] < r[index]) index = j;

            if (index != i){ //根据最小值下标与当前位置交换
int temp = r[index];
                r[index] = r[i];
                r[i] = temp;
            }
        }
    }

    //////////////////////////////////////////堆排序////////////////////////////////////////////

    //堆存储结构：元素在数组中按层序遍历顺序排序（下标从1开始）

    //（子堆已经建好后）调整堆顶
public void sift(int[] r, int k, int m){  //从小到大排：建立最大堆
        //k：堆顶序号  m：最后节点序号
int i = k , j = 2 * i; //i：堆顶序号  j：堆顶孩子节点序号
while(j <= m){
            if(j < m && r[j] < r[j+]) j++; //j为左右子节点中较大的

if(r[i] < r[j]){ //交换父子节点
int temp = r[i];
                r[i] = r[j];
                r[j] = temp;

                i = j;  j = 2 * i; //调整改变堆顶后的子堆
}
            else break;
        }
    }

    //堆排序：由下至上建立堆，堆顶元素交换到数组尾部
public void heapSort(int[] r, int n){

        for(int i = n/; i >= ; i--){ //由下至上建立堆
sift(r,i,n);
        }

        for(int i = ; i < n; i++){ //i:第i次取顶

            //堆顶元素交换到数组尾部（排序）
int temp = r[];
            r[] = r[n - (i - )];
            r[n - (i - )] = temp;

            sift(r,,n - i);//对堆顶重新建堆（未排序）
}

    }

    //////////////////////////////////////////归并排序////////////////////////////////////////////

public  void merge(int[] r, int[] r1, int s, int m, int t)//一节
{
        int i = s, j = m + ; //r下标
int k = s; //r1下标

while(i <= m && j <= t) //取两子序列r[i] r[j]中较小者放入r1
{
            if(r[i] < r[j]) r1[k++] = r[i++];
            else r1[k++] = r[j++];
        }

        //收尾处理
if(i <= m)
            while(i <= m) r1[k++] = r[i++];
        else
            while(j <= t) r1[k++] = r[j++];

    }

    public void mergePass(int r[], int r1[], int n, int h)//一趟（总长n,子序列长h）
{
        int i = ; //下标从1开始
while(i < n - *h + ) //归并{h, h}
{
            merge(r, r1, i, i+h-, i+*h-);
            i = i + *h;
        }
        if(i < n - h + ) //归并{h, <h}
merge(r, r1, i, i+h-, n);
        else  //归并 <h
for(int k = i; k <= n ;k++)   r1[k] = r[k];
    }

    public void mergeSort(int r[], int r1[], int n)
    {
        int h = ;
        while(h < n){
            mergePass(r, r1, n, h); //r -> r1
h = *h;
            mergePass(r1, r, n, h); //r1 -> r
h = *h;
        }
    }

    //////////////////////////////////////////桶排序////////////////////////////////////////////

public class ElemNode //静态链表
{
        ElemNode(){}
        public int key;  //排序索引
        //        int value; //具体值
public int next; //静态链表的next index
}

    public class KeyNode  //key桶
{
        public int front; //桶首的静态链表index
public int rear;  //桶尾的静态链表index
}

    //分配
public void distribute(ElemNode[] r, int n, KeyNode[] q, int m)
    {
        int i = 0 ;  //静态链表从0开始

while(i < n)  //扫描静态链表
{
            int k = r[i].key;
            if(q[k].front == -) q[k].front = i; //key桶为空：设置key桶头部
else r[q[k].rear].next = i;  //key桶非空：静态链表连接桶元素

q[k].rear = i;  //设置key桶尾部

i++;  //i后移，处理静态链表下一个元素
}
    }

    //收集
public int collect(ElemNode[] r, int n, KeyNode[] q, int m)
    {
        int k = ; //key桶从0开始
while(q[k].front == -)  k++;  //找到第一个非空key桶

int first = q[k].front; //静态链表首部index
int last = q[k].rear; //静态链表尾部index

while (k < m) //扫描key桶
{
            k++;
            if (k < m && q[k].front != -) //找到下一个非空key桶
{
                r[last].next = q[k].front; //静态链表连接
last = q[k].rear;  //修改静态链表尾部index
}
        }
        r[last].next = -;  //设置静态链表排序后尾部标志

return first;  //返回排序后的静态链表首部index
}

    public int bucketSort(ElemNode[] r, int n, KeyNode[] q, int m)
    {
        //初始化静态链表
for(int i = ; i < n; i++)  r[i].next = i + ;
        r[n - ].next = -;  //尾标志为-1

        //初始化key桶
for(int j = ; j < m; j++){
            q[j].front = -;
            q[j].rear = -;
        }

        distribute(r,n,q,m);
        return  collect(r,n,q,m);
    }

}

 

 

 

 

 

来自为知笔记(Wiz)