数据结构—排序算法

于 2015-04-12 17:35:46 发布
阅读量366 收藏
点赞数
分类专栏： 数据结构 文章标签： 排序算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xaiomessi/article/details/45012161
版权

此博客主要是记录自己在看《数据结构》排序这一章节时候，对各种排序算法的java实现。

排序算法分为内部排序和外部排序。我讲的主要是内部排序。（注：每种排序的概念和排序的样例

展示可以参照清华大学出版社《数据结构》一书，这里就不一一介绍了）
八大排序算法

1.插入排序:直接插入排序和希尔排序

//插入排序
public class InsertionSort {
    public static void InsertionSort(int[] array,int N){
        for(int i=1;i<N;i++){
            int temp=array[i];
            int j;
            for(j=i;j>0;j--){
                if(array[j-1]>temp){
                array[j]=array[j-1];}
                else{
                    break;
                }
            }
            array[j]=temp;
            printArray(array);
        }
    }

    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
        System.out.println();
    }
    public static void main(String[] args){
        int[] array={34,8,64,51,32,31};
        InsertionSort(array,array.length);
        printArray(array);

    }
}

//希尔排序
public class shellSort {
    public static void shellSort(int[] array,int N){
        for(int Increment=N/2;Increment>0;Increment=Increment/2){
            for(int i=Increment;i<N;i++){
                int temp=array[i];
                int j;
                for(j=i;j>=Increment;j-=Increment){
                    if(array[j-Increment]>temp){
                        array[j]=array[j-Increment];
                    }
                    else
                        break;
                }
                array[j]=temp;
            }
        }
    }


    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
        System.out.println();
    }
    public static void main(String[] args){
        int[] array={81,94,11,96,12,36,17,95,28,58,41,75,15};
        shellSort(array,array.length);
        printArray(array);

    }
}

2.选择排序：简单选择和堆排序

//简单选择排序
public class SelectSort {
    public static int selectMin(int[] array,int i){
        int minIndex=i;
        for(int j=i+1;j<array.length;j++){
            if(array[j]<array[minIndex])
                minIndex=j;
        }
        return minIndex;
    }

    public static void selectSort(int[] array){
        int index=0;
        for(int i=0;i<array.length-1;i++){
            index=selectMin(array,i);
            if(index!=i){
                int temp=array[i];
                array[i]=array[index];
                array[index]=temp;
            }
        }
    }
    public static void print(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
    }

    public static void main(String[] args){
        int[] array={49,38,65,97,76,13,27,49};
        selectSort(array);
        print(array);
    }
}

//堆排序
public class HeapSort {
    public static void heapAdjust(int[] heap,int s,int m){
        int rc=heap[s];
        for(int i=2*s+1;i<=m;i=2*s+1){
            if(i<m&&heap[i+1]<heap[i])
                i++;
            if(heap[s]<=heap[i])
                break;
            //heap[s]=heap[i];
            int temp=heap[s];
            heap[s]=heap[i];
            heap[i]=temp;
            s=i;
        }
        heap[s]=rc;
    }

    public static void heapSort(int[] array){
        for(int i=(array.length-1)/2;i>=0;--i){
            heapAdjust(array,i,array.length-1);
        }
        for(int i=array.length-1;i>0;--i){
            int temp=array[0];
            array[0]=array[i];
            array[i]=temp;
            heapAdjust(array,0,i-1);
        }
    }
    public static void print(int[] array){
        for(int i=0;i<array.length;++i){
            System.out.print(array[i]+",");
        }
    }

    public static void main(String[] args){
        int[] array={49,38,65,97,76,13,27,49};
        heapSort(array);
        print(array);
    }
}

3.交换排序：冒泡排序和快速排序

//冒泡排序
public class BubbleSort {
    public static void bubbleSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }

            }
        }
    }
    public static void print(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
    }

    public static void main(String[] args){
        int[] array={49,38,65,97,76,13,27,49};
        bubbleSort(array);
        print(array);
    }
}

//快速排序1
public class QuickSort {
    public static int partition(int[] sqList,int low,int high){
        int pivotKey=sqList[low];
        while(low<high){
            while(low<high&&sqList[high]>=pivotKey)
                --high;
            sqList[low]=sqList[high];
            while(low<high&&sqList[low]<=pivotKey)
                ++low;
            sqList[high]=sqList[low];
        }
        sqList[low]=pivotKey;
        return low;
    }
    public  static void QSort(int[] sqList,int low,int high){
        if(low<high){
            int  pivotloc=partition(sqList,low,high);
            QSort(sqList,low,pivotloc-1);
            QSort(sqList,pivotloc+1,high);
        }
    }

    public static void print(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
    }
    public static void main(String[] args){
        int[] array={49,38,65,97,76,13,27,49};
        print(array);
        System.out.println();
        QSort(array,0,array.length-1);
        print(array);
    }
}

//快速排序2
public class QuickSort {
    public static int partition(int data[],int begin,int end){
        //int first=data[end];
        int pivot=begin-1;

        for(int i=begin;i<end;i++){
            if(data[i]<data[end]){
                pivot++;
                if(pivot!=i){
                    int temp=data[pivot];
                    data[pivot]=data[i];
                    data[i]=temp;
                }
            } 

        }

            pivot++;
            if(pivot!=end){
                int temp=data[pivot];
                data[pivot]=data[end];
                data[end]=temp;
            }
        return pivot;
    }
    public static void quickSort(int[] data,int begin,int end){
        if(data==null&&begin>end)
            return;
        int index=partition(data,begin,end);
        if(index>begin)
            quickSort(data,begin,index-1);
        if(index<end)
            quickSort(data,index+1,end);
    }

    public static void display(int[] data){
        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+",");
        }
    }

    public static void main(String[] args){
        int[] array={20,11,31,49,15,7,68,16};
        quickSort(array,0,7);
        display(array);

    }
}

4.归并排序

public class MergeSort {
    public static int[] mergeSort(int[] nums,int low,int high){
        int mid=(low+high)/2;
        if(low<high){
            mergeSort(nums,low,mid);
            mergeSort(nums,mid+1,high);
            merge(nums,low,mid,high);
        }
        return nums;
    }
    public static void merge(int[] nums,int low,int mid,int high){
        int[] nums2=new int[high-low+1];
        int i=low;
        int j=mid+1;
        int k=0;
        while(i<=mid&&j<=high){
            if(nums[i]<nums[j])
                nums2[k++]=nums[i++];
            else
                nums2[k++]=nums[j++];

        }
        while(i<=mid)
            nums2[k++]=nums[i++];

        while(j<=high)
            nums2[k++]=nums[j++];

        for(int k2=0;k2<nums2.length;k2++){
            nums[k2+low]=nums2[k2];
        }
    }
    public static void print(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
    }
    public static void main(String[] args){
        int[] array={49,38,65,97,76,13,27,49};
        int[] array1=mergeSort(array,0,array.length-1);
        print(array1);
    }
}

5.基数排序

import java.util.LinkedList;
import java.util.Queue;


public class RadixSort {

    public static void main(String[] args){
        RadixSort sort=new RadixSort();
        int[] array={278,109,63,930,589,184,505,269,8,83};
        sort.radixSort(array);
        print(array);
    }

    public void radixSort(int[] array){
        int max=array[0];
        for(int i=1;i<array.length;i++){
            if(array[i]>max)
                max=array[i];
        }


        int times=0;
        while(max>0){
            max=max/10;
            times++;
        }

        //初始化队列
        Queue[] queue=new Queue[10];
        for(int i=0;i<10;i++){
            queue[i]=new LinkedList<Integer>(); 
        }

        //分配
        for(int i=0;i<times;i++){

            for(int j=0;j<array.length;j++){
                int k=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10,i);
                queue[k].add(array[j]);
            }




        //收集
            int count=0;
            for(int k=0;k<10;k++){
                    while(queue[k].size()>0){
                        array[count]=(int)(queue[k].remove());
                        count++;
                    }

            }
    }


    }
    public static void print(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+",");
        }
    }

}

各种排序算法的性能比较如下图所示：

Rookie_Feng
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值