排序

冒泡排序

 

 

代码：

public static void ArraySortTest() {

        int[] ages= {21,27,31,19,50,32,16,25};
        System.out.println(Arrays.toString(ages));
        //控制比较轮数
        for(int i=1;i<ages.length;i++) {
            //每轮比较多少
            for(int j=0;j<ages.length-i;j++) {
                if(ages[j]>ages[j+1]) {
                    int tmp=0;
                    tmp=ages[j];
                    ages[j]=ages[j+1];
                    ages[j+1]=tmp;                    
                }
            }
        }
System.out.println(Arrays.toString(ages));

选择排序

1、记录数组第一个元素的值（数组长度n）。

2、遍历n-1次，用该值与其他元素比较，找到最大或者最小的一个数交换。

3、记录数组第二个元素的值。

4、遍历n-2次，用该值与其他元素比较，找到最大或者最小的一个数交换。

5、重复上述步骤，遍历N次，直到没有要比较的数。

 

 

 代码：

int array[] = { 7,10,12,3,9,5 };
  for (int i = 0; i < 6; i++)
  {
    int minkey = array[i];
    for (int j = i + 1; j < 6; j++)
    {
      if (minkey < array[j])
      {
        int tamp = array[j];
        array[j] = minkey;
        minkey = tamp;
      }
    }
    array[i] = minkey;
  }

插入排序

基本思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表只包含一个元素，无序表中包含

有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，

将它插入到有序表中的适当位置，使之成为新的有序表。

 

 

 代码：

    publicstaticvoidinsertSort(intarr[]) {
        for (inti = 1; i < arr.length; i++) {
//定义待插入的值
            intinsertVal = arr[i];
            intinsertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
//说明待排序的值小于前面的值，所以前面的要往后移
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
//当退出while循环时，说明找到插入位置，insertIndex+1
            arr[insertIndex + 1] = insertVal;
            System.out.println("第" + i + "轮插入：");
            System.out.println(Arrays.toString(arr));
        }
    }

希尔排序

 

基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，

每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

 

 

 交换时使用交换法：

代码：

    publicstaticvoidShellSort(int[] arr) {
        inttemp = 0;
        intcount = 0;
//根据元素总长进行分步长
        for (intgap = arr.length / 2; gap > 0; gap /= 2) {
//遍历各组元素中所有的元素
            for (inti = gap; i < arr.length; i++) {
                for (intj = i - gap; j >= 0; j -= gap) {
//如果前面的元素比后面的元素大就进行换位
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
            System.out.println("第" + (++count) + "轮排序：");
            System.out.println(Arrays.toString(arr));
        }
    }

交换时使用移位法：

代码：

    publicstaticvoidShellShot2(int[] arr) {
        intcount = 0;
        for (intgap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素，逐个对其所在的组进行直接插入排序
            for (inti = gap; i < arr.length; i++) {
                intj = i;
                inttemp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
//当退出while循环时，就给temp找到插入的位置
                    arr[j] = temp;
                }
            }
            System.out.println("第" + (++count) + "轮排序：");
            System.out.println(Arrays.toString(arr));
        }
    }

 

快速排序

 

基本思想：快速排序是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，

其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行

快速排序，整个排序过程可以递归进行以此达到整个数据变成有序序列。

 代码：

    publicstaticvoidQuickSort(int[] arr, intleft, intright) {
        intl = left;
        intr = right;
        intmid = arr[(right - left) / 2];//中间值
        inttemp = 0;//记录交换时的值
        while (l < r) {
//当左边的值比中间的值大下标就往右移
            while (arr[l] < mid) {
                l += 1;
            }
//当右边的值比中间的值小下标就往左移
            while (arr[r] > mid) {
                r -= 1;
            }
//当左边的下标大于或等于时退出循环
            if (l >= r) {
                break;
            }
//交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
//当交换完后arr[l]==mid时，r--
            if (arr[l] == mid) {
                r -= 1;
            }
//当交换完后arr[r]==mid时，l++
            if (arr[r] == mid) {
                l += 1;
            }
        }
//如果r==l就必须让r--l++否则会出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }
//向左递归
        if (left < r) {
            QuickSort(arr, left, r);
        }
//向右递归
        if (right > l) {
            QuickSort(arr, l, right);
        }
    }

归并排序

 

归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略成一些小的问题然后递归求解，

而治的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之。

 代码：

    publicclassMergeSort {
        publicstaticvoidmain(String[]args){
            int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
            int[] temp = newint[arr.length];//归并排序需要额外的空间
            mergeShot(arr, 0, arr.length - 1, temp);
            System.out.println("归并排序后=" + Arrays.toString(arr));
        }
//分+合的方法
        publicstaticvoidmergeShot( int[] arr, intleft, intright, int[] temp){
            if (left < right) {
                intmid = (left + right) / 2;//中间索引
//向左递归
                mergeShot(arr, left, mid, temp);
//向右递归
                mergeShot(arr, mid + 1, right, temp);
//合并
                merge(arr, left, mid, right, temp);
            }
        }

/**
 *
 *@paramarr传入的数组
 *@paramleft左边的索引值
 *@parammid中间的索引值
 *@paramright右边的索引值
 *@paramtemp临时数组保存已排序的数组
 */
//将数组合并
        publicstaticvoidmerge( int[] arr, intleft, intmid, intright, int[] temp){
            inti = left;
            intj = mid + 1;
            intt = 0;//记录temp的位置

//将左右两边（有序）按照规则填充到temp中
//直到有一边填充完毕
            while (i <= mid && j <= right) {
                if (arr[i] <= arr[j]) {
//如果左边的值小于右边的值，就将左边的值记录到temp中
                    temp[t] = arr[i];
                    t += 1;
                    i += 1;
                } else {
//如果右边的值小于左边的值，就将右边的值记录到temp中
                    temp[t] = arr[j];
                    t += 1;
                    j += 1;
                }
            }
//将剩余数依次填充到temp中
            while (i <= mid) {
//左边还有剩余的数组，要依次填充到temp中
                temp[t] = arr[i];
                t += 1;
                i += 1;
            }
            while (j <= right) {
//右边还有剩余的数组，要依次填充到temp中
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
//将temp中的数组拷到arr中
//不是每次都拷所有的
            t = 0;
            inttempLeft = left;
            while (tempLeft <= right) {
                arr[tempLeft] = temp[t];
                t += 1;
                tempLeft += 1;
            }
        }
    }

基数排序

 

基数排序属于“分配式排序”，又称“桶子法”，它是通过键值得各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。

基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法。

基数排序是1887年赫尔曼何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字。然后按每个位数分别比较。

基数排序是对传统的桶排序的扩展，速度很快，基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序是容易造成OutMemoryError。

 代码：

    importjava.util.Arrays;

    publicclassRadixSort {
        publicstaticvoidmain(String[]args){
            int[] arr = {53, 3, 542, 748, 14, 214};
            radixSort(arr);
        }
        publicstaticvoidradixSort( int[] arr){
//根据推导可以得出最终的代码
//先找出数组中最大数的最大位数
            intmax = arr[0];//假定第一个数为最大的数
            for (inti = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
//得到最大数的位数
            intmaxLength = (max + "").length();

//定义一个二维数组，表示10个桶，每个桶就是一个一维数组
            int[][] bucket = newint[10][arr.length];

//定义一个一维数组，记录每次在一维数组中放入的数据个数
            int[] bucketElementCounts = newint[10];

//使用循环将代码整合
            for (intl = 0, x = 1; l < maxLength; l++, x *= 10) {
//每一次循环取出对应的位数
                for (inti = 0; i < arr.length; i++) {
                    intdigitOfElement = arr[i] / x % 10;

//将这个数放入对应的桶中
                    bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
                    bucketElementCounts[digitOfElement]++;
                }
//定义一个index记录原数组当前位置
                intindex = 0;
//按照桶的顺序把每个数按顺序取出到原数组中
                for (intj = 0; j < bucket.length; j++) {
//如果桶中有数据就按顺序取出
                    if (bucketElementCounts[j] != 0) {
//循环第j个桶，放入
                        for (intk = 0; k < bucketElementCounts[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
//在每第一轮过后需要将bucketElementCounts[]置零
                    bucketElementCounts[j] = 0;
                }
                System.out.println("第" + (l + 1) + "轮排序的结果" + Arrays.toString(arr));
            }
        }
    }