1.十大经典排序算法

排序算法说明

（1）排序的定义：对一序列对象根据某个关键字进行排序；

输入：n个数：a1,a2,a3,…,an 
输出：n个数的排列:a1’,a2’,a3’,…,an’，使得a1’<=a2’<=a3’<=…<=an’。

再讲的形象点就是排排坐，调座位，高的站在后面，矮的站在前面咯。

（2）对于评述算法优劣术语的说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；

内排序：所有排序操作都在内存中完成； 
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；

时间复杂度: 一个算法执行所耗费的时间。 
空间复杂度: 运行完一个程序所需内存的大小。

关于时间空间复杂度的更多了解请戳这里，或是看书程杰大大编写的《大话数据结构》还是很赞的，通俗易懂。

（3）排序算法图片总结：

排序对比：

图片名词解释：

n: 数据规模 
k:“桶”的个数 
In-place: 占用常数内存，不占用额外内存 
Out-place: 占用额外内存

排序分类：

(1)冒泡排序（Bubble Sort）

①算法描述

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

②算法描述和实现

  • <1>.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • <2>.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • <3>.针对所有的元素重复以上的步骤，除了最后一个；
  • <4>.重复步骤1~3，直到排序完成。

③Java代码实现：　　

public static void bubbleSort(int[] array) {  long start = System.nanoTime();  int len = array.length;  for (int i = 0; i < len - 1; i++) {  for (int j = 0; j < len - i - 1; j++) {  if (array[j] > array[j + 1]) {  int tmp = array[j];  array[j] = array[j + 1];  array[j + 1] = tmp;  }  }  }  long end = System.nanoTime();  System.out.println((end - start)/1000.0 + "ms");
}

改进冒泡排序：

设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

public static void bubbleSort2(int[] array) {  long start = System.nanoTime();  int len = array.length;  int i = len - 1;  while (i > 0) {  int pos = 0;  for (int j = 0; j < i; j++) {  if (array[j] > array[j + 1]) {  pos = j;  int tmp = array[j];  array[j] = array[j + 1];  array[j + 1] = tmp;  }  }  i = pos;  }  long end = System.nanoTime();  System.out.println((end - start)/1000.0 + "ms");
}

④冒泡排序动图演示:

⑤算法分析

时间复杂度：

  • 最佳情况：T(n) = O(n) 当输入的数据已经是正序时
  • 最差情况：T(n) = O(n^2) 当输入的数据是反序时
  • 平均情况：T(n) = O(n^2)

空间复杂度：

  • 就空间复杂度而言，可以看到在每次循环中，所需要的额外空间就是在进行数值交换时候的一个额外空间，所以空间复杂度为一个常量O(1)

(2)选择排序（Selection Sort）

表现最稳定的排序算法之一(这个稳定不是指算法层面上的稳定哈，相信聪明的你能明白我说的意思2333)，因为无论什么数据进去都是O(n²)的时间复杂度…..所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

①算法简介

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

②算法描述和实现

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

  • <1>.初始状态：无序区为R[1..n]，有序区为空；
  • <2>.第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
  • <3>.n-1趟结束，数组有序化了。

③Java代码实现:

public static void selectSort(int[] array) {  long start = System.nanoTime();  int len = array.length;  int minIndex = 0;  for(int i = 0; i < len - 1 ; i++) {  minIndex = i;  for(int j = i + 1; j < len; j++) {  if(array[j] < array[minIndex]) {  minIndex = j;  }  }  int tmp = array[minIndex];  array[minIndex] = array[i];  array[i] = tmp;  }  long end = System.nanoTime();  System.out.println((end - start)/1000.0 + "ms");
}

④选择排序动图演示：

⑤算法分析

时间复杂度：

  • 最佳情况：T(n) = O(n^2)
  • 最差情况：T(n) = O(n^2)
  • 平均情况：T(n) = O(n^2)

空间复杂度：

  • 同冒泡排序一样，占用常数的额外空间，所以空间复杂度为O(1)

(3)插入排序（Insertion Sort）

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。

①算法简介

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

②算法描述和实现

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

  • <1>.从第一个元素开始，该元素可以认为已经被排序；
  • <2>.取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • <3>.如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • <4>.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • <5>.将新元素插入到该位置后；
  • <6>.重复步骤2~5。

③Java代码实现:

public static void insertSort(int[] array) {  long start = System.nanoTime();  int len = array.length;  for (int i = 1; i < len; i++) {  for (int j = i; j > 0 && array[j - 1] > array[j]; j--) {  int tmp = array[j - 1];  array[j - 1] = array[j];  array[j] = tmp;  }  }  long end = System.nanoTime();  System.out.println((end - start) / 1000.0 + "ms");
}

改进插入排序： 查找插入位置时使用二分查找的方式。相比与上面简单插入排序，他针对每一批已排好序的序列，采用了二分查找的方式提高定位效率。

public static void insertSort2(int[] array) {  long start = System.nanoTime();  int len = array.length;  for (int i = 1; i < len; i++) {  int current = array[i];  int st = 0;  int en = i - 1;  while (st <= en) {  int mid = (st + en) >> 1;  if (array[mid] < array[i]) {  st = mid + 1;  } else {  en = mid - 1;  }  }  for (int j = i - 1; j >= st; j--) {  array[j + 1] = array[j];  }  array[st] = current;  }  long end = System.nanoTime();  System.out.println((end - start) / 1000.0 + "ms");
}

④插入排序动图演示:

⑤算法分析

  • 最佳情况：输入数组按升序排列。T(n) = O(n)
  • 最坏情况：输入数组按降序排列。T(n) = O(n^2)
  • 平均情况：T(n) = O(n^2)

(4)希尔排序（Shell Sort）

1959年Shell发明； 
第一个突破O(n^2)的排序算法；是简单插入排序的改进版；它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序

①算法简介

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版》的合著者Robert Sedgewick提出的。

②算法描述和实现

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

  • <1>. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  • <2>.按增量序列个数k，对序列进行k 趟排序；
  • <3>.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

③Java代码实现：

public static void shellSort(int[] array) {  long start = System.nanoTime();  int len = array.length;  int gap = len/2;  //while(gap < len / 3) gap = 3 * gap + 1;   //目前比较高效的gap  while(gap >= 1){  for(int i = gap; i < len; i++) {  for(int j = i; j - gap > 0 && array[j - gap] > array[j]; j -= gap) {  int tmp = array[j - gap];  array[j - gap] = array[j];  array[j] = tmp;  }  }  gap /= 2;  //gap /= 3;
    }  long end = System.nanoTime();  System.out.println((end - start) / 1000.0 + "ms");
}

④希尔排序图示（图片来源网络）：

⑤算法分析

  • 最佳情况：T(n) = O(nlog2 n)
  • 最坏情况：T(n) = O(nlog2 n)
  • 平均情况：T(n) =O(nlog n)

(5)归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

①算法简介

　归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

②算法描述和实现

具体算法描述如下：

  • <1>.把长度为n的输入序列分成两个长度为n/2的子序列；
  • <2>.对这两个子序列分别采用归并排序；
  • <3>.将两个排序好的子序列合并成一个最终的排序序列。

③Java代码实现:

public static void mergeSort(int[] array, int start, int end) {  int len = end - start + 1;  if (len < 2) {  return;  }  int middle = end +  (start - end) / 2; //防止溢出
    mergeSort(array, start, middle);  mergeSort(array, middle + 1, end);  merge(array, start, end);
}  private static void merge(int[] array, int start, int end) {  int[] tmp = new int[end - start + 1];  int mid = (start + end) / 2;  int left = start;  int right = mid + 1;  int point = 0;  while (left <= mid && right <= end) {  if (array[left] < array[right]) {  tmp[point++] = array[left++];  } else {  tmp[point++] = array[right++];  }  }  while (left <= mid) {  tmp[point++] = array[left++];  }  while (right <= end) {  tmp[point++] = array[right++];  }  for (int i = 0; i < tmp.length; i++) {  array[i + start] = tmp[i];  }
}

④归并排序动图演示:

⑤算法分析

  • 最佳情况：T(n) = O(n)
  • 最差情况：T(n) = O(nlogn)
  • 平均情况：T(n) = O(nlogn)

(6)快速排序（Quick Sort）

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高! 它是处理大数据最快的排序算法之一了。

①算法简介

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

②算法描述和实现

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

  • <1>.从数列中挑出一个元素，称为 “基准”（pivot）；
  • <2>.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • <3>.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

③Java代码实现：

public static void quickSort(int[] array, int st, int en) {  int start = st;  int end = en;  if (start >= en)  return;  int index = partition(array, start, end);  quickSort(array, st, index - 1);  quickSort(array, index + 1, end);  }  private static int partition(int[] array, int st, int en) {  int reserve = array[st];  int start = st;  int end = en;  if (start >= end)  return start;  while (start < end) {  while (start < end && reserve <= array[end]) {  end--;  }  if (start < end) {  array[start++] = array[end];  }  while (start < end && array[start] <= reserve) {  start++;  }  if (start < end) {  array[end--] = array[start];  }  }  array[start] = reserve;  return start;  }

④快速排序动图演示：

快速排序算法优化——三向切分快速排序

在上面的快速排序中，当有很多重复元素存在的时候，会大大的增加无谓的切分耗时：比如当前切分块中若全部是相同的元素，则在当前块中的递归切分就是无意义也没有必要的。所以在三向切分中，用了lt和gt两个“指针”来分隔小于当前“基准元素”和大于当前“基准元素”的值。

public static void quickSort3ways(int[] array, int low, int high) {  if (low >= high)  return;  int lt = low;  int i = low + 1;  int gt = high + 1;  while (i < gt) {  if (array[i] < array[lt]) {  swap(array, i++, lt++);  } else if (array[i] > array[lt]) {  swap(array, i, --gt);  } else {  i++;  }  }  quickSort3ways(array, low, lt);  quickSort3ways(array, gt, high);
}

上面这幅图是三向切分的一个例子，为字母进行排序。每次迭代都不会包含和当前基准重复的元素。可以在下图中看到，三向的效率还是有优势的：

⑤算法分析

递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n)  ；

最优情况下时间复杂度

快速排序最优的情况就是每一次取到的元素都刚好平分整个数组(很显然我上面的不是)；
        此时的时间复杂度公式则为：T[n] = 2T[n/2] + f(n)；T[n/2]为平分后的子数组的时间复杂度，f[n] 为平分这个数组时所花的时间；
下面来推算下，在最优的情况下快速排序时间复杂度的计算(用迭代法)：
                         T[n] =  2T[n/2] + n                                                                     ----------------第一次递归

令：n = n/2        =  2 { 2 T[n/4] + (n/2) }  + n                                               ----------------第二次递归

=  2^2 T[ n/ (2^2) ] + 2n

令：n = n/(2^2)   =  2^2  {  2 T[n/ (2^3) ]  + n/(2^2)}  +  2n                         ----------------第三次递归

=  2^3 T[  n/ (2^3) ]  + 3n

......................................................................................

令：n = n/(  2^(m-1) )    =  2^m T[1]  + mn                                                  ----------------第m次递归(m次后结束)

当最后平分的不能再平分时，也就是说把公式一直往下跌倒，到最后得到T[1]时，说明这个公式已经迭代完了（T[1]是常量了）。

得到：T[n/ (2^m) ]  =  T[1]    ===>>   n = 2^m   ====>> m = logn；

T[n] = 2^m T[1] + mn ；其中m = logn;

T[n] = 2^(logn) T[1] + nlogn  =  n T[1] + nlogn  =  n + nlogn  ；其中n为元素个数

又因为当n >=  2时：nlogn  >=  n  (也就是logn > 1)，所以取后面的 nlogn；

综上所述：快速排序最优的情况下时间复杂度为：O( nlogn )

最差情况下时间复杂度

最差的情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)

这种情况时间复杂度就好计算了，就是冒泡排序的时间复杂度：T[n] = n * (n-1) = n^2 + n;

综上所述：快速排序最差的情况下时间复杂度为：O( n^2 )

平均时间复杂度

(7)堆排序（Heap Sort）

堆排序可以说是一种利用堆的概念来排序的选择排序。

①算法简介

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

②算法描述和实现

具体算法描述如下：

③Java代码实现：

public static void heapSort(int[] array) {  buildHeap(array);  int n = array.length;  int i = 0;  // 取出该最大堆的根节点，同时，取最末尾的叶子节点来作为根节点，从此根节点开始调整堆，使其满足最大堆的特性  // 直到堆的大小由n个元素降到2个  for (i = n - 1; i >= 1; i--) {  swap(array, 0, i);  heapify(array, 0, i);  for (int j = 0; j < array.length; j++) {  System.out.print(array[j]);  System.out.print(",");  }  System.out.println();  }
}  // 构建堆
public static void buildHeap(int[] array) {  for (int i = array.length / 2 - 1; i >= 0; i--) {  heapify(array, i, array.length);  }
}  // 调整堆
public static void heapify(int[] data, int parentNode, int heapSize) {  int leftChild = 2 * parentNode + 1;// 左子树的下标  int rightChild = 2 * parentNode + 2;// 右子树的下标（如果存在的话）  int largest = parentNode;  // 寻找3个节点中最大值节点的下标  if (leftChild < heapSize && data[leftChild] > data[parentNode]) {  largest = leftChild;  }  if (rightChild < heapSize && data[rightChild] > data[largest]) {  largest = rightChild;  }  // 如果最大值不是父节点，那么交换，并继续调整堆  if (largest != parentNode) {  swap(data, largest, parentNode);  heapify(data, largest, heapSize);  }
}  // 交换函数
public static void swap(int[] array, int i, int j) {  int temp = 0;  temp = array[i];  array[i] = array[j];  array[j] = temp;
}

④堆排序动图演示：

⑤算法分析

(8)计数排序（Counting Sort）

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 
作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

①算法简介

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

②算法描述和实现

具体算法描述如下：

③Java代码实现：

public static void countSort(int[] array, int downBound, int upperBound) {  int[] countArray = new int[upperBound - downBound + 1];  if (upperBound < downBound)  return;  for (int i = 0; i < array.length; i++) {  countArray[array[i] - downBound]++;  }  int posSum = 0;  for (int i = 0; i < upperBound - downBound + 1; i++) {  posSum += countArray[i];  countArray[i] = posSum;  }  int[] result = new int[array.length];  for (int i = array.length - 1; i >= 0; i--) {  result[countArray[array[i] - downBound] - 1] = array[i];  countArray[array[i] - downBound]--;  }  for (int i = 0; i < array.length; i++) {  array[i] = result[i];  }
}

④动图演示：

⑤算法分析

当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存（如果数据比较分散，则在countArray中其实是有大量0的，占用很多空间）。

  • 最佳情况：T(n) = O(n+k)
  • 最差情况：T(n) = O(n+k)
  • 平均情况：T(n) = O(n+k)

(9)桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

①算法简介

桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排

②算法描述和实现

具体算法描述如下：

  • <1>.设置一个定量的数组当作空桶；
  • <2>.遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • <3>.对每个不是空的桶进行排序；
  • <4>.从不是空的桶里把排好序的数据拼接起来。

③Java代码实现:

public static void bucketSort(int[] arr){  int max = Integer.MIN_VALUE;  int min = Integer.MAX_VALUE;  for(int i = 0; i < arr.length; i++){  max = Math.max(max, arr[i]);  min = Math.min(min, arr[i]);  }  //桶数  int bucketNum = (max - min) / arr.length + 1;  ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);  for(int i = 0; i < bucketNum; i++){  bucketArr.add(new ArrayList<Integer>());  }  //将每个元素放入桶  for(int i = 0; i < arr.length; i++){  int num = (arr[i] - min) / (arr.length);  bucketArr.get(num).add(arr[i]);  }  //对每个桶进行排序  for(int i = 0; i < bucketArr.size(); i++){  Collections.sort(bucketArr.get(i));  }  }

④桶排序图示（图片来源网络）：

关于桶排序更多

⑤算法分析

　桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

  • 最佳情况：T(n) = O(n+k)
  • 最差情况：T(n) = O(n+k)
  • 平均情况：T(n) = O(n2)

(10)基数排序（Radix Sort）

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；

①算法简介

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

②算法描述和实现

具体算法描述如下：

  • <1>.取得数组中的最大数，并取得位数；
  • <2>.arr为原始数组，从最低位开始取每个位组成radix数组；
  • <3>.对radix进行计数排序（利用计数排序适用于小范围数的特点）；

③Java代码实现：

public static void radixSort(int[] array, int maxDigit) {  int len = array.length;  int digitCount = 1;  int digitDev = 1;  int[] tmp = new int[len];  int[] count = new int[10];  while (digitCount <= maxDigit) {  Arrays.fill(count, 0);  Arrays.fill(count, 0);  for (int i = 0; i < len; i++) {  count[(array[i] / digitDev) % 10]++;  }  int sum = 0;  for (int i = 1; i < 10; i++) {  count[i] = count[i] + count[i - 1];  }  for (int i = len - 1; i >= 0; i--) {  tmp[count[(array[i] / digitDev) % 10] - 1] = array[i];  count[(array[i] / digitDev) % 10]--;  }  for (int i = 0; i < len; i++) {  array[i] = tmp[i];  }  digitDev *= 10;  digitCount++;  }
}

④基数排序LSD动图演示：

⑤算法分析

  • 最佳情况：T(n) = O(n * k)
  • 最差情况：T(n) = O(n * k)
  • 平均情况：T(n) = O(n * k)

基数排序有两种方法：

  • MSD 从高位开始进行排序
  • LSD 从低位开始进行排序

基数排序 vs 计数排序 vs 桶排序

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

  1. 基数排序：根据键值的每位数字来分配桶
  2. 计数排序：每个桶只存储单一键值
  3. 桶排序：每个桶存储一定范围的数值

2.冒泡排序，插入排序，希尔排序，归并排序，快速排序哪些是稳定的，哪些不是，为什么？

十大稳定排序中：

  • 稳定：冒泡排序、插入排序、归并排序、计数排序、桶排序、基数排序
  • 不稳定：选择排序、希尔排序、快速排序、堆排序

原因：

在一组排序数组中，a在b的前面，并且a=b，在排序之后若a仍在b前面为稳定，反之不稳定

3.海量日志数据下①怎么在海量数据中找出重复次数最多的一个；②提取出某日访问网站次数最多的那个IP；③提取出某日访问网站次数最多的前n个IP

①怎么在海量数据中找出重复次数最多的一个

算法思想：

        方案1：先做hash，然后求模映射为小文件，求出每个小文件中重复次数最多的一个，并记录重复次数。

然后找出上一步求出的数据中重复次数最多的一个就是所求（如下）。

#include <fstream>
#include <iostream>
#include <ctime>    using namespace std;
#define N 32           //临时文件数    

#define ID(x)  (x>>27)                 //x对应的文件编号
#define VALUE(x) (x&0x07ffffff)        //x在文件中保存的值
#define MAKE_IP(x,y)  ((x<<27)|y)      //由文件编号和值得到IP地址.    

#define MEM_SIZE  128*1024*1024       //需分配内存的大小为 MEM_SIZE*sizeof(unsigned)       char* data_path="D:/test/ip.dat";        //ip数据    //产生n个随机IP地址
void make_data(const int& n)
{    ofstream out(data_path,ios::out|ios::binary);    srand((unsigned)(time(NULL)));    if (out)    {    for (int i=0; i<n; ++i)    {    unsigned val=unsigned(rand());             val = (val<<24)|val;              //产生unsigned类型的随机数
    out.write((char *)&val,sizeof (unsigned));    }    }    out.close();
}    //找到访问次数最大的ip地址
int main()
{    //make_data(100);     //     make_data(100000000);       //产生测试用的IP数据
    fstream arr[N];    for (int i=0; i<N; ++i)                 //创建N个临时文件
    {    char tmp_path[128];     //临时文件路径    sprintf(tmp_path,"D:/test/tmp%d.dat",i);    arr[i].open(tmp_path, ios::trunc|ios::in|ios::out|ios::binary);  //打开第i个文件    if( !arr[i])    {    cout<<"open file"<<i<<"error"<<endl;    }    }    ifstream infile(data_path,ios::in|ios::binary);   //读入测试用的IP数据
    unsigned data;    while(infile.read((char*)(&data), sizeof(data)))    {    unsigned val=VALUE(data);    int key=ID(data);    arr[ID(data)].write((char*)(&val), sizeof(val));           //保存到临时文件件中
    }    for(unsigned i=0; i<N; ++i)    {    arr[i].seekg(0);    }    unsigned max_ip = 0;    //出现次数最多的ip地址    unsigned max_times = 0;     //最大只出现的次数    //分配512M内存,用于统计每个数出现的次数    unsigned *count = new unsigned[MEM_SIZE];      for (unsigned i=0; i<N; ++i)    {    memset(count, 0, sizeof(unsigned)*MEM_SIZE);    //统计每个临时文件件中不同数字出现的次数
        unsigned data;    while(arr[i].read((char*)(&data), sizeof(unsigned)))         {    ++count[data];    }    //找出出现次数最多的IP地址    for(unsigned j=0; j<MEM_SIZE; ++j)                               {    if(max_times<count[j])               {    max_times = count[j];    max_ip = MAKE_IP(i,j);        // 恢复成原ip地址.
            }    }    }    delete[] count;    unsigned char *result=(unsigned char *)(&max_ip);    printf("出现次数最多的IP为:%d.%d.%d.%d,共出现%d次\n",     result[0], result[1], result[2], result[3], max_times);
}

② 网站日志中记录了用户的IP，找出访问次数最多的IP。

算法思想：
       IP地址最多有2^32=4G种取值可能，所以不能完全加载到内存中。

可以考虑分而治之的策略；

map

按照IP地址的hash(IP)%1024值，将海量日志存储到1024个小文件中，每个小文件最多包含4M个IP地址。

reduce
                对于每个小文件，可以构建一个IP作为key，出现次数作为value的hash_map，并记录当前出现次数最多的1个IP地址。

有了1024个小文件中的出现次数最多的IP，我们就可以轻松得到总体上出现次数最多的IP。

4.古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....

具体分析如下：

f(1) = 1(第1个月有一对兔子）
f(2) = 1(第2个月还是一对兔子）
f(3) = 2(原来有一对兔子，第3个开始，每个月生一对兔子）
f(4) = 3(原来有两对兔子，有一对可以生育）
f(5) = 5(原来有3对兔子，第3个月出生的那对兔子也可以生育了，那么现在有两对兔子可以生育）
f(6) = 8(原来有5对兔子，第4个月出生的那对兔子也可以生育了，那么现在有3对兔子可以生育）
..............
由以上可以看出，第n个月兔子的对数为
f(n) = f(n - 1) + f(n - 2);
f(n-1)是上个月的兔子数量，是原来有的。
f(n-2)是可以生育的兔子数，即多出来的数量。第n-2个月开始后的第3个月是第n个月，此时第n-2个月时的兔子都可以生育了。

public class Demo01 {public static void main(String args[]) {for (int i = 1; i <= 20; i++)System.out.println(f(i));}public static int f(int x) {if (x == 1||x == 2)return 1;elsereturn f(x - 1) + f(x - 2);}
}

或

public class Demo01 {public static void main(String args[]) {math mymath = new math();for (int i = 1; i <= 20; i++)System.out.println(mymath.f(i));}
}
class math {public int f(int x) {if (x == 1||x == 2)return 1;elsereturn f(x - 1) + f(x - 2);}
}

5.判断101-200之间有多少个素数，并输出所有素数

程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数

public class Demo02{public static void main(String[] args){for(int i=2;i<=200;i++){boolean flag=true;for(int j=2;j<i;j++){if(i%j==0){flag=false;break;}}if(flag==true){System.out.print(" "+i);}}}
}

6.打印出所有的 水仙花数 ，所谓 水仙花数 是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 水仙花数 ，因为153=1的三次方＋5的三次方＋3的三次方

程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

public class Demo03 {public static void main(String args[]) {math mymath = new math();for (int i = 100; i <= 999; i++)if (mymath.shuixianhua(i) == true)System.out.println(i);}
}
class math {public boolean shuixianhua(int x) {int i = 0, j = 0, k = 0;i = x/100;j = (x%100)/10;k = x%10;if (x == i*i*i + j*j*j + k*k*k)return true;elsereturn false;}
}

7.将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5

程序分析：对n进行分解质因数，应先找到一个最小的质数i，然后按下述步骤完成： 
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n > i，但n能被i整除，则应打印出i的值，并用n除以i的商,作为新的正整数你,重复执行第一步。
(3)如果n不能被i整除，则用i+1作为i的值,重复执行第一步。

import java.util.Scanner;
public class Demo04 {public Demo04() {super();}public void fenjie(int n) {for (int i = 2; i <= n; i++) {if (n % i == 0) {System.out.print(i);if(n!=i){System.out.print("*");}fenjie(n/i);}}System.exit(0); //退出程序
    }public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("请输入N的值：");int N = in.nextInt();System.out.print( "分解质因数：" + N +"=");new Demo04().fenjie(N);}
}

8.利用条件运算符的嵌套来完成此题：学习成绩=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

程序分析：(a>b)?a:b这是条件运算符的基本例子。

import java.util.Scanner;
public class Demo05 {public static void main(String[] args) {System.out.println("请输入N的值：");Scanner in = new Scanner(System.in);int N = in.nextInt();System.out.println(N >= 90 ?"A": (N >= 60 ? "B":"C"));}
}

9.输入两个正整数m和n，求其最大公约数和最小公倍数。

程序分析：利用辗除法

import java.util.Scanner;
public class Demo06 {public static void main(String[] args){int a,b,m,n;Scanner in=new Scanner(System.in);System.out.println("请输入一个正整数：");a=in.nextInt();System.out.println("再输入一个正整数：");b=in.nextInt();commonDivisor use=new commonDivisor();m=use.commonDivisor(a,b);n=a*b/m;System.out.println("最大公约数："+m);System.out.println("最小公倍数："+n); }
}
class commonDivisor{public int commonDivisor(int x,int y){if(x<y){int t=x;x=y;y=t;}while(y!=0){if(x==y)return x;else{int k=x%y;x=y;y=k;}}return x;}
}

10.输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

利用for循环语句,if条件语句。

import java.util.Scanner;public class Demo07 {public static void main(String[] args){System.out.println("请输入一个字符串;");Scanner in=new Scanner(System.in);String str=in.nextLine();char[] ch=str.toCharArray();count use=new count();use.count(ch);}
}
class count{int digital,character,blank,other;public void count(char[] arr){for(int i=0;i<arr.length;i++){if(arr[i]>='0'&&arr[i]<='9'){digital++;}else if((arr[i]>='a'&&arr[i]<='z')||(arr[i]>='A'&&arr[i]<='Z')){character++;}else if(arr[i]==' '){blank++;}else{other++;}}System.out.println("数字个数："+digital);System.out.println("英文字母个数："+character);System.out.println("空格个数："+blank);System.out.println("其他字符个数："+other);}
}

11.求s = a + aa + aaa + aaaa + aa...a的值，其中a是一个数字。例如2 + 22 + 222 + 2222 + 22222(此时共有5个数相加)，几个数相加有键盘控制。

程序分析：关键是计算出每一项的值。

import java.util.Scanner;
public class Demo08 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println(请输入a的值);int a = in.nextInt();System.out.println(请输入n个数);int n = in.nextInt();int s = 0,t=0;for (int i = 1; i <= n; i++) {t += a;a = a*10;s += t;}System.out.println(s);}
}

12.一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3。编程找出1000以内的所有完数。

public class Demo09 {public static void main(String[] args) {int s;for (int i = 1; i <= 1000; i++) {s = 0;for (int j = 1; j < i; j++)if (i % j == 0)s = s + j;if (s == i)System.out.print(i + " " );}System.out.println();}
}
或
public class Demo09{public static void main(String[] args) {int i,j,sum;          for(i=1;i<1000;i++)  {sum = 0;          for(j=1;j<=i/2;j++)   {if(i%j==0)         {sum+=j;        }}if(sum==i)            {System.out.print(i+" its factors are:   ");       for(j=1;j<=i/2;j++)                          {if(i%j==0)                                  System.out.print(j+", ");}System.out.println();}}}
}

13.一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

public class Demo10 {public static void main(String[] args) {double s = 0;double h = 100;for (int i = 1; i <= 10; i++) {s += h;h = h/2;s += h;}System.out.println("经过路程："+s);System.out.println("反弹高度："+h);}
}

14.有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。

public class Demo11 {public static void main(String[] args) {int count = 0;for (int i = 1; i <= 4; i++)for (int j = 1; j <= 4; j++)for (int k = 1; k <= 4; k++)if (i != j && j != k && i != k) {count += 1;System.out.println(i*100 + j*10 + k);}System.out.println("共" + count + "个三位数");}
}

15.企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润lirun，求应发放奖金总数sum？

程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型

import java.util.Scanner;
public class Demo12 {public static void main(String[] args) {double sum; System.out.println("输入当月利润：(万元)");Scanner in = new Scanner(System.in);double lirun = in.nextDouble(); if (lirun <= 10) {sum = lirun * 0.1;} else if (lirun <= 20) {sum = 10*0.1 + (lirun - 10) * 0.075;} else if (lirun <= 40) {sum = 10*0.1 + 10*0.075 + (lirun - 20) * 0.05;} else if (lirun <= 60) {sum = 10*0.1 + 10*0.075 + 10*0.05 + (lirun - 40) * 0.03;} else if (lirun <= 100) {sum = 10*0.1 + 10*0.075 + 10*0.05 + 10*0.03 + (lirun - 60) * 0.015;} else {sum = 10*0.1 + 10*0.075 + 10*0.05 + 10*0.03 + 10*0.015 + (lirun - 100) * 0.01;}System.out.println("应发的奖金是："+sum+"(万元)");}
}

16.一个整数，它加上100后是一个完全平方数，加上168又是一个完全平方数，请问该数是多少？

程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上168后再开方，如果开方后的结果满足如下条件，即是结果。请看具体分析：

public class Demo13 {public static void main(String[] args) {for(int x=1;x<100000;x++){if(Math.sqrt(x+100)%1==0)if(Math.sqrt(x+100+168)%1==0)System.out.println(x+"加上100后是一个完全平方数，加上168又是一个完全平方数");}}
}

17.输入某年某月某日，判断这一天是这一年的第几天？

程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本月的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。

import java.util.Calendar;
import java.util.Scanner;
public class Demo14 {public static void main(String[] args) {System.out.println("请输入年,月,日：");Scanner in = new Scanner(System.in);int year = in.nextInt();int month = in.nextInt();int day = in.nextInt();Calendar cal = Calendar.getInstance();cal.set(year, month - 1, day);int sum = cal.get(Calendar.DAY_OF_YEAR);System.out.println("这一天是这一年的第" + sum +"天");}
}
或
import java.util.*;
public class Demo14 {public static void main(String[] args){int year,month,day,sum=0;Scanner in=new Scanner(System.in);System.out.println("输入年：");year=in.nextInt();System.out.println("输入月：");month=in.nextInt();System.out.println("输入日：");day=in.nextInt();switch(month){case 1:sum=0;break;case 2:sum=31;break;case 3:sum=59;break;case 4:sum=90;break;case 5:sum=120;break;case 6:sum=151;break;case 7:sum=181;break;case 8:sum=212;break;case 9:sum=243;break;case 10:sum=273;break;case 11:sum=304;break;case 12:sum=334;break;default:System.out.println("wrong input!");return;}sum=sum+day;boolean leap;if(year%400==0||(year%4==0&&year%100!=0)){leap=true;}else {leap=false;}if(leap&&month>2){sum++;}System.out.println("It is the "+sum+"th day.");}
}
或
import java.util.Scanner;
public class Demo14 {public static void main(String[] args){System.out.println("请输入年 月 日：");Scanner in=new Scanner(System.in);int year=in.nextInt();int month=in.nextInt();int day=in.nextInt();System.out.println("是该年的第"+count(year,month,day)+"天");}public static int count(int year,int month,int day){int sum=0;int days=0;for(int i=1;i<month;i++){switch(i){case 1:case 3:case 5:case 7:case 8:case 10:case 12:days=31;break;case 4:case 6:case 9:case 11:days=30;break;case 2:if(year%400==0||year%4==0&&year%100!=0){days=29;}else{days=28;}break;}sum+=days;}sum+=day;return sum;}
}

18.输入三个整数x,y,z，请把这三个数由小到大输出。

程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。

import java.util.Arrays;
import java.util.Scanner;
public class Demo15 {public static void main(String[] args) {System.out.print("请输入三个数:");Scanner in = new Scanner(System.in);int[] arr = new int[3];for (int i = 0; i < 3; i++) {arr[i] = in.nextInt();}Arrays.sort(arr);for (int i=0;i<arr.length;i++) {System.out.print(arr[i] + " ");}}
}
或
if(x > y) { int t = x; x = y; y = t; } if(x > z) { int t = x; x = z; z = t; } if(y > z) { int t = y; y = z; z = t; }

19.输出9*9口诀乘法表

程序分析：分行与列考虑，共9行9列，i控制行，j控制列。

出现重复的乘积（全矩形）
public class Demo16 { public static void main(String[] args) {for (int i = 1; i <= 9; i++) {for (int j = 1; j <= 9; j++)System.out.print(i + "*" + j + "=" + (i*j) + "\t");System.out.println();}}
}
不现重复的乘积(下三角)
public class Demo16 {public static void main(String[] args) {for (int i = 1; i <= 9; i++) {for (int j = 1; j <= i; j++)System.out.print(i + "*" + j + "=" + (i*j) + "\t");System.out.println();}}
}

20.猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩
下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

程序分析：采取逆向思维的方法，从后往前推断。

public class Demo17 {public static void main(String[] args) {int sum = 1;for (int i = 0; i < 9; i++) {sum = (sum + 1) * 2;}System.out.println("第一天共摘"+sum);}
}

21.两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单

public class Demo18 {static char[] m = { 'a', 'b', 'c' }; static char[] n = { 'x', 'y', 'z' };public static void main(String[] args) {for (int i = 0; i < m.length; i++) { for (int j = 0; j < n.length; j++) {if (m[i] == 'a' && n[j] == 'x') {continue;} else if (m[i] == 'a' && n[j] == 'y') {continue;} else if ((m[i] == 'c' && n[j] == 'x')|| (m[i] == 'c' && n[j] == 'z')) {continue;} else if ((m[i] == 'b' && n[j] == 'z')|| (m[i] == 'b' && n[j] == 'y')) {continue;} elseSystem.out.println(m[i] + " vs " + n[j]);}}}
}
或
public class Demo18 {public String a, b, c;public Demo18(String a, String b, String c) {this.a = a;this.b = b;this.c = c;}public static void main(String[] args) {Demo18 arr_a = new Demo18("a", "b", "c");String[] b = { "x", "y", "z" };for (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {for (int k = 0; k < 3; k++) {Demo18 arr_b = new Demo18(b[i], b[j], b[k]);if (!arr_b.a.equals(arr_b.b) & !arr_b.b.equals(arr_b.c)& !arr_b.c.equals(arr_b.a) & !arr_b.a.equals("x")& !arr_b.c.equals("x") & !arr_b.c.equals("z")) {System.out.println(arr_a.a + "--" + arr_b.a);System.out.println(arr_a.b + "--" + arr_b.b);System.out.println(arr_a.c + "--" + arr_b.c);}}}}}
}

22.打印出如下图案（菱形）

程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重for循环，第一层控制行，第二层控制列。

三角形：
*
***
******
********
******
***
*
public class Demo19 {public static void main(String[] args) {int i=0;int j=0;for ( i = 1; i <= 4; i++) {for ( j = 1; j <= 2 * i - 1; j++)System.out.print("*");System.out.println();}for ( i = 3; i >= 1; i--) {for ( j = 1; j <= 2 * i - 1; j++)System.out.print("*");System.out.println();}}
}菱形：* *** *****
****************
public class Demo19 {public static void main(String[] args) {int i = 0;int j = 0;for (i = 1; i <= 4; i++) {for (int k = 1; k <= 4 - i; k++)System.out.print( " " );for (j = 1; j <= 2 * i - 1; j++)System.out.print("*");System.out.println();}for (i = 3; i >= 1; i--) {for (int k = 1; k <= 4 - i; k++)System.out.print( " " );for (j = 1; j <= 2 * i - 1; j++)System.out.print("*");System.out.println();}}
}

23.有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和

程序分析：请抓住分子与分母的变化规律。

public class Demo20 {public static void main(String[] args) {float fm = 1.0f;float fz = 1.0f;float temp;float sum = 0f;for (int i = 0; i < 20; i++) {temp = fm;fm = fz;fz = fz + temp;System.out.println((int) fz + "/" + (int) fm);sum += fz / fm;}System.out.println(sum);}
}

24.题目：求1+2!+3!+...+20!的和。

程序分析：此程序只是把累加变成了累乘。

public class Demo21 {public static void main(String[] args) {long sum = 0;long fac = 1;for (int i = 1; i <= 20; i++) {fac = fac * i;sum += fac;}System.out.println(sum);}
}

25.题目：利用递归方法求5!。

程序分析：递归公式：f(n)=f(n-1)*4!

import java.util.Scanner;
public class Demo22 {public static long fac(int n) {long value = 0;if (n == 1 || n == 0) {value = 1;} else if (n > 1) {value = n * fac(n - 1);}return value;}public static void main(String[] args) {System.out.println("请输入一个数：");Scanner in = new Scanner(System.in);int n = in.nextInt();System.out.println(n + "的阶乘为：" + fac(n));}
}

26. 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两
岁。最后问第一个人，他说是10岁。请问第五个人多大？

程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。

直接求解：
public class Demo23 {public static void main(String[] args) {int n = 10;for (int i = 0; i < 4; i++) {n = n + 2;}System.out.println("第五个人" + n + "岁");}
}
递归求解：
public class Demo23 {public static int getAge(int n) {if (n == 1) {return 10;}return 2 + getAge(n - 1);}public static void main(String[] args) {System.out.println("第五个的年龄为" + getAge(5));}
}

27.题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

本题原方法：
import java.util.Scanner;
public class Demo24 {public static void main(String[] args) {Demo24 use = new Demo24();System.out.println("请输入：");Scanner in = new Scanner(System.in);long a = in.nextLong();if (a < 0 || a >= 100000) {System.out.println("Error Input, please run this program Again!");System.exit(0);}if (a >= 0 && a <= 9) {System.out.println(a + "是一位数");System.out.println("按逆序输出是:"  + a);} else if (a >= 10 && a <= 99) {System.out.println(a + "是二位数");System.out.println("按逆序输出是:");use.converse(a);} else if (a >= 100 && a <= 999) {System.out.println(a + "是三位数");System.out.println("按逆序输出是:");use.converse(a);} else if (a >= 1000 && a <= 9999) {System.out.println(a + "是四位数");System.out.println("按逆序输出是:");use.converse(a);} else if (a >= 10000 && a <= 99999) {System.out.println(a + "是五位数");System.out.println("按逆序输出是:");use.converse(a);}}public void converse(long l) {String s = Long.toString(l);char[] ch = s.toCharArray();for (int i = ch.length - 1; i >= 0; i--) {System.out.print(ch[i]);}}
}
个人版方法：
import java.util.Scanner;
public class Demo24 {public static void main(String[] args) {System.out.println("请输入：");Scanner in = new Scanner(System.in);String str = in.next();if (str.matches("\\d+")) { //正则表达式System.out.println("输入的是" + str.length() + "位数");StringBuffer buf = new StringBuffer(str);System.out.println(buf.reverse());//字符串反转
        }}
}

28.题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

原方法：
import java.util.Scanner;
public class Demo25 {static int[] a = new int[5];static int[] b = new int[5];public static void main(String[] args) {boolean is = false;System.out.println("Please input：");Scanner in = new Scanner(System.in);long l = in.nextLong();if (l > 99999 || l < 10000) {System.out.println("Input error, please input again!");l = in.nextLong();}for (int i = 4; i >= 0; i--) {a[i] = (int) (l / (long) Math.pow(10, i));l = (l % (long) Math.pow(10, i));}System.out.println();for (int i = 0, j = 0; i < 5; i++, j++) {b[j] = a[i];}for (int i = 0, j = 4; i < 5; i++, j--) {if (a[i] != b[j]) {is = false;break;} else {is = true;}}if (is == false) {System.out.println("is not a Palindrom!");} else if (is == true) {System.out.println("is a Palindrom!");}}
}
个人版：
import java.util.Scanner;
public class Demo25 {public static void main(String[] args) {System.out.println("请输入：");Scanner in = new Scanner(System.in);String str = in.next();int l = Integer.parseInt(str);//转换成整数if (l < 10000 || l > 99999) {System.out.println("输入错误！");System.exit(0);}boolean is=false;char[] ch = str.toCharArray();for(int i=0;i<ch.length/2;i++){if(ch[i]!=ch[ch.length-i-1]){is=false;}else{is=true;}}if(is){System.out.println("这是一个回文!");}else{System.out.println("不是一个回文!");}}
}

29.题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。

程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或if语句判断第二个字母。

import java.util.Scanner;
public class Demo26 {public static void main(String[] args) {char weekSecond;//保存第二字母Scanner in = new Scanner(System.in);//接收用户输入System.out.println("请输入星期的第一个字母：");String letter = in.next();if (letter.length() == 1) {//判断用户控制台输入字符串长度是否是一个字母char weekFirst = letter.charAt(0);//取第一个字符switch (weekFirst) {case 'm':case 'M':System.out.println("星期一(Monday)");break;case 't':case 'T':System.out.print("由于星期二(Tuesday)与星期四(Thursday)均以字母T开头，故需输入第二个字母才能正确判断：");letter = in.next();                 if (letter.length() == 1) {weekSecond = letter.charAt(0);if (weekSecond == 'U' || weekSecond == 'u') {System.out.println("星期二(Tuesday)");break;} else if (weekSecond == 'H' || weekSecond == 'h') {System.out.println("星期四(Thursday)");break;} else {System.out.println("Error!");break;}} else {System.out.println("输入错误，只能输入一个字母，程序结束！");break;}case 'w':case 'W':System.out.println("星期三(Wednesday)");break;case 'f':case 'F':System.out.println("星期五(Friday)");break;case 's':case 'S':System.out.print("由于星期六(Saturday)与星期日(Sunday)均以字母S开头，故需输入第二个字母才能正确判断：");letter = in.next();if (letter.length() == 1) {weekSecond = letter.charAt(0);if (weekSecond == 'A' || weekSecond == 'a') {System.out.println("星期六(Saturday)");break;} else if (weekSecond == 'U' || weekSecond == 'u') {System.out.println("星期日(Sunday)");break;} else {System.out.println("Error!");break;}} else {System.out.println("输入错误，只能输入一个字母，程序结束！");break;}default:System.out.println("输入错误，不能识别的星期值第一个字母，程序结束！");break;}} else {System.out.println("输入错误，只能输入一个字母，程序结束！");}}
}

30.题目：求100之内的素数

public class Demo27 {public static void main(String args[]) {int sum, i;for (sum = 2; sum <= 100; sum++) {for (i = 2; i <= sum / 2; i++) {if (sum % i == 0)break;}if (i > sum / 2)System.out.println(sum + "是素数");}}
}
或
public class Demo27{public static void main(String args[]){int w=1;for(int i=2;i<=100;i++){for(int j=2;j<i;j++){w=i%j;if(w==0)break;}if(w!=0)System.out.println(i+"是素数"); }}
}

31.题目：对10个数进行排序

程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。

本例代码为生成随机10个数排序，并输入1个数，插入重排序输出：
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class Demo28 {public static void main(String[] args) {int arr[] = new int[11];Random r = new Random();for (int i = 0; i < 10; i++) {arr[i] = r.nextInt(100) + 1; //得到10个100以内的整数
        }Arrays.sort(arr);for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] +"\t");}System.out.print("\nPlease Input a int number:" );Scanner in = new Scanner(System.in);arr[10] = in.nextInt(); Arrays.sort(arr);for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] +"\t");}}
}
个人代码：
import java.util.Arrays;
import java.util.Scanner;
public class Demo28 {public static void main(String[] args) {System.out.println("请输入10个数：");Scanner in = new Scanner(System.in);int[] arr = new int[10];for (int i = 0; i < 10; i++) {arr[i] = in.nextInt(); }System.out.println("原数组为：");for (int x : arr) {//foreach遍历System.out.print( x + "\t");}Arrays.sort(arr);System.out.println();System.out.println("排序后为：");for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}

32.题目：求一个3*3矩阵主对角线元素之和。

程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。

public class Demo29 {public static void main(String[] args) {double sum = 0;int array[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 7, 8 } };for (int i = 0; i < 3; i++)for (int j = 0; j < 3; j++) {if (i == j)sum = sum + array[i][j];}System.out.println(sum);}
}
主负对角线：for(i=0;i<n;i++)for(j=0;j<n;j++){if(i==j) sum1+=a[i][j];if(i+j==n-1) sum2+=a[i][j];}

33. 题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。

import java.util.Random;
public class Demo30 {public static void main(String[] args) {int temp = 0;int arr[] = new int[12];Random r = new Random();for (int i = 0; i <= 10; i++)arr[i] = r.nextInt(1000);for (int i = 0; i <= 10; i++)System.out.print(arr[i] + "\t");for (int i = 0; i <= 9; i++)for (int k = i + 1; k <= 10; k++)if (arr[i] > arr[k]) {temp = arr[i];arr[i] = arr[k];arr[k] = temp;}System.out.println();for (int k = 0; k <= 10; k++)System.out.print(arr[k] + "\t");arr[11] = r.nextInt(1000);for (int k = 0; k <= 10; k++)if (arr[k] > arr[11]) {temp = arr[11];for (int j = 11; j >= k + 1; j--)arr[j] = arr[j - 1];arr[k] = temp;}System.out.println();for (int k = 0; k <= 11; k++)System.out.print(arr[k] + "\t");}
}

34.题目：将一个数组逆序输出。

程序分析：用第一个与最后一个交换

用逆序循环控制变量输出：
public class Demo31 {public static void main(String[] args) {int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };for (int i = a.length - 1; i >= 0; i--) {System.out.print(a[i] + " ");}}
}

35.题目：取一个整数a从右端开始的第4～7位数字

import java.util.*;
public class Demo32 { public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.print("请输入一个7位以上的正整数："); long l = in.nextLong(); String str = Long.toString(l); char[] ch = str.toCharArray();int j=ch.length; if (j<7){System.out.println("输入错误！");} else { System.out.println("截取从右端开始的4～7位是："+ch[j-7]+ch[j-6]+ch[j-5]+ch[j-4]);}}
}
或
import java.util.Scanner;
public class Demo32{public static void main(String[] args) {int a = 0;Scanner s = new Scanner(System.in);long b = s.nextLong();a = (int) (b % 10000000 / 1000);System.out.println(a);}
}

36.题目：打印出杨辉三角形（要求打印出10行如下图）

程序分析：
1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5   10   10   5   1

public class Demo33 {public static void main(String args[]) {int i, j;int a[][];int n = 10;a = new int[n][n];for (i = 0; i < n; i++) {a[i][i] = 1;a[i][0] = 1;}for (i = 2; i < n; i++) {for (j = 1; j <= i - 1; j++) {a[i][j] = a[i - 1][j - 1] + a[i - 1][j];}}for (i = 0; i < n; i++) {for (j = 0; j <= i; j++) {System.out.printf(a[i][j] + "\t");}System.out.println();}}
}

37.题目：输入3个数a,b,c，按大小顺序输出。（也可互相比较交换排序）

import java.util.Arrays;
public class Demo34 {public static void main(String[] args) {int[] arrays = { 800, 56, 500 };Arrays.sort(arrays);for (int n = 0; n < arrays.length; n++)System.out.println(arrays[n]);}
}
或
if(x > y) { int t = x; x = y; y = t; } if(x > z) { int t = x; x = z; z = t; } if(y > z) { int t = y; y = z; z = t; }

38. 题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

import java.util.*;
public class Demo35 {public static void main(String[] args) {int i, min=0, max=0, n, temp1, temp2;int a[];System.out.println("定义数组的长度:");Scanner in = new Scanner(System.in);n = in.nextInt();a = new int[n];for (i = 0; i < n; i++) {System.out.print("输入第" + (i + 1) + "个数据:");a[i] = in.nextInt();}for (i = 1; i < n; i++) {if (a[i] > a[max])max = i;  if (a[i] < a[min])min = i;  }temp1 = a[0]; a[0] = a[max];a[max] = temp1;temp2 = a[min];  if (min != 0) { // 如果最小值不是a[0]，执行下面a[min] = a[n - 1];a[n - 1] = temp2;  } else {  //如果最小值是a[0],执行下面a[max] = a[n - 1];a[n - 1] = temp1;}for (i = 0; i < n; i++) {  System.out.print(a[i] + " " );}}
}

39.题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Demo36 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("输入数字个数n：");int n = in.nextInt();System.out.println("输入后移位数m：");int m = in.nextInt();LinkedList<Integer> list = new LinkedList<Integer>();for (int i = 0; i < n; i++) {System.out.println("请输入第"+(i+1)+"个数:");list.add(in.nextInt());}System.out.println("原数据排序为：");for (int t : list) {System.out.print(t + " " );}System.out.println();List<Integer> temp1 = list.subList(list.size() - m, list.size());List<Integer> temp2 = list.subList(0, list.size() - m);temp2.addAll(0, temp1);System.out.println("移动后排序为;");for (int t : temp2) {System.out.print(t + " " );}}
}
或
import java.util.*;
public class Demo36{public static void main(String[] args){Scanner in=new Scanner(System.in);        System.out.println("请定义数组的长度：");int n=in.nextInt();System.out.println("请输入移动的位数：");int m=in.nextInt();int [] arr=new int [n];int [] brr=new int [n];for(int i=0;i<n;i++){System.out.println("请输入第"+(i+1)+"个数：");arr[i]=in.nextInt();}System.out.println("排序前：");for(int i=0;i<n;i++){System.out.print(arr[i]+" ");}System.out.println();for(int i=0;i<m;i++){brr[i]=arr[n-m+i];}for(int i=0;i<n-m;i++){arr[m+i]=arr[i];}for(int i=0;i<m;i++){arr[i]=brr[i];}System.out.println("排序后：");for(int i=0;i<n;i++){System.out.print(arr[i]+" ");}}
}

40.题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
（约瑟夫环问题，百度百科有时间复杂度最简单的数学方法）

原例代码：
import java.util.Scanner;
public class Demo37 {public static void main(String[] args) {System.out.println("请输人数n：");Scanner in = new Scanner(System.in);int n = in.nextInt();boolean[] arr = new boolean[n];for (int i = 0; i < arr.length; i++) {arr[i] = true; //下标为TRUE时说明还在圈里
        }int leftCount = n;int countNum = 0;int index = 0;while (leftCount > 1) {if (arr[index] == true) { //当在圈里时countNum++;  //报数递加if (countNum == 3) { //报数为3时countNum = 0; //从零开始继续报数arr[index] = false; //此人退出圈子leftCount--; //剩余人数减一
                }}index++; //每报一次数，下标加一if (index == n) { //是循环数数，当下标大于n时，说明已经数了一圈，index = 0; //将下标设为零重新开始。
            }}for (int i = 0; i < n; i++) {if (arr[i] == true) {System.out.println(i);}}}
}
个人代码1：
import java.util.Scanner;
public class Demo37 {public static void main(String[] args) {System.out.println("请输入人数：");Scanner in = new Scanner(System.in);int[] a = new int[in.nextInt()];for (int i = 0; i < a.length; i++) {a[i] = 1;}int left = a.length;int j = 0;int num = 0;while (left > 1) {if (a[j] == 1) {num++;}if (num == 3) {a[j] = 0;num = 0;left--;}j++;if (j == a.length) {j = 0;}}for (int i = 0; i < a.length; i++) {if (a[i] == 1) {System.out.println("最后留下的人是"+ (i + 1) + "号");break;}}}
}
个人代码2：
import java.util.LinkedList;
import java.util.Scanner;
public class Demo37 {public static void main(String[] args) {LinkedList<Integer> l = new LinkedList<Integer>();System.out.println("请输入人数：");Scanner in = new Scanner(System.in);int len = in.nextInt();for (int i = 0; i < len; i++) {l.add(i + 1);}int sum = 0;int temp = 0;for (int i = 0; sum != len - 1;) {if (l.get(i) != 0) {temp++;}if (temp == 3) {l.remove(i);l.add(i, 0);temp = 0;sum++;}i++;if (i == l.size()) {i = 0;}}for (int t : l) {if (t != 0) {System.out.println("最后留下的人是" + t + "号");}}}
}

41.题目:写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

import java.util.Scanner;
public class Demo38 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("请输入一个字符串：");String mys = in.next();System.out.println(str_len(mys));}public static int str_len(String x) {return x.length();}
}
或
import java.util.Scanner;
public class Demo38 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("请输入一个字符串：");String mys = in.next();System.out.println(mys.length());}
}

42.题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n

import java.util.Scanner;
public class Demo39 {public static double ouShu(int n) {double result = 0;for (int i = 2; i <= n; i = i + 2) {result +=  1 / (double) i;}return result;}public static double jiShu(int n) {double result = 0;for (int i = 1; i <= n; i = i + 2) {result += 1 / (double) i;}return result;}public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("输入n的值：");int n = in.nextInt();if (n % 2 == 0) { //偶数，1/2+1/4+...+1/n
            System.out.println(ouShu(n));} else { //奇数，1/1+1/3+...+1/n
            System.out.println(jiShu(n));}}
}

43. 题目：字符串排序。

利用容器类中的sort方法

import java.util.*;
public class Demo40 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<String>();list.add("010102");list.add("010003");list.add("010201");Collections.sort(list);for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}
}
或
import java.util.*;public class Demo40 {public static void main(String[] args){Scanner in=new Scanner(System.in);System.out.println("请定义字符串的个数：");int n=in.nextInt();String[] str=new String[n];for(int i=0;i<str.length;i++){System.out.println("请输入第"+(i+1)+"字符串：");str[i]=in.next();}strSort(n,str);System.out.println("字符串排序后：");for(int i=0;i<str.length;i++){System.out.print(str[i]+" ");}}public static void strSort(int n,String[] arr){for(int i=0; i<n; i++) { for(int j=i+1; j<n; j++) { if(compare(arr[i], arr[j]) == false) { String temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;} } } }static boolean compare(String s1, String s2) {boolean result = true; for(int i=0; i<s1.length() && i<s2.length(); i++) { if(s1.charAt(i) > s2.charAt(i)) {result = false; break;} else if(s1.charAt(i) <s2.charAt(i)) {result = true;break;} else { if(s1.length() < s2.length()) {result = true;} else { result = false; } } } return result;}
}

44.题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

本题源码：
public class Demo41 {static int ts = 0;// 桃子总数int fs = 1;// 记录分的次数static int hs = 5;// 猴子数int tsscope = 5000;// 桃子数的取值范围，太大容易溢出。public int fT(int t) {if (t == tsscope) {// 当桃子数到了最大的取值范围时取消递归System.out.println("结束");return 0;} else {if ((t - 1) % hs == 0 && fs <= hs) {if (fs == hs) {System.out.println("桃子数=" + ts + "时满足分桃条件");}fs += 1;return fT((t - 1) / 5 * 4);// 返回猴子拿走一份后的剩下的总数} else {// 没满足条件fs = 1;// 分的次数重置为1return fT(ts += 1);// 桃子数加+1
            }}}public static void main(String[] args) {new Demo41().fT(0);}
}
个人修改：
public class Demo41 {public static void main(String[] args) {int sum = 0;for (int i = 6;; i++) {// 最少6个分最后一次sum = i;// 桃子数for (int j = 0; j < 5; j++) {// 分的次数循环if ((sum - 1) % 5 == 0 && j < 5) {// 如果扔一个后能均分5份，继续分sum = (sum - 1) / 5 * 4;// 每分一次剩余桃子数if (j == 4) {// 如果已分5次，且仍能除尽，输出，退出程序
                        System.out.println(i);System.exit(0);}}}}}
}

45. 题目：809*??=800*??+9*??+1。其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。

（本题为无解，去掉1有解）

public class Demo42 {public static void main(String[] args) {for (int i = 10; i < 100; i++) {if (809 * i == (800 * i + 9 * i + 1) && 8 * i >= 10 && 8 * i < 100&& 9 * i >= 100 && 9 * i < 1000) {System.out.println("?? =" + i);System.out.println("809*??="+ 809 * i);System.exit(0);}}}
}

46.题目：求0—7所能组成的奇数个数。

暴力算法：
public class Demo43 {public static boolean isJiShu(int n) {if (n % 2 != 0) {return true;} else {return false;}}public static boolean fun(char c) {if (c >= '0' && c <= '7') {return true;} else {return false;}}public static void main(String[] args) {int count = 0;String s;for (int i = 0; i < 100000000; i++) {s = "" + i;boolean flag = true;char[] c = s.toCharArray();for (int j = 0; j < c.length; j++) {if (!fun(c[j])) {flag = false;break;}}if (flag && isJiShu(i)) {count++;}s = "";}System.out.println("共" + count + "个。");}
}
数学算法：
public class Demo43 {public static void main(String[] args) {// 因为是奇数，所以个位只能是1，3，5，7共4种，前面可随便排列int count = 4;// 个位的4种// 2位时，十位有8种，个位4种，8×4// 3位时，8×8×4……for (int i = 1; i < 8; i++) {count = 8 * count;System.out.println("count:" + count);}}
}
个人算法：
//组成1位数是4个。
//组成2位数是7*4个。
//组成3位数是7*8*4个。
//组成4位数是7*8*8*4个。
//......
public class Demo43 { public static void main (String[] args) { int sum=4; int j;System.out.println("组成1位数是 "+sum+" 个"); sum=sum*7; System.out.println("组成2位数是 "+sum+" 个");for(j=3;j<=9;j++){ sum=sum*8; System.out.println("组成"+j+"位数是 "+sum+" 个"); } }
}

47.题目：一个偶数总能表示为两个素数之和。（注：哥德巴赫猜想是想证明对任何大于6的自然数n之内的所有偶数可以表示为两个素数之和）

public class Demo44 {public static boolean isSuShu(int x) {if (x == 0 || x == 1) {return false;}for (int i = 2; i <= Math.sqrt(x); i++) {if (x % i == 0) {return false;}}return true;}public static void main(String[] args) {// 求了下100以内的情况for (int i = 0; i < 100; i = i + 2) {for (int j = 0; j <= (i + 1) / 2; j++) {if (isSuShu(j) && isSuShu(i - j)) {System.out.println(i + "=" + j + "+" + (i - j));}}}}
}
或
public class Demo44{    public static void main(String[] args){    for (int i=6;i<=100 ;i+=2 ){    for (int j=2;j<100 ;j++ ){        if(!isPrime(j)||!isPrime(i-j)||j>=i) continue;            System.out.println(i+"="+j+"+"+(i-j));            break;        }        }    }   public static boolean isPrime(int n){    for (int i=2;i<n ;i++ ){        if(n%i==0)return false;    }            return true;    }
}

48.题目：（1）判断几个9能被一个素数整除。（2）判断一个整数能被几个9整除。（原题：一个素数能被几个9整除）

（一）
public class Demo45 {public static boolean isSuShu(int x) {if (x == 0 || x == 1) {return false;}for (int i = 2; i <= Math.sqrt(x); i++) {if (x % i == 0) {return false;}}return true;}public static void main(String[] args) {int[] a = new int[100];int n = 0;int num = 0;// 长度100的素数数组while (n < 100) {if (isSuShu(num)) {a[n] = num;n++;num++;} else {num++;}}/* for (int t : a) {System.out.println(t);}*/String s = "9";int index = 0;while (s.length() < 9) {if (new Integer(s).intValue() % a[index] == 0) {System.out.println(s + "%" + a[index] + "=0");if (index < 100 - 1) {index++;} else {index = 0;s = s + "9";}// System.exit(0);} else {if (index < 100 - 1) {index++;} else {index = 0;s = s + "9";}}}}
}（二）
import java.util.*; public class Demo45 {public static void main (String[] args) {Scanner in = new Scanner(System.in);System.out.print("请输入一个整数：");int num = in.nextInt();int tmp = num;int count = 0;for(int i = 0 ; tmp%9 == 0 ;){tmp = tmp/9;count ++;}System.out.println(num+" 能够被 "+count+" 个9 整除。");}
}

49.题目：两个字符串连接程序。

import java.util.Scanner;
public class Demo46 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("输入第一个字符串：");String s1 = in.next();System.out.println("输入第一个字符串：");String s2 = in.next();System.out.println("连接后：\n" + s1 + s2);}
}
或
import java.util.*;
public class Demo46 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.print("请输入一个字符串：");String str1 = in.nextLine();System.out.print("请再输入一个字符串：");String str2 = in.nextLine();String str = str1+str2;System.out.println("连接后的字符串是："+str);}
}

50.题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的。

import java.util.*;
public class Demo47 {public static void main(String[] args) {Scanner s = new Scanner(System.in);int n=1,num;while(n<=7){do{System.out.print("请输入一个1--50 之间的整数：");num= s.nextInt();}while(num<1||num>50);for(int i=1;i<=num;i++){System.out.print("*");}System.out.println();n ++;}}
}
或
import java.util.Scanner;
public class Demo47 {public static void print(int n) {for (int i = 0; i < n; i++) {System.out.print("*");}System.out.println();}public static void main(String[] args) {Scanner in = new Scanner(System.in);for (int i = 0; i < 7; i++) {int temp = in.nextInt();print(temp);}}
}

51.题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5，然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

import java.util.Scanner;
public class Demo48{public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("请输入一个4位数字：");String str = in.next();if (!((str).matches("\\d{4}"))) {System.out.println("输入的不是4位数字！");System.exit(0);}char[] c = str.toCharArray();int[] a = new int[4];for (int i = 0; i < a.length; i++) {a[i] = ((int) (c[i] - '0') + 5) % 10;}int t;t = a[0];a[0] = a[3];a[3] = t;t = a[1];a[1] = a[2];a[2] = t;System.out.println("结果是：" + a[0] + a[1] + a[2] + a[3]);}
}
或
import java.util.*;
public class Demo48 { public static void main(String args[]) {Scanner s = new Scanner(System.in); int num=0,temp; do{ System.out.print("请输入一个4位正整数：");num = s.nextInt(); }while (num<1000||num>9999);int a[]=new int[4]; a[0] = num/1000; //取千位的数字 a[1] = (num/100)%10; //取百位的数字 a[2] = (num/10)%10; //取十位的数字 a[3] = num%10; //取个位的数字 for(int j=0;j<4;j++) { a[j]+=5; a[j]%=10;}for(int j=0;j<=1;j++) {temp = a[j]; a[j] = a[3-j]; a[3-j] =temp;} System.out.print("加密后的数字为：");for(int j=0;j<4;j++) System.out.print(a[j]); }
}

52.题目：计算字符串中子串出现的次数。

import java.util.Scanner;
public class Demo49 {public static void main(String[] args) {Scanner in=new Scanner(System.in);System.out.println("请输入主串：");String str1 = in.nextLine();System.out.println("请输入子串：");String str2 = in.nextLine();// 生成子串长度的N个字符串数组String[] sa = new String[str1.length() - str2.length() + 1];for (int i = 0; i < sa.length; i++) {sa[i] = str1.substring(i, i + str2.length());}int sum = 0;// 子串与N个拆开的子串比对for (int i = 0; i < sa.length; i++) {if (sa[i].equals(str2)) {// 成功配对，计数器+1；sum++;// 因为不计算重叠的子串，所以跳过配对之后的部分拆分子串i = i + str2.length();}}System.out.println("主串中共包含" + sum + "个字串");}
}

53. 题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，把原有的数据和计算出的平均分数存放在磁盘文import java.io.File;

import java.io.FileWriter;
import java.util.Scanner;
class Student {private int number = 0;private String name = "";private double[] a = new double[3];public double getAve() {return (a[0] + a[1] + a[2]) / 3;}public Student(int number, String name, double[] a) {super();this.number = number;this.name = name;this.a = a;}@Overridepublic String toString() {return "学号：" + this.number + "\t姓名：" + this.name + "\r\n各科成绩：\r\n" + a[0] + "\t" + a[1] + "\t" + a[2] + "\r\n平均成绩：\r\n"+ this.getAve();}
}
public class Demo50 {public static Student input() {Scanner s = new Scanner(System.in);System.out.println("请输入学号：");int num = s.nextInt();System.out.println("请输入姓名：");String name = s.next();System.out.println("请分别输入3门成绩：");double[] a = new double[3];for (int i = 0; i < 3; i++) {a[i] = s.nextDouble();}return new Student(num, name, a);}public static void main(String[] args) throws Exception {Student[] st = new Student[2];for (int i = 0; i < st.length; i++) {st[i] = input();}File f = new File("d:" + File.separator + "123.txt");FileWriter output = new FileWriter(f);for (int i = 0; i < st.length; i++) {output.write(st[i].toString() + "\r\n");output.write("\r\n");}output.close();}
}

【Java-排序算法】相关推荐

  1. Java排序算法：冒泡排序

    Java排序算法:冒泡排序 //创建数组并赋值int[] data = new int[] {11,10,55,78,100,111,45,56,79,90,345,1000};for(int i=0 ...

  2. Java十大排序算法总结,Java排序算法总结之冒泡排序

    本文实例讲述了Java排序算法总结之冒泡排序.分享给大家供大家参考.具体分析如下: 前言:冒泡排序(BubbleSort)就是依次比较相邻的两个数,将小数放在前面,大数放在后面. 下面让我们一起    ...

  3. Java排序算法之直接选择排序

    Java排序算法之直接选择排序 基本过程:假设一序列为R[0]~R[n-1],第一次用R[0]和R[1]~R[n-1]相比较,若小于R[0],则交换至R[0]位置上.第二次从R[1]~R[n-1]中选 ...

  4. java排序算法 sort_Java排序算法之SleepSort排序示例

    本文实例讲述了Java排序算法之SleepSort排序.分享给大家供大家参考,具体如下: 分享一个很有创意的排序算法:sleepSort .巧妙利用了线程的sleep(),代码如下: public c ...

  5. java 排序算法总结,Java排序算法总结之归并排序

    本文实例讲述了Java排序算法总结之归并排序.分享给大家供大家参考.具体分析如下: 归并操作(merge),也叫归并算法,指的是将两个已经排序的序列合并成一个序列的操作.和快速排序类似,让我们一起来看 ...

  6. Java排序算法——插入排序（Insertion Sort）

    之前总结了交换排序的冒泡排序与选择排序的简单选择排序,这次我们来看看插入排序的简单插入排序~ 往期传送门: 冒泡排序: Java排序算法--冒泡排序(Bubble Sort)https://blog. ...

  7. Java排序算法——选择排序

    Java排序算法--选择排序(Selection sort) 传送门 冒泡排序 插入排序 简述 选择排序(Selection sort)是一种简单直观的排序算法.它的工作原理如下.首先在未排序序列中找 ...

  8. java排序算法（插入排序，冒泡排序，选择排序）

    java排序算法(插入排序,冒泡排序,选择排序) 先了解原理,然后自己跟着敲一下,加深印象 CMD编译命令:javac -encoding utf-8 SortList.java && ...

  9. java 排序算法 讲解_java实现排序算法之冒泡排序法详细讲解

    冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交 ...

  10. Java排序算法总结

    稳定排序: * 泡沫排序(bubble sort) - O(n²) * 插入排序 (insertion sort)- O(n²) * 桶排序 (bucket sort)- O(n); 需要 O(k)  ...

最新文章

  1. Android自定义View：MeasureSpec的真正意义与View大小控制
  2. Android应用开发—TabLayout定制化Tab样式
  3. SAP License：统计型实际结算型内部订单
  4. (转)Managed DirectX +C# 开发（入门篇）（七）
  5. Oracle 更新多字段1
  6. 数值积分方法的总结（从简单梯形积分到龙贝格积分、自适应积分、高斯积分等）
  7. 秒杀系统设计要点总结
  8. 煤矿智能更衣柜管理系统解决方案
  9. RAID 技术全解 – RAID0、RAID1、RAID5、RAID10
  10. 什么？阿里巴巴不允许工程师直接使用Log4j和Logback的API！
  11. 一个失败的项目管理案例
  12. HRBUST - 1653
  13. excel基础知识大全_冷轧基础知识学习（八）
  14. 欧美游戏业者都挣多少钱
  15. 西安硬科技创新大会前奏，一起玩转陕西首档广播双创节目乐创power
  16. 微信小程序-从相册获取图片,视频 使用相机拍照,录像上传+服务器(nodejs版)接收
  17. 支付宝当面付（扫二维码）
  18. 【1000套HTML5+CSS项目实战案例】大学生期末网页作业源代码
  19. 图片损坏打不开如何修复?
  20. 一刻相册“AI头像生成器”，普通照片秒变超现实大片

热门文章

  1. PHP代码审计--百家CMS4.1.4项目实战（上）
  2. halcon，什么是标定？怎么标定？标定获得了什么？标定能干什么？
  3. apache RewriteCond详解
  4. 动态再结晶CA法模拟基础之生命游戏入门
  5. Codeforces Round #739 (Div. 3) 「A B C D E F1 F2」
  6. Word中分节符的奇妙用法(转)
  7. Python开发-Django安全
  8. 海惠生活，海量优惠充斥你的生活
  9. 推荐三个快速在线生成微信跳转手机浏览器api接口的平台
  10. steam登录api_教程：STEAM换绑手机令牌最短冷却时间的操作方式（48小时）。