ShihChieh_Ma
ShihChieh_Ma

排序笔记

/**
 * @author: shihchieh.ma
 * @create: 2020/6/15 6:13 下午
 * @email: [email protected]
 * @description:
 */
public class Sort {

  public static final int[] INTS = {
    //        24, 352, 23, 4, 1, 421, 5, 6, 436, 7, 86, 97, 9, 74, 34, 234, 1, 3, 6, 7
    10, 8, 6, 4, 2
  };

/**
   * @param n 生成n个元素的随机数组
   * @param rangeL 随机范围[rangeL
   * @param rangeR rangeR]
   * @return 返回一个随机 int 型数组
   */
  public static int[] gennerateArray(int n, int rangeL, int rangeR) {
    int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
      arr[i] = (int) (Math.random() * (rangeR - rangeL + 1)) + rangeL;
    }
    return arr;
  }

  public static void main(String[] args) {
    //    int[] INTS = gennerateArray(1000, 10);
    long startTime, endTime;
    //    冒泡排序
    int[] bubbleArr = INTS.clone();
    startTime = System.currentTimeMillis();
    bubbleSort(bubbleArr);
    endTime = System.currentTimeMillis();
    printArray("冒泡排序:", bubbleArr, endTime - startTime);

    //    选择排序
    int[] selectionArr = INTS.clone();
    startTime = System.currentTimeMillis();
    selectionSort(selectionArr);
    endTime = System.currentTimeMillis();
    printArray("选择排序:", selectionArr, endTime - startTime);

    //    插入排序
    int[] insertArr = INTS.clone();
    startTime = System.currentTimeMillis();
    insertSort(insertArr);
    endTime = System.currentTimeMillis();
    printArray("插入排序:", insertArr, endTime - startTime);

    //    快速排序
    int[] quickArr = INTS.clone();
    startTime = System.currentTimeMillis();
    quickSort(quickArr, 0, quickArr.length - 1);
    endTime = System.currentTimeMillis();
    printArray("快速排序:", quickArr, endTime - startTime);

    //    计数排序
    int[] countArr = INTS.clone();
    startTime = System.currentTimeMillis();
    int[] countSort = countSort(countArr);
    endTime = System.currentTimeMillis();
    printArray("计数排序:", countSort, endTime - startTime);

    //    基数排序
    int[] radixArr = INTS.clone();
    startTime = System.currentTimeMillis();
    radixSort(radixArr);
    endTime = System.currentTimeMillis();
    printArray("基数排序:", radixArr, endTime - startTime);

    // 桶排序
    int[] bucketArr = INTS.clone();
    startTime = System.currentTimeMillis();
    int[] bucketSort = bucketSort(bucketArr);
    endTime = System.currentTimeMillis();
    printArray("桶排序:", bucketSort, endTime - startTime);

    // 归并排序
    int[] mergeArr = INTS.clone();
    startTime = System.currentTimeMillis();
    mergeSort(mergeArr, 0, mergeArr.length - 1, new int[mergeArr.length]);
    endTime = System.currentTimeMillis();
    printArray("归并排序:", mergeArr, endTime - startTime);

    // 希尔排序
    int[] shellArr = INTS.clone();
    startTime = System.currentTimeMillis();
    shellSort(shellArr);
    endTime = System.currentTimeMillis();
    printArray("希尔排序:", shellArr, endTime - startTime);

    // 堆排序
    int[] heapArr = INTS.clone();
    startTime = System.currentTimeMillis();
    heapSort(heapArr);
    endTime = System.currentTimeMillis();
    printArray("堆排序:", heapArr, endTime - startTime);
  }

  private static void printArray(String name, int[] ints, long time) {
    for (int anInt : ints) {
      System.out.print("_" + anInt + "_");
    }
    System.out.println("\t");
    System.out.println(name + "耗时:" + time);
    System.out.println();
  }
}

冒泡排序

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  /** 冒泡排序 */
  private static void bubbleSort(int[] clone) {
    for (int i = 0, j = clone.length; i < j; i++) {
      for (int k = 0, l = j - 1 - i; k < l; k++) {
        if (clone[k] > clone[k + 1]) {
          clone[k] = clone[k] ^ clone[k + 1];
          clone[k + 1] = clone[k] ^ clone[k + 1];
          clone[k] = clone[k] ^ clone[k + 1];
        }
      }
    }
  }

选择排序

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
  2. 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
  3. 以此类推，直到所有元素均排序完毕
  /** 选择排序 */
  private static void selectionSort(int[] clone) {
    for (int i = 0, j = clone.length; i < j; i++) {
      int minIndex = i;
      for (int k = i; k < j; k++) {
        if (clone[k] < clone[minIndex]) {
          minIndex = k;
        }
      }
      if (minIndex != i) {
        clone[i] = clone[i] + clone[minIndex];
        clone[minIndex] = clone[i] - clone[minIndex];
        clone[i] = clone[i] - clone[minIndex];
      }
    }
  }

插入排序

  1. 第一个元素开始，该元素可以认为已经被排序
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
  5. 将新元素插入到该位置后
  6. 重复步骤 2->5
  /** 插入排序 */
  private static void insertSort(int[] clone) {
    for (int i = 1, j = clone.length; i < j; i++) {
      int k = i;
      int temp = clone[k];
      while (k > 0 && clone[k - 1] > temp) {
        clone[k] = clone[k - 1];
        k--;
      }
      clone[k] = temp;
    }
  }

快速排序

  1. 选取第一个数为基准
  2. 将比基准小的数交换到前面，比基准大的数交换到后面
  3. 对左右区间重复第二步，直到各区间只有一个数
  /**
   * 快速排序
   *
   * @param clone 数组
   * @param leftIndex 左边角标 初始0
   * @param rightIndex 右边角标 初始length-1
   */
  private static void quickSort(int[] clone, int leftIndex, int rightIndex) {
    // temp-基准位
    int i, j, temp;
    if (leftIndex > rightIndex) {
      return;
    }
    i = leftIndex;
    j = rightIndex;
    temp = clone[leftIndex];
    while (i < j) {
      // 先右边，往左递减,找一个小于基准位的数
      // 当右边的角标位置所在的数>基准位的数时，继续从右往左找（同时 j 索引-1)
      // 找到就跳出 while循环
      while (temp <= clone[j] && i < j) {
        j--;
      }
      // 再左边，往右递增
      // 如上
      while (temp >= clone[i] && i < j) {
        i++;
      }
      // 满足条件则交换
      if (i < j) {
        clone[i] = clone[i] + clone[j];
        clone[j] = clone[i] - clone[j];
        clone[i] = clone[i] - clone[j];
      }
    }
    // i=j 左右在同一位置
    // 最后将基准为与i和j相等位置的数字交换
    clone[leftIndex] = clone[i];
    clone[i] = temp;
    // 左半数组<(i或j所在索引的数)<右半数组
    // 也就是说(i或j所在索引的数)已经确定排序位置，就不用再排序了，
    // 相同的方法分别处理左右数组
    // 递归调用左半数组
    quickSort(clone, leftIndex, j - 1);
    // 递归调用右半数组
    quickSort(clone, j + 1, rightIndex);
  }

计数排序

  1. 找出待排序的数组中最大和最小的元素；
  2. 统计数组中每个值为 i 的元素出现的次数，存入数组 C 的第 i 项；
  3. 对所有的计数累加（从 C 中的第一个元素开始，每一项和前一项相加）；
  4. 向填充目标数组：将每个元素 i 放在新数组的第 C[i] 项，每放一个元素就将 C[i] 减去 1；

当数组最大和最小差值过大时，不适合计数排序
当数组元素不是整数时，不适合用计数排序

  /** 计数排序 */
  private static int[] countSort(int[] clone) {
    int max = clone[0];
    int min = clone[0];
    for (int i = 1, j = clone.length; i < j; i++) {
      if (clone[i] > max) {
        max = clone[i];
      }
      if (clone[i] < min) {
        min = clone[i];
      }
    }
    int dValue = max - min;
    int[] countArray = new int[dValue + 1];
    for (int value : clone) {
      countArray[value - min]++;
    }
    // 统计数组做变形，后边的元素等于前面的元素之和
    for (int i = 1; i < countArray.length; i++) {
      countArray[i] += countArray[i - 1];
    }
    // 倒序遍历原始数组，从统计数组中找到正确的位置，输出到结果数组
    int[] sortedArray = new int[clone.length];
    for (int i = clone.length - 1; i >= 0; i--) {
      // 给sortedArray的当前位置赋值
      sortedArray[countArray[clone[i] - min] - 1] = clone[i];
      // 给countArray的位置的值--
      countArray[clone[i] - min]--;
    }
    return sortedArray;
  }

基数排序

  1. 取得数组中的最大数，并取得位数；
  2. arr为原始数组，从最低位开始取每个位组成radix数组；
  3. 对radix进行计数排序
  /** 基数排序 */
  private static void radixSort(int[] clone) {
    int maxLength = 0;
    // 最大位数
    for (int i : clone) {
      int length = String.valueOf(i).length();
      maxLength = Math.max(length, maxLength);
    }
    List> list =
        new ArrayList>() {
          {
            // 0-9
            for (int i = 0; i < 10; i++) {
              add(new ArrayList<>());
            }
          }
        };
    for (int i = 0, temp = 1; i < maxLength; temp *= 10, i++) {
      for (int value : clone) {
        list.get((value / temp) % 10).add(value);
      }
      for (int j = 0, k = 0, l = list.size(); j < l; j++) {
        while (!list.get(j).isEmpty()) {
          clone[k] = list.get(j).get(0);
          list.get(j).remove(0);
          k++;
        }
      }
    }
  }

桶排序

  1. 设置一个定量的数组当作空桶子。
  2. 寻访序列，并且把项目一个一个放到对应的桶子去。
  3. 对每个不是空的桶子进行排序。
  4. 从不是空的桶子里把项目再放回原来的序列中。
 /** 桶排序 */
  private static int[] bucketSort(int[] clone) {
    int maxLength = 0, minLength = 0;
    // 最大位数and最小位数
    for (int i = 0, j = clone.length; i < j; i++) {
      int length = String.valueOf(clone[i]).length();
      maxLength = Math.max(length, maxLength);
      if (i == 0) {
        minLength = length;
      } else {
        minLength = Math.min(length, minLength);
      }
    }
    // 新建一个桶的集合
    List> buckets = new ArrayList<>();
    for (int i = 0, j = maxLength - minLength + 1; i < j; i++) {
      // 新建一个桶，并将其添加到桶的集合中去。
      buckets.add(new LinkedList<>());
    }
    for (int i : clone) {
      int index = String.valueOf(i).length() - 1;
      LinkedList integers = buckets.get(index);
      integers.add(i);
    }
    int[] finalArr = new int[clone.length];
    int tempIndex = 0;
    // 计数排序
    for (LinkedList integers : buckets) {
      if (integers.size() > 0) {
        int max = integers.get(0);
        int min = integers.get(0);
        for (Integer i : integers) {
          if (i > max) {
            max = i;
          }
          if (i < min) {
            min = i;
          }
        }
        int dValue = max - min;
        int[] countArray = new int[dValue + 1];
        for (int value : integers) {
          countArray[value - min]++;
        }
        // 统计数组做变形，后边的元素等于前面的元素之和
        for (int i = 1; i < countArray.length; i++) {
          countArray[i] += countArray[i - 1];
        }
        // 倒序遍历原始数组，从统计数组中找到正确的位置，输出到结果数组
        Integer[] sortedArray = new Integer[integers.size()];
        for (int i = integers.size() - 1; i >= 0; i--) {
          // 给sortedArray的当前位置赋值
          sortedArray[countArray[integers.get(i) - min] - 1] = integers.get(i);
          // 给countArray的位置的值--
          countArray[integers.get(i) - min]--;
        }
        for (Integer integer : sortedArray) {
          finalArr[tempIndex++] = integer;
        }
      }
    }
    return finalArr;
  }

归并排序

  1. 把长度为n的输入序列分成两个长度为n/2的子序列；
  2. 对这两个子序列分别采用归并排序；
  3. 将两个排序好的子序列合并成一个最终的排序序列。
  /**
   * 归并排序
   *
   * @param ints 数组
   * @param start 左角标
   * @param end 右角标
   * @param tempArr 辅助数组
   */
  private static void mergeSort(int[] ints, int start, int end, int[] tempArr) {
    // 当子序列中只有一个元素时结束递归
    if (start < end) {
      // 划分子序列
      int mid = (start + end) / 2;
      // 对左侧子序列进行递归排序
      mergeSort(ints, start, mid, tempArr);
      // 对右侧子序列进行递归排序
      mergeSort(ints, mid + 1, end, tempArr);
      // 合并
      merge(ints, start, mid, end, tempArr);
    }
  }
  /** 两路归并算法，两个排好序的子序列合并为一个子序列 */
  private static void merge(int[] ints, int left, int mid, int right, int[] tempArr) {
    int p1 = left, p2 = mid + 1, k = left;
    while (p1 <= mid && p2 <= right) {
      if (ints[p1] <= ints[p2]) {
        tempArr[k++] = ints[p1++];
      } else {
        tempArr[k++] = ints[p2++];
      }
    }
    while (p1 <= mid) {
      // 如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
      tempArr[k++] = ints[p1++];
    }
    while (p2 <= right) {
      tempArr[k++] = ints[p2++];
    }
    // 复制回原素组
    if (right + 1 - left >= 0) {
      System.arraycopy(tempArr, left, ints, left, right + 1 - left);
    }
  }

希尔排序

  1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列个数k，对序列进行k 趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
  /** 希尔排序 */
  public static void shellSort(int[] clone) {
    // 步长逐渐减小
    for (int gap = clone.length / 2; gap > 0; gap /= 2) {
      // 在同一步长内
      for (int i = gap; i < clone.length; i++) {
        // 同一步长内排序方式是插入排序
        int temp = clone[i], j;
        // j-gap代表有序数组中最大数的下标，j-pag表示有序数组的前一个元素，减pag是减去偏移量就是步长
        for (j = i; j >= gap && temp < clone[j - gap]; j -= gap) {
          // 原有序数组最大的后移一位
          clone[j] = clone[j - gap];
        }
        // 找到了合适的位置插入
        clone[j] = temp;
      }
    }
  }

堆排序

  1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
  2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
  3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
 /** 堆排序 */
  private static void heapSort(int[] clone) {
    // 创建堆
    for (int i = (clone.length - 1) / 2; i >= 0; i--) {
      // 从第一个非叶子结点从下至上，从右至左调整结构
      adjustHeap(clone, i, clone.length);
    }

    // 调整堆结构,交换堆顶元素与末尾元素
    for (int i = clone.length - 1; i > 0; i--) {
      // 将堆顶元素与末尾元素进行交换
      clone[i] = clone[i]+clone[0];
      clone[0] = clone[i]-clone[0];
      clone[i] = clone[i]-clone[0];
      // 重新对堆进行调整
      adjustHeap(clone, 0, i);
    }
  }

  /**
   * 调整堆
   *
   * @param arr 待排序列
   * @param parent 父节点
   * @param length 待排序列尾元素索引
   */
  private static void adjustHeap(int[] arr, int parent, int length) {
    // 将temp作为父节点
    int temp = arr[parent];
    // 左孩子
    int lChild = 2 * parent + 1;

    while (lChild < length) {
      // 右孩子
      int rChild = lChild + 1;
      // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
      if (rChild < length && arr[lChild] < arr[rChild]) {
        lChild++;
      }
      // 如果父结点的值已经大于孩子结点的值，则直接结束
      if (temp >= arr[lChild]) {
        break;
      }
      // 把孩子结点的值赋给父结点
      arr[parent] = arr[lChild];
      // 选取孩子结点的左孩子结点,继续向下筛选
      parent = lChild;
      lChild = 2 * lChild + 1;
    }
    arr[parent] = temp;
  }

练习代码

import java.util.*;

/**
 * @author: shihchieh.ma
 * @create: 2020/6/15 6:13 下午
 * @email: [email protected]
 * @description:
 */
public class Sort {

  public static final int[] INTS = {
    24, 352, 23, 4, 1, 421, 5, 6, 436, 7, 86, 97, 9, 74, 34, 234, 1, 3, 6, 7
    //    10, 8, 6, 4, 2
  };

  /**
   * @param n 生成n个元素的随机数组
   * @param rangeL 随机范围[rangeL
   * @param rangeR rangeR]
   * @return 返回一个随机 int 型数组
   */
  public static int[] gennerateArray(int n, int rangeL, int rangeR) {
    int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
      arr[i] = (int) (Math.random() * (rangeR - rangeL + 1)) + rangeL;
    }
    return arr;
  }

  public static void main(String[] args) {
    //        int[] INTS = gennerateArray(10000, 1,10001);
    long startTime, endTime;
    //    冒泡排序
    int[] bubbleArr = INTS.clone();
    startTime = System.currentTimeMillis();
    bubbleSort(bubbleArr);
    endTime = System.currentTimeMillis();
    printArray("冒泡排序:", bubbleArr, endTime - startTime);

    //    选择排序
    int[] selectionArr = INTS.clone();
    startTime = System.currentTimeMillis();
    selectionSort(selectionArr);
    endTime = System.currentTimeMillis();
    printArray("选择排序:", selectionArr, endTime - startTime);

    //    插入排序
    int[] insertArr = INTS.clone();
    startTime = System.currentTimeMillis();
    insertSort(insertArr);
    endTime = System.currentTimeMillis();
    printArray("插入排序:", insertArr, endTime - startTime);

    //    快速排序
    int[] quickArr = INTS.clone();
    startTime = System.currentTimeMillis();
    quickSort(quickArr, 0, quickArr.length - 1);
    endTime = System.currentTimeMillis();
    printArray("快速排序:", quickArr, endTime - startTime);

    //    计数排序
    int[] countArr = INTS.clone();
    startTime = System.currentTimeMillis();
    int[] countSort = countSort(countArr);
    endTime = System.currentTimeMillis();
    printArray("计数排序:", countSort, endTime - startTime);

    //    基数排序
    int[] radixArr = INTS.clone();
    startTime = System.currentTimeMillis();
    radixSort(radixArr);
    endTime = System.currentTimeMillis();
    printArray("基数排序:", radixArr, endTime - startTime);

    // 桶排序
    int[] bucketArr = INTS.clone();
    startTime = System.currentTimeMillis();
    int[] bucketSort = bucketSort(bucketArr);
    endTime = System.currentTimeMillis();
    printArray("桶排序:", bucketSort, endTime - startTime);

    // 归并排序
    int[] mergeArr = INTS.clone();
    startTime = System.currentTimeMillis();
    mergeSort(mergeArr, 0, mergeArr.length - 1, new int[mergeArr.length]);
    endTime = System.currentTimeMillis();
    printArray("归并排序:", mergeArr, endTime - startTime);

    // 希尔排序
    int[] shellArr = INTS.clone();
    startTime = System.currentTimeMillis();
    mergeSort(shellArr, 0, shellArr.length - 1, new int[shellArr.length]);
    endTime = System.currentTimeMillis();
    printArray("希尔排序:", shellArr, endTime - startTime);

    // 堆排序
    int[] heapArr = INTS.clone();
    startTime = System.currentTimeMillis();
    heapSort(heapArr);
    endTime = System.currentTimeMillis();
    printArray("堆排序:", heapArr, endTime - startTime);
  }

  /** 冒泡排序 */
  private static void bubbleSort(int[] clone) {
    for (int i = 0, j = clone.length; i < j; i++) {
      for (int k = 0, l = j - 1 - i; k < l; k++) {
        if (clone[k] > clone[k + 1]) {
          clone[k] = clone[k] ^ clone[k + 1];
          clone[k + 1] = clone[k] ^ clone[k + 1];
          clone[k] = clone[k] ^ clone[k + 1];
        }
      }
    }
  }

  /** 选择排序 */
  private static void selectionSort(int[] clone) {
    for (int i = 0, j = clone.length; i < j; i++) {
      int minIndex = i;
      for (int k = i; k < j; k++) {
        if (clone[k] < clone[minIndex]) {
          minIndex = k;
        }
      }
      if (minIndex != i) {
        clone[i] = clone[i] + clone[minIndex];
        clone[minIndex] = clone[i] - clone[minIndex];
        clone[i] = clone[i] - clone[minIndex];
      }
    }
  }

  /** 插入排序 */
  private static void insertSort(int[] clone) {
    for (int i = 1, j = clone.length; i < j; i++) {
      int k = i;
      int temp = clone[k];
      while (k > 0 && clone[k - 1] > temp) {
        clone[k] = clone[k - 1];
        k--;
      }
      clone[k] = temp;
    }
  }

  /**
   * 快速排序
   *
   * @param clone 数组
   * @param leftIndex 左边角标 初始0
   * @param rightIndex 右边角标 初始length-1
   */
  private static void quickSort(int[] clone, int leftIndex, int rightIndex) {
    // temp-基准位
    int i, j, temp;
    if (leftIndex > rightIndex) {
      return;
    }
    i = leftIndex;
    j = rightIndex;
    temp = clone[leftIndex];
    while (i < j) {
      // 先右边，往左递减,找一个小于基准位的数
      // 当右边的角标位置所在的数>基准位的数时，继续从右往左找（同时 j 索引-1)
      // 找到就跳出 while循环
      while (temp <= clone[j] && i < j) {
        j--;
      }
      // 再左边，往右递增
      // 如上
      while (temp >= clone[i] && i < j) {
        i++;
      }
      // 满足条件则交换
      if (i < j) {
        clone[i] = clone[i] + clone[j];
        clone[j] = clone[i] - clone[j];
        clone[i] = clone[i] - clone[j];
      }
    }
    // i=j 左右在同一位置
    // 最后将基准为与i和j相等位置的数字交换
    clone[leftIndex] = clone[i];
    clone[i] = temp;
    // 左半数组<(i或j所在索引的数)<右半数组
    // 也就是说(i或j所在索引的数)已经确定排序位置，就不用再排序了，
    // 相同的方法分别处理左右数组
    // 递归调用左半数组
    quickSort(clone, leftIndex, j - 1);
    // 递归调用右半数组
    quickSort(clone, j + 1, rightIndex);
  }

  /** 计数排序 */
  private static int[] countSort(int[] clone) {
    int max = clone[0];
    int min = clone[0];
    for (int i = 1, j = clone.length; i < j; i++) {
      if (clone[i] > max) {
        max = clone[i];
      }
      if (clone[i] < min) {
        min = clone[i];
      }
    }
    int dValue = max - min;
    int[] countArray = new int[dValue + 1];
    for (int value : clone) {
      countArray[value - min]++;
    }
    // 统计数组做变形，后边的元素等于前面的元素之和
    for (int i = 1; i < countArray.length; i++) {
      countArray[i] += countArray[i - 1];
    }
    // 倒序遍历原始数组，从统计数组中找到正确的位置，输出到结果数组
    int[] sortedArray = new int[clone.length];
    for (int i = clone.length - 1; i >= 0; i--) {
      // 给sortedArray的当前位置赋值
      sortedArray[countArray[clone[i] - min] - 1] = clone[i];
      // 给countArray的位置的值--
      countArray[clone[i] - min]--;
    }
    return sortedArray;
  }

  /** 基数排序 */
  private static void radixSort(int[] clone) {
    int maxLength = 0;
    // 最大位数
    for (int i : clone) {
      int length = String.valueOf(i).length();
      maxLength = Math.max(length, maxLength);
    }
    List> list =
        new ArrayList>() {
          {
            // 0-9
            for (int i = 0; i < 10; i++) {
              add(new ArrayList<>());
            }
          }
        };
    for (int i = 0, temp = 1; i < maxLength; temp *= 10, i++) {
      for (int value : clone) {
        list.get((value / temp) % 10).add(value);
      }
      for (int j = 0, k = 0, l = list.size(); j < l; j++) {
        while (!list.get(j).isEmpty()) {
          clone[k] = list.get(j).get(0);
          list.get(j).remove(0);
          k++;
        }
      }
    }
  }

  /** 桶排序 */
  private static int[] bucketSort(int[] clone) {
    int maxLength = 0, minLength = 0;
    // 最大位数and最小位数
    for (int i = 0, j = clone.length; i < j; i++) {
      int length = String.valueOf(clone[i]).length();
      maxLength = Math.max(length, maxLength);
      if (i == 0) {
        minLength = length;
      } else {
        minLength = Math.min(length, minLength);
      }
    }
    // 新建一个桶的集合
    List> buckets = new ArrayList<>();
    for (int i = 0, j = maxLength - minLength + 1; i < j; i++) {
      // 新建一个桶，并将其添加到桶的集合中去。
      buckets.add(new LinkedList<>());
    }
    for (int i : clone) {
      int index = String.valueOf(i).length() - 1;
      LinkedList integers = buckets.get(index);
      integers.add(i);
    }
    int[] finalArr = new int[clone.length];
    int tempIndex = 0;
    // 计数排序
    for (LinkedList integers : buckets) {
      if (integers.size() > 0) {
        int max = integers.get(0);
        int min = integers.get(0);
        for (Integer i : integers) {
          if (i > max) {
            max = i;
          }
          if (i < min) {
            min = i;
          }
        }
        int dValue = max - min;
        int[] countArray = new int[dValue + 1];
        for (int value : integers) {
          countArray[value - min]++;
        }
        // 统计数组做变形，后边的元素等于前面的元素之和
        for (int i = 1; i < countArray.length; i++) {
          countArray[i] += countArray[i - 1];
        }
        // 倒序遍历原始数组，从统计数组中找到正确的位置，输出到结果数组
        Integer[] sortedArray = new Integer[integers.size()];
        for (int i = integers.size() - 1; i >= 0; i--) {
          // 给sortedArray的当前位置赋值
          sortedArray[countArray[integers.get(i) - min] - 1] = integers.get(i);
          // 给countArray的位置的值--
          countArray[integers.get(i) - min]--;
        }
        for (Integer integer : sortedArray) {
          finalArr[tempIndex++] = integer;
        }
      }
    }
    return finalArr;
  }

  /**
   * 归并排序
   *
   * @param ints 数组
   * @param start 左角标
   * @param end 右角标
   * @param tempArr 辅助数组
   */
  private static void mergeSort(int[] ints, int start, int end, int[] tempArr) {
    // 当子序列中只有一个元素时结束递归
    if (start < end) {
      // 划分子序列
      int mid = (start + end) / 2;
      // 对左侧子序列进行递归排序
      mergeSort(ints, start, mid, tempArr);
      // 对右侧子序列进行递归排序
      mergeSort(ints, mid + 1, end, tempArr);
      // 合并
      merge(ints, start, mid, end, tempArr);
    }
  }
  /** 两路归并算法，两个排好序的子序列合并为一个子序列 */
  private static void merge(int[] ints, int left, int mid, int right, int[] tempArr) {
    int p1 = left, p2 = mid + 1, k = left;
    while (p1 <= mid && p2 <= right) {
      if (ints[p1] <= ints[p2]) {
        tempArr[k++] = ints[p1++];
      } else {
        tempArr[k++] = ints[p2++];
      }
    }
    while (p1 <= mid) {
      // 如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
      tempArr[k++] = ints[p1++];
    }
    while (p2 <= right) {
      tempArr[k++] = ints[p2++];
    }
    // 复制回原素组
    if (right + 1 - left >= 0) {
      System.arraycopy(tempArr, left, ints, left, right + 1 - left);
    }
  }

  /** 希尔排序 */
  private static void shellSort(int[] clone) {
    // 步长逐渐减小
    for (int gap = clone.length / 2; gap > 0; gap /= 2) {
      // 在同一步长内
      for (int i = gap; i < clone.length; i++) {
        // 同一步长内排序方式是插入排序
        int temp = clone[i], j;
        // j-gap代表有序数组中最大数的下标，j-pag表示有序数组的前一个元素，减pag是减去偏移量就是步长
        for (j = i; j >= gap && temp < clone[j - gap]; j -= gap) {
          // 原有序数组最大的后移一位
          clone[j] = clone[j - gap];
        }
        // 找到了合适的位置插入
        clone[j] = temp;
      }
    }
  }

  /** 堆排序 */
  private static void heapSort(int[] clone) {
    // 创建堆
    for (int i = (clone.length - 1) / 2; i >= 0; i--) {
      // 从第一个非叶子结点从下至上，从右至左调整结构
      adjustHeap(clone, i, clone.length);
    }

    // 调整堆结构,交换堆顶元素与末尾元素
    for (int i = clone.length - 1; i > 0; i--) {
      // 将堆顶元素与末尾元素进行交换
      clone[i] = clone[i]+clone[0];
      clone[0] = clone[i]-clone[0];
      clone[i] = clone[i]-clone[0];
      // 重新对堆进行调整
      adjustHeap(clone, 0, i);
    }
  }

  /**
   * 调整堆
   *
   * @param arr 待排序列
   * @param parent 父节点
   * @param length 待排序列尾元素索引
   */
  private static void adjustHeap(int[] arr, int parent, int length) {
    // 将temp作为父节点
    int temp = arr[parent];
    // 左孩子
    int lChild = 2 * parent + 1;

    while (lChild < length) {
      // 右孩子
      int rChild = lChild + 1;
      // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
      if (rChild < length && arr[lChild] < arr[rChild]) {
        lChild++;
      }
      // 如果父结点的值已经大于孩子结点的值，则直接结束
      if (temp >= arr[lChild]) {
        break;
      }
      // 把孩子结点的值赋给父结点
      arr[parent] = arr[lChild];
      // 选取孩子结点的左孩子结点,继续向下筛选
      parent = lChild;
      lChild = 2 * lChild + 1;
    }
    arr[parent] = temp;
  }

  private static void printArray(String name, int[] ints, long time) {
    for (int anInt : ints) {
      System.out.print("_" + anInt + "_");
    }
    System.out.println("\t");
    System.out.println(name + "耗时:" + time);
    System.out.println();
  }
}

你可能感兴趣的:(排序笔记)

  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • Day17笔记-高阶函数 ~在杰难逃~ Python笔记python开发语言pycharm数据分析
    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • 读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
    为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
  • 基于Python给出的PDF文档转Markdown文档的方法 程序媛了了 pythonpdf开发语言
    注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • C语言代码练习（第十九天） 小小框架 C语言C语言重点练习c语言
    今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
  • Armv8.3 体系结构扩展--原文版 代码改变世界ctw ARM-TEE-Androidarmv8嵌入式arm架构安全架构芯片TrustzoneSecureboot
    快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • 阅读《认知觉醒》读书笔记 就看看书
    本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
  • 阅读笔记：阅读方法中的逻辑和转念 施吉涛
    聊聊一些阅读的方法论吧，别人家的读书方法刚开始想写，然后就不知道写什么了，因为作者写的非常的“精致”我有一种乡巴佬进城的感觉，看到精美的摆盘，精致的食材不知道该如何下口也就是《阅读的方法》，我们姑且来试一下强劲的大脑篇，第一节：逻辑通俗的来讲，也就是表达的排列和顺序，再进一步就是因果关系和关联实际上书已经看了大概一遍，但直到打算写一下笔记的时候，才发现作者讲的推理更多的是阅读的对象中呈现出的逻辑也
  • 《转介绍方法论》学习笔记 小可乐的妈妈
    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • 解决Obsidian写笔记中的＜img＞标签无法显示图片的问题 全能全知者 笔记
    Obsidian中写md笔记如果使用标签会显示不出图案，后来才知道因为Obsidian的问题导致只能用绝对路径定位。所以我本人写了一个py插件，将md笔记里的img标签批量替换成Obsidian能够读取的形式。安装FixObsImgDpy:pipinstallFixObsImgDpy安装完成后在需要修复的md文件的父目录下运行命令:FixObsImgDpy就会自动修复父目录以下的全部md文件 仓库
  • 2021年周总结 03 Ruby之家
    这周的生活过得也是比较快，因为暂时住的离公司有点距离，所以通勤时间相对较长一点，而在地铁上的一个半小时如何充分利用起来，则是我最近一直在思考的问题，2021年想让自己的生活都运行在计划中。(有时候自己想干一件事情就总是给自己找很多借口，想着以后怎么怎么样？然而哪有那么多的以后，能够方便当下的工作生活就立马执行就OK，这仅仅只是我此时想到背的很重的老人机笔记本电脑，也算是陪伴我快8年的—当时买的时候
  • rose中原焦点团队网络初级27期、中级27期分享第201天20211019 rosewshx
    今天出差回来上班，很多事情又都拥挤到了一起，列表排序逐一落实吧。排出来心里就不慌乱了，稳得住事情去逐一解决。调整烦躁慌乱的心态，平稳住按部就班就好，让觉察时时在。
  • [实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
  • Js函数返回值 _wy_ jsreturn
    一、返回控制与函数结果，语法为：return 表达式;作用: 结束函数执行，返回调用函数，而且把表达式的值作为函数的结果 二、返回控制语法为：return;作用: 结束函数执行，返回调用函数，而且把undefined作为函数的结果 在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性
  • MySQL 的 char 与 varchar bylijinnan mysql
    今天发现，create table 时，MySQL 4.1有时会把 char 自动转换成 varchar 测试举例： CREATE TABLE `varcharLessThan4` ( `lastName` varchar(3) ) ; mysql> desc varcharLessThan4; +----------+---------+------+-
  • Quartz——TriggerListener和JobListener eksliang TriggerListenerJobListenerquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208624 一.概述 listener是一个监听器对象，用于监听scheduler中发生的事件，然后执行相应的操作；你可能已经猜到了，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。   二.JobListener监听器  j
  • oracle层次查询 18289753290 oracle；层次查询；树查询
    .oracle层次查询(connect  by) oracle的emp表中包含了一列mgr指出谁是雇员的经理，由于经理也是雇员，所以经理的信息也存储在emp表中。这样emp表就是一个自引用表，表中的mgr列是一个自引用列，它指向emp表中的empno列，mgr表示一个员工的管理者， select   empno,mgr,ename,sal  from e
  • 通过反射把map中的属性赋值到实体类bean对象中 酷的飞上天空 javaee泛型类型转换
    使用过struts2后感觉最方便的就是这个框架能自动把表单的参数赋值到action里面的对象中 但现在主要使用Spring框架的MVC，虽然也有@ModelAttribute可以使用但是明显感觉不方便。 好吧，那就自己再造一个轮子吧。 原理都知道，就是利用反射进行字段的赋值，下面贴代码 主要类如下：   import java.lang.reflect.Field; imp
  • SAP HANA数据存储：传统硬盘的瓶颈问题 蓝儿唯美 HANA
    SAPHANA平台有各种各样的应用场景，这也意味着客户的实施方法有许多种选择，关键是如何挑选最适合他们需求的实施方案。 在 《Implementing SAP HANA》这本书中，介绍了SAP平台在现实场景中的运作原理，并给出了实施建议和成功案例供参考。本系列文章节选自《Implementing SAP HANA》，介绍了行存储和列存储的各自特点，以及SAP HANA的数据存储方式如何提升空间压
  • Java Socket 多线程实现文件传输 随便小屋 javasocket
            高级操作系统作业，让用Socket实现文件传输，有些代码也是在网上找的，写的不好，如果大家能用就用上。 客户端类：   package edu.logic.client; import java.io.BufferedInputStream; import java.io.Buffered
  • java初学者路径 aijuans java
    学习Java有没有什么捷径?要想学好Java，首先要知道Java的大致分类。自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE
  • APP推广 aoyouzi APP推广
    一，免费篇 1，APP推荐类网站自主推荐 最美应用、酷安网、DEMO8、木蚂蚁发现频道等,如果产品独特新颖，还能获取最美应用的评测推荐。PS：推荐简单。只要产品有趣好玩，用户会自主分享传播。例如足迹APP在最美应用推荐一次，几天用户暴增将服务器击垮。 2，各大应用商店首发合作 老实盯着排期，多给应用市场官方负责人献殷勤。 3，论坛贴吧推广 百度知道，百度贴吧，猫扑论坛，天涯社区，豆瓣（
  • JSP转发与重定向 百合不是茶 jspservletJava Webjsp转发
      在servlet和jsp中我们经常需要请求,这时就需要用到转发和重定向;   转发包括;forward和include     例子;forwrad转发;  将请求装法给reg.html页面   关键代码;    req.getRequestDispatcher("reg.html
  • web.xml之jsp-config bijian1013 javaweb.xmlservletjsp-config
    1.作用：主要用于设定JSP页面的相关配置。 2.常见定义： <jsp-config> <taglib> <taglib-uri>URI(定义TLD文件的URI,JSP页面的tablib命令可以经由此URI获取到TLD文件)</tablib-uri> <taglib-location> TLD文件所在的位置
  • JSF2.2 ViewScoped Using CDI sunjing CDIJSF 2.2ViewScoped
    JSF 2.0 introduced annotation @ViewScoped; A bean annotated with this scope maintained its state as long as the user stays on the same view(reloads or navigation - no intervening views). One problem w
  • 【分布式数据一致性二】Zookeeper数据读写一致性 bit1129 zookeeper
    很多文档说Zookeeper是强一致性保证，事实不然。关于一致性模型请参考http://bit1129.iteye.com/blog/2155336    Zookeeper的数据同步协议 Zookeeper采用称为Quorum Based Protocol的数据同步协议。假如Zookeeper集群有N台Zookeeper服务器(N通常取奇数，3台能够满足数据可靠性同时
  • Java开发笔记 白糖_ java开发
    1、Map<key,value>的remove方法只能识别相同类型的key值   Map<Integer,String> map = new HashMap<Integer,String>(); map.put(1,"a"); map.put(2,"b"); map.put(3,"c"
  • 图片黑色阴影 bozch 图片
     .event{ padding:0;    width:460px;    min-width: 460px;    border:0px solid #e4e4e4;    height: 350px;    min-heig
  • 编程之美-饮料供货-动态规划 bylijinnan 动态规划
    import java.util.Arrays; import java.util.Random; public class BeverageSupply { /** * 编程之美 饮料供货 * 设Opt（V’，i）表示从i到n-1种饮料中，总容量为V’的方案中，满意度之和的最大值。 * 那么递归式就应该是：Opt（V’，i）=max{ k * Hi+Op
  • ajax大参数（大数据）提交性能分析 chenbowen00 WebAjax框架浏览器prototype
    近期在项目中发现如下一个问题 项目中有个提交现场事件的功能，该功能主要是在web客户端保存现场数据（主要有截屏，终端日志等信息）然后提交到服务器上方便我们分析定位问题。客户在使用该功能的过程中反应点击提交后反应很慢，大概要等10到20秒的时间浏览器才能操作，期间页面不响应事件。 根据客户描述分析了下的代码流程，很简单，主要通过OCX控件截屏，在将前端的日志等文件使用OCX控件打包，在将之转换为
  • [宇宙与天文]在太空采矿,在太空建造 comsci
         我们在太空进行工业活动...但是不太可能把太空工业产品又运回到地面上进行加工,而一般是在哪里开采,就在哪里加工,太空的微重力环境,可能会使我们的工业产品的制造尺度非常巨大....      地球上制造的最大工业机器是超级油轮和航空母舰,再大些就会遇到困难了,但是在空间船坞中,制造的最大工业机器,可能就没
  • ORACLE中CONSTRAINT的四对属性 daizj oracleCONSTRAINT
    ORACLE中CONSTRAINT的四对属性 summary:在data migrate时,某些表的约束总是困扰着我们,让我们的migratet举步维艰,如何利用约束本身的属性来处理这些问题呢?本文详细介绍了约束的四对属性: Deferrable/not deferrable, Deferred/immediate, enalbe/disable, validate/novalidate,以及如
  • Gradle入门教程 dengkane gradle
    一、寻找gradle的历程 一开始的时候，我们只有一个工程，所有要用到的jar包都放到工程目录下面，时间长了，工程越来越大，使用到的jar包也越来越多，难以理解jar之间的依赖关系。再后来我们把旧的工程拆分到不同的工程里，靠ide来管理工程之间的依赖关系，各工程下的jar包依赖是杂乱的。一段时间后，我们发现用ide来管理项程很不方便，比如不方便脱离ide自动构建，于是我们写自己的ant脚本。再后
  • C语言简单循环示例 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i; int count = 0; int sum = 0; float avg; for (i=1; i<=100; i++) { if (i%2==0) { count++; sum += i; } } avg
  • presentModalViewController 的动画效果 dcj3sjt126com controller
    系统自带(四种效果)： presentModalViewController模态的动画效果设置：     [cpp]  view plain copy   UIViewController *detailViewController = [[UIViewController al
  • java 二分查找 shuizhaosi888 二分查找java二分查找
    需求：在排好顺序的一串数字中，找到数字T   一般解法：从左到右扫描数据，其运行花费线性时间O(N)。然而这个算法并没有用到该表已经排序的事实。 /** * * @param array * 顺序数组 * @param t * 要查找对象 * @return */ public stati
  • Spring Security（07）——缓存UserDetails 234390216 ehcache缓存Spring Security
           Spring Security提供了一个实现了可以缓存UserDetails的UserDetailsService实现类，CachingUserDetailsService。该类的构造接收一个用于真正加载UserDetails的UserDetailsService实现类。当需要加载UserDetails时，其首先会从缓存中获取，如果缓存中没
  • Dozer 深层次复制 jayluns VOmavenpo
    最近在做项目上遇到了一些小问题，因为架构在做设计的时候web前段展示用到了vo层，而在后台进行与数据库层操作的时候用到的是Po层。这样在业务层返回vo到控制层，每一次都需要从po-->转化到vo层，用到BeanUtils.copyProperties(source, target)只能复制简单的属性，因为实体类都配置了hibernate那些关联关系，所以它满足不了现在的需求，但后发现还有个很
  • CSS规范整理（摘自懒人图库） a409435341 htmlUIcss浏览器
       刚没事闲着在网上瞎逛，找了一篇CSS规范整理，粗略看了一下后还蛮有一定的道理，并自问是否有这样的规范，这也是初入前端开发的人一个很好的规范吧。 一、文件规范 1、文件均归档至约定的目录中。 具体要求通过豆瓣的CSS规范进行讲解： 所有的CSS分为两大类：通用类和业务类。通用的CSS文件，放在如下目录中： 基本样式库 /css/core
  • C++动态链接库创建与使用 你不认识的休道人 C++dll
    一、创建动态链接库 1.新建工程test中选择”MFC [dll]”dll类型选择第二项"Regular DLL With MFC shared linked"，完成 2.在test.h中添加 extern “C” 返回类型 _declspec(dllexport)函数名(参数列表); 3.在test.cpp中最后写 extern “C” 返回类型 _decls
  • Android代码混淆之ProGuard rensanning ProGuard
    Android应用的Java代码，通过反编译apk文件（dex2jar、apktool）很容易得到源代码，所以在release版本的apk中一定要混淆一下一些关键的Java源码。 ProGuard是一个开源的Java代码混淆器（obfuscation）。ADT r8开始它被默认集成到了Android SDK中。 官网： http://proguard.sourceforge.net/
  • 程序员在编程中遇到的奇葩弱智问题 tomcat_oracle jquery编程ide
    　　现在收集一下：       　　排名不分先后，按照发言顺序来的。   1、Jquery插件一个通用函数一直报错，尤其是很明显是存在的函数，很有可能就是你没有引入jquery。。。或者版本不对 2、调试半天没变化：不在同一个文件中调试。这个很可怕，我们很多时候会备份好几个项目，改完发现改错了。有个群友说的好：   在汤匙
  • 解决maven-dependency-plugin (goals "copy-dependencies","unpack") is not supported xp9802 dependency
    解决办法：在plugins之前添加如下pluginManagement，二者前后顺序如下：   [html]  view plain copy   <build>           <pluginManagement
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他