##注：从小到大排

##冒泡排序##

特点：效率低，实现简单

public void bubbleSort(int array[]) {

                int t = 0;

                        for (int j = 0; j < array.length - 1 - i; j++)

                                if (array[j] > array[j + 1]) {

                                        t = array[j];

                                        array[j] = array[j + 1];

                                        array[j + 1] = t;

                                }

        }

##选择排序##

特点：效率低，容易实现。

思想：每一趟从待排序序列选择一个最小的元素放到已排好序序列的末尾，剩下的为待排序序列，重复上述步骤直到完成排序。

public void selectSort(int array[]) {

                for (int i = 0; i < array.length - 1; i++){

                        int index=i;

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

                                if (array[index] > array[j])

                                        index=j;

                        if(index!=i){ //找到了比array小的则与array交换位置

                                t = array;

                                array = array[index];

                                array[index] = t;

                        }

                }

        }

8

1

##插入排序##

游客，如果您要查看本帖隐藏内容请回复

快速排序

特点：高效，时间复杂度为nlogn。

采用分治法的思想：首先设置一个轴值pivot，然后以这个轴值为划分基准将待排序序列分成比pivot大和比pivot小的两部分，接下来对划分完的子序列进行快排直到子序列为一个元素为止。

public void quickSort(int array[], int low, int high) {// 传入low=0，high=array.length-1;

                int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。

                if (low < high) {

                        p_pos = low;

                        pivot = array[p_pos];

                        for (i = low + 1; i <= high; i++)

                                if (array > pivot) {

                                        p_pos++;

                                        t = array[p_pos];

                                        array[p_pos] = array;

                                        array = t;

                                }

                        t = array[low];

                        array[low] = array[p_pos];

                        array[p_pos] = t;

                        // 分而治之

                        quickSort(array, low, p_pos - 1);// 排序左半部分

                        quickSort(array, p_pos + 1, high);// 排序右半部分

                }

##注：从小到大排

##冒泡排序##

特点：效率低，实现简单

public void bubbleSort(int array[]) {

                int t = 0;

                        for (int j = 0; j < array.length - 1 - i; j++)

                                if (array[j] > array[j + 1]) {

                                        t = array[j];

                                        array[j] = array[j + 1];

                                        array[j + 1] = t;

                                }

        }

##选择排序##

特点：效率低，容易实现。

思想：每一趟从待排序序列选择一个最小的元素放到已排好序序列的末尾，剩下的为待排序序列，重复上述步骤直到完成排序。

public void selectSort(int array[]) {

                for (int i = 0; i < array.length - 1; i++){

                        int index=i;

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

                                if (array[index] > array[j])

                                        index=j;

                        if(index!=i){ //找到了比array小的则与array交换位置

                                t = array;

                                array = array[index];

                                array[index] = t;

                        }

                }

        }

8

1

##插入排序##

游客，如果您要查看本帖隐藏内容请回复

快速排序

特点：高效，时间复杂度为nlogn。

采用分治法的思想：首先设置一个轴值pivot，然后以这个轴值为划分基准将待排序序列分成比pivot大和比pivot小的两部分，接下来对划分完的子序列进行快排直到子序列为一个元素为止。

public void quickSort(int array[], int low, int high) {// 传入low=0，high=array.length-1;

                int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。

                if (low < high) {

                        p_pos = low;

                        pivot = array[p_pos];

                        for (i = low + 1; i <= high; i++)

                                if (array > pivot) {

                                        p_pos++;

                                        t = array[p_pos];

                                        array[p_pos] = array;

                                        array = t;

                                }

                        t = array[low];

                        array[low] = array[p_pos];

                        array[p_pos] = t;

                        // 分而治之

                        quickSort(array, low, p_pos - 1);// 排序左半部分

                        quickSort(array, p_pos + 1, high);// 排序右半部分

                }