java实现8张基础排序算法

/*

 * author junby

 * 冒泡排序

 * 2013.28

 */

package com.xzb.sort;

public class BubbleSort

{

    public static void main(String[] args)

    {

        

        

        

        int[] a ={2,5,4,8,7};

        bubblesort(a);

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

        {

            System.out.print(a[i]);

            System.out.print(" ");

        }

    }

    

    public static void bubblesort(int[] data)

    {

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

        {

            for (int j = i; j < data.length; j++)

            {

                if (data[i]>data[j])

                {

                    int temp = data[i];

                    data[i] = data[j];

                    data[j] = temp;

                }

            }

        }

    }

}

/*

 * author by junby

 * 堆排序

 * 2012.8.29

 */

package com.xzb.sort;

public class Heapsort

{

    public static void main(String[] args)

    {

        int[] a =

        { 2, 5, 4, 8, 7, 1 };

        heapsort(a);

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

        {

            System.out.print(a[i]);

            System.out.print(" ");

        }

    }

    public static void heapsort(int[] data)

    {

        for (int i = data.length - 1; i > 0; i--)

        {

            bulidheap(data, i);

            // 交换根与最末尾元素

            swap(data, 0, i);

        }

    }

    // 调整堆

    public static void bulidheap(int[] data, int lastindex)

    {

        int lastparentindex = (lastindex - 1) / 2;

        for (int i = lastparentindex; i >= 0; i--)

        {

            int k = i;// 记录当前正在判断的节点

            while ((2 * k + 1) <= lastindex)

            {

                int leftindex = 2 * k + 1;

                int rightindex = 2 * k + 2;

                int max = leftindex;// 记录左右子数大的下标

                if (rightindex <= lastindex)

                {

                    max = data[leftindex] > data[rightindex] ? leftindex

                            : rightindex;

                }

                if (data[max] > data[k])

                {

                    swap(data, k, max);

                    k = max;

                } else

                {

                    break;

                }

            }

        }

    }

    public static void swap(int[] a, int i, int j)

    {

        int temp;

        temp = a[i];

        a[i] = a[j];

        a[j] = temp;

    }

}

/*

 * author by junby

 * 直接插入排序

 * 2013.8.28

 */

package com.xzb.sort;

public class Insertsort

{

    public static void main(String[] args)

    {

        int[] data = {1,5,3,4,9,7,8};

        insertsort(data);

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

        {

            System.out.print(data[i]);

            System.out.print(" ");

        }

    }

    public static void insertsort(int[] a)

    {

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

        {

            int temp = a[i];// 未排序的第一个数字

            int j = i - 1;

            while (j >= 0 && a[j] > temp)

            {

                a[j + 1] = a[j];

                j--;

            }

            a[j + 1] = temp;

        }

    }

}

/*

 * 归并排序

 * author by junby

 * 2013.8.31

 */

package com.xzb.sort;

public class Mergingsort

{

    public static void main(String[] args)

    {

        int[] data =

        { 1, 5, 3, 4, 9, 7, 8 };

        mergesort(data, 0, data.length - 1);

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

        {

            System.out.print(data[i]);

            System.out.print(" ");

        }

    }

    public static void mergesort(int[] a, int left, int right)

    {

        if (left < right)

        {

            int middle = (left + right) / 2;

            // 对左边进行递归

            mergesort(a, left, middle);

            // 对右边进行递归

            mergesort(a, middle + 1, right);

            // 进行合并排序

            merge(a, left, middle, right);

        }

    }

    public static void merge(int[] a, int left, int middle, int right)

    {

        int temp = left;// 临时数组的下标

        int temp1 = left;

        int mid = middle + 1;// 右边数组的起始下标

        int[] tempArray = new int[a.length];// 存储合并排序好之后的数组

        while (left <= middle && mid <= right)

        {

            if (a[left] <= a[mid])

            {

                tempArray[temp] = a[left];

                temp++;

                left++;

            } else

            {

                tempArray[temp] = a[mid];

                temp++;

                mid++;

            }

        }

        // 将剩下的左边或者右边的元素追加到临时数组中

        while (left <= middle)

        {

            tempArray[temp] = a[left];

            temp++;

            left++;

        }

        while (mid <= right)

        {

            tempArray[temp] = a[mid];

            temp++;

            mid++;

        }

        // 将排序好的临时数组复制到a原始数组中(???)

        while(temp1<=right)

        {

            a[temp1] = tempArray[temp1];

            temp1++;

        }

    }

}

/*

 * author by junby

 * 快速排序

 * 2013.8.27

 */

package com.xzb.sort;

public class QuickSort

{

    public static int data[];

    // 返回基准下标

    public static int middle(int[] a, int low, int high)

    {

        int pivot = a[low];// 基准元素

        while (low < high)

        {

            while (low < high && a[high] > pivot)

            {

                high--;

            }

            a[low] = a[high];// 如果比基准大，交换位置

            while (low < high && a[low] < pivot)

            {

                low++;

            }

            a[high] = a[low];

        }

        a[low] = pivot;

        return low;

    }

    public static void quicksort(int[] data, int low, int high)

    {

        int p;

        if (low < high)

        {

            p = middle(data, low, high);

            quicksort(data, low, p - 1);

            quicksort(data, p + 1, high);

        }

    }

    public static void main(String[] args)

    {

        int a[] =

        { 44, 22, 2, 32, 54, 22, 88, 77, 99, 11 };

        quicksort(a, 0, 9);

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

        {

            System.out.print(a[i]);

            System.out.print(" ");

        }

    }

}

/*

 * 基排序

 * author by junby

 * 2013.9.1

 */

package com.xzb.sort;

public class Radixsort

{

    public static void main(String[] args)

    {

        int[] data =

        { 15, 51, 32, 43, 91, 17, 8 };

        radixsort(data);

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

        {

            System.out.print(data[i]);

            System.out.print(" ");

        }

    }

    public static void radixsort(int[] a)

    {

        int max = 0;// 确定这个数组中最大的值

        int count = 0;// 确定最高位数

        int[][] temp = new int[10][a.length];

        int[] order = new int[10];// 每个桶中的初始存放元素的个数

        int nowcount = 0;

        int n =1;//获取个十百..的数字时使用

        int k = 0; //用来覆盖原来数组的下标

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

        {

            if (max < a[i])

            {

                max = a[i];

            }

        }

        // 根据最大数确定最高位数

        while (max / 10 != 0)

        {

            count++;

            max = max / 10;

        }

        while (nowcount <= count)

        {

            // 利用当前位数放入桶中

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

            {

                // 获取位数

                int lsd = (a[i]/n) % 10;

                temp[lsd][order[lsd]] = a[i]; //同一个桶，即在同一行后面添加新数据如1桶中  11  21

                order[lsd]++;

            }

            

            //从十个桶中取出数据

            for (int i = 0; i < 10; i++)

            {

                //说明当前的桶里面有数据

                if(order[i]!=0)

                {

                    for (int j = 0; j < order[i]; j++)

                    {

                        a[k] = temp[i][j];

                        k++;

                    }

                    order[i] = 0;//取出元素之后置为0，说明该桶中无元素

                }

            }

            k = 0;

            nowcount++;

            n = 10*n;

        }

    }

}

/*

 * author by junby

 * 选择排序

 * 2012.8.28

 */

package com.xzb.sort;

public class Selectsort

{

    public static void main(String[] args)

    {

        int[] a ={2,5,4,8,7,1};

        selectsort(a);

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

        {

            System.out.print(a[i]);

            System.out.print(" ");

        }

    }

    

    public static void selectsort(int data[])

    {

        int position = 0;//记录比较之后最小数值的位置以备后面进行交换

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

        {

            int min = data[i];

            position = i; //将当前的下标定义为最小值

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

            {

                if(data[j]<min)

                {

                    min = data[j];

                    position = j;//记录最小值得下标

                }

            }

            

            int temp;

            temp = data[i];

            data[i] = data[position];

            data[position] = temp;

        }

    }

}

/*

 * author by junby

 * 希尔排序

 * 2013.8.28

 */

package com.xzb.sort;

public class Shellsort

{

    public static void main(String[] args)

    {

        int[] data =

        { 1, 5, 3, 4, 9, 7, 8 };

        shellsort(data);

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

        {

            System.out.print(data[i]);

            System.out.print(" ");

        }

    }

    public static void shellsort(int[] data)

    {

        int datalenght = (int) Math.ceil(data.length / 2);

        while (datalenght != 0)

        {

            for (int i = datalenght; i < data.length; i++)

            {

                int j = i - datalenght;

                int temp = data[i];

                while (j >= 0 && data[j] > temp)

                {

                    data[j + datalenght] = data[j];

                    j = j - datalenght;

                }

                data[j + datalenght] = temp;

            }

            datalenght = datalenght / 2;

        }

    }

}