Java面试题-算法篇十七
Posted Java知音
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java面试题-算法篇十七相关的知识，希望对你有一定的参考价值。
170，堆和栈在内存中的区别是什么？
概念：
栈（stack）是为执行线程留出的内存空间。当函数被调用的时候，栈顶为局部变量和一些 bookkeeping 数据预留块。当函数执行完毕，块就没有用了，可能在下次的函数调用的时候再被使用。栈通常用后进先出的方式预留空间；因此最近的保留块通常最先被释放。这么做可以使跟踪堆栈变的简单；从栈中释放块只不过是指针的偏移而已。
堆（heap）是为动态分配预留的内存空间。和栈不一样，从堆上分配和重新分配块没有固定模式；你可以在任何时候分配和释放它。这样使得跟踪哪部分堆已经被分配和被释放变的异常复杂；有许多定制的堆分配策略用来为不同的使用模式下调整堆的性能。
区别：
内存分配：
堆：一般人为分配和释放，对Java而言由系统释放回收，但对于C++等，必须手动释放，如果没有手动释放会引起内存泄漏。
系统响应：
栈：只要栈的剩余空间大于所申请的空间，系统将为程序提供内存，否则将报异常提示栈溢出。
大小限制：
结论：堆获得的空间比较灵活，也比较大。
分配效率：
栈：由系统自动分配，速度较快，无法人为控制。
堆：由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
存储内容：
堆：一般在堆的头部用一个字节存放堆的大小，具体内容受人为控制。
171，求出1000之内的所有水仙花数
概念：
水仙花数指的是一个三位整数，它的各位数字的立方和等于这个数本身.。
解法：
public class NumberOfDaffodils { public static void main(String[] args) { // TODO Auto-generated method stub int hundred, ten, bits; System.out.println("水仙花数为："); for (int i = 100; i <= 999; i++) { hundred = i / 100; ten = i % 100 / 10; bits = i % 10; if (i == hundred * hundred * hundred + ten * ten * ten + bits * bits * bits) { System.out.print(i + " "); } } } } 172，比较一下几种常用的排序算法，简单的写一下你知道的几种排序算法？
比较：
1.稳定性比较
插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的
选择排序、希尔排序、快速排序、堆排序是不稳定的
2.时间复杂性比较
插入排序、冒泡排序、选择排序的时间复杂性为O(n2)
其它非线形排序的时间复杂性为O(nlog2n)
线形排序的时间复杂性为O(n);
3.辅助空间的比较
线形排序、二路归并排序的辅助空间为O(n)；
其它排序的辅助空间为O(1);
4.其它比较
*插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度，但是在这种情况下，快速排序反而慢了。
*当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
*若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
*当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
*当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下宜用归并排序。
*当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
常见的排序算法：
选择排序
public class SelectionSort {
public void selectionSort(int[] array) {
int temp;
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j <= array.length - 1; j++) {
if (array[i] > array[j]) {
// 注意和冒泡排序的区别，这里是i和j比较。
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
} // 打印每趟排序结果
for (int m = 0; m <= array.length - 1; m++) {
System.out.print(array[m] + "\t");
}
System.out.println();
}
}
public static void main(String[] args) {
SelectionSort selectionSort = new SelectionSort();
int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
selectionSort.selectionSort(array);
for (int m = 0; m <= array.length - 1; m++) {
System.out.print(array[m] + "\t");
}
}
}插入排序
public class InsertSort {
public void insertSort(int[] array, int first, int last) {
int temp, i, j;
for (i = first + 1; i <= last - 1; i++) {
temp = array[i];
j = i - 1;
while (j >= first && array[j] > temp) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp; // 打印每次排序结果
for (int m = 0; m <= array.length - 1; m++) {
System.out.print(array[m] + "\t");
}
System.out.println();
}
}
public static void main(String[] args) {
InsertSort insertSort = new InsertSort();
int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
insertSort.insertSort(array, 0, array.length);
for (int i = 0; i <= array.length - 1; i++) {
System.out.print(array[i] + "\t");
}
}
}快速排序
public class QuickSort {
public int partition(int[] sortArray, int low, int height) {
int key = sortArray[low];
while (low < height) {
while (low < height && sortArray[height] >= key)
height--;
sortArray[low] = sortArray[height];
while (low < height && sortArray[low] <= key)
low++;
sortArray[height] = sortArray[low];
}
sortArray[low] = key; // 打印每次排序结果
for (int i = 0; i <= sortArray.length - 1; i++) {
System.out.print(sortArray[i] + "\t");
}
System.out.println();
return low;
}
public void sort(int[] sortArray, int low, int height) {
if (low < height) {
int result = partition(sortArray, low, height);
sort(sortArray, low, result - 1);
sort(sortArray, result + 1, height);
}
}
public static void main(String[] args) {
QuickSort quickSort = new QuickSort();
int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
for (int i = 0; i <= array.length - 1; i++) {
System.out.print(array[i] + "\t");
}
System.out.println();
quickSort.sort(array, 0, 8);
for (int i = 0; i <= array.length - 1; i++) {
System.out.print(array[i] + "\t");
}
}
}希尔排序
public class ShellSort {
public void shellSort(int[] array, int n) {
int i, j, gap;
int temp;
for (gap = n / 2; gap > 0; gap /= 2) {
for (i = gap; i < n; i++) {
for (j = i - gap; j >= 0 && array[j] > array[j + gap]; j -= gap) {
temp = array[j];
array[j] = array[j + gap];
array[j + gap] = temp;
} // 打印每趟排序结果
for (int m = 0; m <= array.length - 1; m++) {
System.out.print(array[m] + "\t");
}
System.out.println();
}
}
}
public static void main(String[] args) {
ShellSort shellSort = new ShellSort();
int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
shellSort.shellSort(array, array.length);
for (int m = 0; m <= array.length - 1; m++) {
System.out.print(array[m] + "\t");
}
}
}就先列到这里了，谁还有其他算法的示例或者有这些算法的其他更优解，欢迎留言讨论！
以上是关于Java面试题-算法篇十七的主要内容，如果未能解决你的问题，请参考以下文章