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;
        }
    }
}