java程序员面试笔试宝典8.3排序

1如何进行选择排序

1）对于给定的一组纪录，经过第一轮比较得到最小的纪录将该纪录与第一个纪录的位置进行交换。
2）接着对不包括第一个纪录以外的其他纪录进行第二轮比较，得到最小的纪录并与第二个纪录进行位置交换。
3）重复该过程，直到进行比较的纪录只有一个时为止。

以数组{38，65，97，76，13，27，49}为例
public class TestSort {

    public static void selectSort(int[] a){
        int i;
        int j;
        int temp = 0;
        int flag = 0;
        int n = a.length;
        for (i = 0; i < n; i++) {
            temp = a[i];
            flag = i;
            for (j = i+1;  j< n; j++) {
                if(a[j]<temp){
                    temp = a[j];
                    flag = j;
                }
            }
            if(flag != i){
                a[flag] = a[i];
                a[i] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int i = 0;
        int a[] = {38,65,97,76,13,27,49};
        //int a[] = {5,4,9,8,7,6,0,1,2,3};
        selectSort(a);
        for (i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println("\n");
    }
}

结果：
13 27 38 49 65 76 97 

2.如何进行插入排序：

对于给定的一组纪录，初始时假设第一个纪录自成一个有序序列，其余纪录为无序序列。
接着从第二个纪录开始，按照纪录的大小依次将当前处理的纪录插入到其之前的有序序列中，直至最后一个纪录插入到有序序列中为止。

以数组{38，65，97，76，13，27，49}为例
public class TestSort {

    //插入排序
    public static void insertSort(int[] a){
        if(a!=null){
            for (int i = 1; i < a.length; i++) {
                int temp = a[i],j=i;
                if(a[j-1]>temp){
                    while(j>=1&&a[j-1]>temp){
                        a[j] = a[j-1];
                        j--;
                    }
                }
                a[j] = temp;
            }
        }
    }

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

结果：
13 27 38 49 65 76 97 

3.如何进行冒泡排序？

对于给定的n个纪录，从第一个纪录开始依次比较相邻两个纪录进行比较，当前面的纪录大于后面的纪录时，交换位置
进行一轮比较和换位后，n个纪录中的最大记录将位于第n位
然后对前（n-1）个记录进行第二轮比较
重复该过程直到进行比较的记录只剩下一个为止。

public class MaxMin {

    public static void BubbleSort(int[] array){
        int i;
        int j;
        int len = array.length;
        int tmp;
        for (i = 0; i < len; i++) {
            /*for (j = len-1; j >i; --j) {
                if(array[j]<array[j-1]){
                    tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                }
            }*/

            for (j=1;j<len-i;j++) {
                if(array[j-1]>array[j]){
                    tmp = array[j-1];
                    array[j-1] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {5,4,9,8,7,6,0,1,3,2};
        BubbleSort(a);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

结果：
0 1 2 3 4 5 6 7 8 9 

4.如何进行归并排序？

5.如何进行快速排序？

采用分而治之的思想，把大的拆分为小的，小的拆分为更小的。
对于一组给定的记录，通过一趟排序后，将原序列分为两个部分，其中前一部分的所有记录均比后一部分的所有记录小
然后再依次对前后两部分的记录进行快速排序，直到序列中所有记录均有序为止。

public class Test {

    public static void sort(int array[],int low,int high){
        int i,j;
        int index;//作为key
        if(low>=high){
            return;
        }
        i = low;
        j = high;
        index = array[i];
        while(i<j){
            while(i<j && array[j]>=index){
                j--;
            }
            if(i<j){
                array[i++]=array[j];
            }
            while(i<j && array[i]<index){
                i++;
            }
            if(i<j){
                array[j--] = array[i];
            }
        }

        array[i] = index;
        sort(array, low, i-1);
        sort(array, i+1, high);
    }

    public static void quickSort(int array[]){
        sort(array, 0, array.length-1);
    }

    public static void main(String[] args) {
        int i = 0;
        int a[] = {5,4,9,8,7,6,0,1,3,2};
        int len = a.length;
        quickSort(a);
        for (i = 0; i < len; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

结果：
0 1 2 3 4 5 6 7 8 9