插入排序与冒泡排序集合框架实现

• 插入排序与冒泡排序的实现：

import java.util.ArrayList;

/**
@author:micro_hz
2015年9月2日
 */
public class Order {
    /*
     * 插入排序,升序
     */
    public static ArrayList<Integer> insertSortAsc(ArrayList<Integer> arrayList)
    {
        if(arrayList == null)
        {
            return null;
        }
        //定义一个列表，是排好序的列表
        ArrayList<Integer> orderedList = new ArrayList<Integer>();
        //首先将第一个值插入到排序好的列表中
        orderedList.add(arrayList.get(0));
        for(int i = 1;i < arrayList.size();i ++)//定义比较多少次
        {
            //先放到最后的位置,起占位的作用
            orderedList.add(arrayList.get(i));
            for(int j = i - 1;j >= 0;j --)
            {
                if(orderedList.get(j) > arrayList.get(i))
                {
                    //如果排好序的列表前面的数字大于则后移
                    orderedList.set(j + 1, orderedList.get(j));
                    orderedList.set(j, arrayList.get(i));
                }
            }
        }
        return orderedList;
    }
    /*
     * 插入排序，降序
     */
    public static ArrayList<Integer> insertSortDesc(ArrayList<Integer> arrayList)
    {
        if(arrayList == null)
        {
            return null;
        }
        //定义一个列表，是排好序的列表
        ArrayList<Integer> orderedList = new ArrayList<Integer>();
        //首先将第一个值插入到排序好的列表中
        orderedList.add(arrayList.get(0));
        for(int i = 1;i < arrayList.size();i ++)//定义比较多少次
        {
            //先放到最后的位置,起占位的作用
            orderedList.add(arrayList.get(i));
            for(int j = i - 1;j >= 0;j --)
            {
                if(orderedList.get(j) < arrayList.get(i))
                {
                    //如果排好序的列表前面的数字大于则后移
                    orderedList.set(j + 1, orderedList.get(j));
                    orderedList.set(j, arrayList.get(i));
                }
            }
        }
        return orderedList;
    }
    /*
     * 冒泡排序，升序
     */
    public static ArrayList<Integer> bubbleOrderAsc(ArrayList<Integer> arrayList)
    {
        //冒泡size - 1次
        for(int i = 0;i < arrayList.size() - 1;i ++)
        {
            for(int j = 0;j < arrayList.size() - i - 1;j ++)
            {
                //若前一个大于后一个，则交换
                if(arrayList.get(j) > arrayList.get(j + 1))
                {
                    Integer temp = arrayList.get(j);
                    arrayList.set(j, arrayList.get(j + 1));
                    arrayList.set(j + 1, temp);
                }
            }
        }
        return arrayList;
    }
    /*
     * 冒泡排序，降序
     */
    public static ArrayList<Integer> bubbleOrderDesc(ArrayList<Integer> arrayList)
    {
        //冒泡size - 1次
        for(int i = 0;i < arrayList.size() - 1;i ++)
        {
            for(int j = 0;j < arrayList.size() - i - 1;j ++)
            {
                //若前一个大于后一个，则交换
                if(arrayList.get(j) < arrayList.get(j + 1))
                {
                    Integer temp = arrayList.get(j);
                    arrayList.set(j, arrayList.get(j + 1));
                    arrayList.set(j + 1, temp);
                }
            }
        }
        return arrayList;
    }
}

测试：

import java.util.ArrayList;
import java.util.List;

/**
@author:micro_hz
2015年9月2日
 */
public class OrderTest {
    public static void main(String args[])
    {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //随机生成10个两位数
        for (int i = 0; i < 10; i++) 
        {
            int temp = (int) (Math.random() * 100);
            System.out.println(temp);
            list.add(temp);
        }
        System.out.println("下面为排序后输出");
        //调用插入排序 
        System.out.println("以下为插入升序排序的结果");
        List<Integer> orderedList = Order.insertSortAsc(list);
        for(Integer i : orderedList)
        {
            //打印数字
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println("以下为插入降序排序的结果");
        List<Integer> orderedList2 = Order.insertSortDesc(list);
        for(Integer i : orderedList2)
        {
            //打印数字
            System.out.print(i + " ");
        }
        //调用冒泡排序的升序
        System.out.println();
        System.out.println("以为为冒泡排序的升序的结果");
        List<Integer> orderList3 = Order.bubbleOrderAsc(list);
        for(Integer i : orderList3)
        {
            //打印数字
            System.out.print(i + " ");
        }
        //调用冒泡排序的降序
        System.out.println();
        System.out.println("以为为冒泡排序的降序的结果");
        List<Integer> orderList4 = Order.bubbleOrderDesc(list);
        for(Integer i : orderList4)
        {
            //打印数字
            System.out.print(i + " ");
        }

    }
}

运行结果：