`
zpball
  • 浏览: 919656 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java面试中经常问到的算法题

算法面试JavaJ# 
阅读更多
从大学到现在，参加过很多面试，经常会被问到一些基本的算法题，而大部分算法的理论及思想，我们曾经都能倒背如流，并且也用语言实现过，可由于在项目开发中应用的比较少，久而久之就忘记了，造成在面试中很尴尬的局面，然后回来查阅相关资料才发现就那么一回事，怎么在面试中就卡壳了呢？在此写下我在面试中经常被问到的一些基本的算法，全当复习。

一、冒泡排序 


1.package sort.bubble;   
2.  
3.import java.util.Random;   
4./**  
5. * 依次比较相邻的两个数，将小数放在前面，大数放在后面  
6. * 冒泡排序，具有稳定性  
7. * 时间复杂度为O（n^2）  
8. * 不及堆排序，快速排序O（nlogn，底数为2）  
9. * @author liangge  
10. *  
11. */  
12.public class Main {   
13.    public static void main(String[] args) {   
14.        Random ran = new Random();   
15.        int[] sort = new int[10];   
16.        for(int i = 0 ; i < 10 ; i++){   
17.            sort[i] = ran.nextInt(50);   
18.        }   
19.        System.out.print("排序前的数组为");   
20.        for(int i : sort){   
21.            System.out.print(i+" ");   
22.        }   
23.        buddleSort(sort);   
24.        System.out.println();   
25.        System.out.print("排序后的数组为");   
26.        for(int i : sort){   
27.            System.out.print(i+" ");   
28.        }   
29.    }   
30.       
31.    /**  
32.     * 冒泡排序  
33.     * @param sort  
34.     */  
35.    private static void buddleSort(int[] sort){   
36.        for(int i=1;i<sort.length;i++){   
37.            for(int j=0;j<sort.length-i;j++){   
38.                if(sort[j]>sort[j+1]){   
39.                    int temp = sort[j+1];   
40.                    sort[j+1] = sort[j];   
41.                    sort[j] = temp;   
42.                }   
43.            }   
44.        }   
45.    }   
46.}  
package sort.bubble;

import java.util.Random;
/**
 * 依次比较相邻的两个数，将小数放在前面，大数放在后面
 * 冒泡排序，具有稳定性
 * 时间复杂度为O（n^2）
 * 不及堆排序，快速排序O（nlogn，底数为2）
 * @author liangge
 *
 */
public class Main {
	public static void main(String[] args) {
		Random ran = new Random();
		int[] sort = new int[10];
		for(int i = 0 ; i < 10 ; i++){
			sort[i] = ran.nextInt(50);
		}
		System.out.print("排序前的数组为");
		for(int i : sort){
			System.out.print(i+" ");
		}
		buddleSort(sort);
		System.out.println();
		System.out.print("排序后的数组为");
		for(int i : sort){
			System.out.print(i+" ");
		}
	}
	
	/**
	 * 冒泡排序
	 * @param sort
	 */
	private static void buddleSort(int[] sort){
		for(int i=1;i<sort.length;i++){
			for(int j=0;j<sort.length-i;j++){
				if(sort[j]>sort[j+1]){
					int temp = sort[j+1];
					sort[j+1] = sort[j];
					sort[j] = temp;
				}
			}
		}
	}
}



二、选择排序 

1.package sort.select;   
2.  
3.import java.util.Random;   
4.  
5./**  
6. * 选择排序  
7. * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，  
8. * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。   
9. * 选择排序是不稳定的排序方法。  
10. * @author liangge  
11. *   
12. */  
13.public class Main {   
14.    public static void main(String[] args) {   
15.        Random ran = new Random();   
16.        int[] sort = new int[10];   
17.        for (int i = 0; i < 10; i++) {   
18.            sort[i] = ran.nextInt(50);   
19.        }   
20.        System.out.print("排序前的数组为");   
21.        for (int i : sort) {   
22.            System.out.print(i + " ");   
23.        }   
24.        selectSort(sort);   
25.        System.out.println();   
26.        System.out.print("排序后的数组为");   
27.        for (int i : sort) {   
28.            System.out.print(i + " ");   
29.        }   
30.    }   
31.  
32.    /**  
33.     * 选择排序  
34.     * @param sort  
35.     */  
36.    private static void selectSort(int[] sort){   
37.        for(int i =0;i<sort.length-1;i++){   
38.            for(int j = i+1;j<sort.length;j++){   
39.                if(sort[j]<sort[i]){   
40.                    int temp = sort[j];   
41.                    sort[j] = sort[i];   
42.                    sort[i] = temp;   
43.                }   
44.            }   
45.        }   
46.    }   
47.}  
package sort.select;

import java.util.Random;

/**
 * 选择排序
 * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
 * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 
 * 选择排序是不稳定的排序方法。
 * @author liangge
 * 
 */
public class Main {
	public static void main(String[] args) {
		Random ran = new Random();
		int[] sort = new int[10];
		for (int i = 0; i < 10; i++) {
			sort[i] = ran.nextInt(50);
		}
		System.out.print("排序前的数组为");
		for (int i : sort) {
			System.out.print(i + " ");
		}
		selectSort(sort);
		System.out.println();
		System.out.print("排序后的数组为");
		for (int i : sort) {
			System.out.print(i + " ");
		}
	}

	/**
	 * 选择排序
	 * @param sort
	 */
	private static void selectSort(int[] sort){
		for(int i =0;i<sort.length-1;i++){
			for(int j = i+1;j<sort.length;j++){
				if(sort[j]<sort[i]){
					int temp = sort[j];
					sort[j] = sort[i];
					sort[i] = temp;
				}
			}
		}
	}
}


三、快速排序 


1.package sort.quick;   
2.  
3./**  
4. * 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，  
5. * 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。  
6. * @author liangge  
7. *   
8. */  
9.public class Main {   
10.    public static void main(String[] args) {   
11.        int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };   
12.        System.out.print("排序前的数组为：");   
13.        for (int data : sort) {   
14.            System.out.print(data + " ");   
15.        }   
16.        System.out.println();   
17.        quickSort(sort, 0, sort.length - 1);   
18.        System.out.print("排序后的数组为：");   
19.        for (int data : sort) {   
20.            System.out.print(data + " ");   
21.        }   
22.    }   
23.  
24.    /**  
25.     * 快速排序  
26.     * @param sort 要排序的数组  
27.     * @param start 排序的开始座标  
28.     * @param end 排序的结束座标  
29.     */  
30.    public static void quickSort(int[] sort, int start, int end) {   
31.        // 设置关键数据key为要排序数组的第一个元素，   
32.        // 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小   
33.        int key = sort[start];   
34.        // 设置数组左边的索引，往右移动判断比key大的数   
35.        int i = start;   
36.        // 设置数组右边的索引，往左移动判断比key小的数   
37.        int j = end;   
38.        // 如果左边索引比右边索引小，则还有数据没有排序   
39.        while (i < j) {   
40.            while (sort[j] > key && j > start) {   
41.                j--;   
42.            }   
43.            while (sort[i] < key && i < end) {   
44.                i++;   
45.            }   
46.            if (i < j) {   
47.                int temp = sort[i];   
48.                sort[i] = sort[j];   
49.                sort[j] = temp;   
50.            }   
51.        }   
52.        // 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，   
53.        // 即保持了key左边的数比key小，key右边的数比key大   
54.        if (i > j) {   
55.            int temp = sort[j];   
56.            sort[j] = sort[start];   
57.            sort[start] = temp;   
58.        }   
59.        //递归调用   
60.        if (j > start && j < end) {   
61.            quickSort(sort, start, j - 1);   
62.            quickSort(sort, j + 1, end);   
63.        }   
64.    }   
65.}  
package sort.quick;

/**
 * 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，
 * 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 * @author liangge
 * 
 */
public class Main {
	public static void main(String[] args) {
		int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
		System.out.print("排序前的数组为：");
		for (int data : sort) {
			System.out.print(data + " ");
		}
		System.out.println();
		quickSort(sort, 0, sort.length - 1);
		System.out.print("排序后的数组为：");
		for (int data : sort) {
			System.out.print(data + " ");
		}
	}

	/**
	 * 快速排序
	 * @param sort 要排序的数组
	 * @param start 排序的开始座标
	 * @param end 排序的结束座标
	 */
	public static void quickSort(int[] sort, int start, int end) {
		// 设置关键数据key为要排序数组的第一个元素，
		// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
		int key = sort[start];
		// 设置数组左边的索引，往右移动判断比key大的数
		int i = start;
		// 设置数组右边的索引，往左移动判断比key小的数
		int j = end;
		// 如果左边索引比右边索引小，则还有数据没有排序
		while (i < j) {
			while (sort[j] > key && j > start) {
				j--;
			}
			while (sort[i] < key && i < end) {
				i++;
			}
			if (i < j) {
				int temp = sort[i];
				sort[i] = sort[j];
				sort[j] = temp;
			}
		}
		// 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，
		// 即保持了key左边的数比key小，key右边的数比key大
		if (i > j) {
			int temp = sort[j];
			sort[j] = sort[start];
			sort[start] = temp;
		}
		//递归调用
		if (j > start && j < end) {
			quickSort(sort, start, j - 1);
			quickSort(sort, j + 1, end);
		}
	}
}



四、插入排序

  
1.package sort.insert;   
2.  
3./**  
4. * 直接插入排序  
5. * 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据  
6. * 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。  
7. */  
8.import java.util.Random;   
9.  
10.public class DirectMain {   
11.    public static void main(String[] args) {   
12.        Random ran = new Random();   
13.        int[] sort = new int[10];   
14.        for (int i = 0; i < 10; i++) {   
15.            sort[i] = ran.nextInt(50);   
16.        }   
17.        System.out.print("排序前的数组为");   
18.        for (int i : sort) {   
19.            System.out.print(i + " ");   
20.        }   
21.        directInsertSort(sort);   
22.        System.out.println();   
23.        System.out.print("排序后的数组为");   
24.        for (int i : sort) {   
25.            System.out.print(i + " ");   
26.        }   
27.    }   
28.  
29.    /**  
30.     * 直接插入排序  
31.     *   
32.     * @param sort  
33.     */  
34.    private static void directInsertSort(int[] sort) {   
35.        for (int i = 1; i < sort.length; i++) {   
36.            int index = i - 1;   
37.            int temp = sort[i];   
38.            while (index >= 0 && sort[index] > temp) {   
39.                sort[index + 1] = sort[index];   
40.                index--;   
41.            }   
42.            sort[index + 1] = temp;   
43.  
44.        }   
45.    }   
46.}  
package sort.insert;

/**
 * 直接插入排序
 * 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
 * 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
 */
import java.util.Random;

public class DirectMain {
	public static void main(String[] args) {
		Random ran = new Random();
		int[] sort = new int[10];
		for (int i = 0; i < 10; i++) {
			sort[i] = ran.nextInt(50);
		}
		System.out.print("排序前的数组为");
		for (int i : sort) {
			System.out.print(i + " ");
		}
		directInsertSort(sort);
		System.out.println();
		System.out.print("排序后的数组为");
		for (int i : sort) {
			System.out.print(i + " ");
		}
	}

	/**
	 * 直接插入排序
	 * 
	 * @param sort
	 */
	private static void directInsertSort(int[] sort) {
		for (int i = 1; i < sort.length; i++) {
			int index = i - 1;
			int temp = sort[i];
			while (index >= 0 && sort[index] > temp) {
				sort[index + 1] = sort[index];
				index--;
			}
			sort[index + 1] = temp;

		}
	}
}



五、顺便贴个二分搜索法 


1.package search.binary;   
2.  
3.public class Main {   
4.    public static void main(String[] args) {   
5.        int[] sort = {1,2,3,4,5,6,7,8,9,10};   
6.        int mask = binarySearch(sort,6);   
7.        System.out.println(mask);   
8.           
9.    }   
10.       
11.       
12.    /**  
13.     * 二分搜索法，返回座标，不存在返回-1  
14.     * @param sort  
15.     * @return  
16.     */  
17.    private static int binarySearch(int[] sort,int data){   
18.        if(data<sort[0] || data>sort[sort.length-1]){   
19.            return -1;   
20.        }   
21.        int begin = 0;   
22.        int end = sort.length;   
23.        int mid = (begin+end)/2;   
24.        while(begin <= end){   
25.            mid = (begin+end)/2;   
26.            if(data > sort[mid]){   
27.                begin = mid + 1;   
28.            }else if(data < sort[mid]){   
29.                end = mid - 1;   
30.            }else{   
31.                return mid;   
32.            }   
33.        }   
34.        return -1;   
35.           
36.    }   
37.}
分享到：
| J2EE技术规范
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA经典算法面试39题及答案

    本文将详细探讨39道JAVA经典算法面试题目，每题都附带答案和解析，从而帮助读者深入理解并提升自身在JAVA编程中的算法应用能力。 首先，我们必须明确算法的定义和重要性。算法是计算机科学的核心，它是一系列解决...

    Java面试中经常问到的算法题.pdf

    Java面试中的算法题是考察开发者基础能力的重要环节，这些题目往往涉及到数据结构和算法的基本概念。以下是关于冒泡排序、选择排序和快速排序的详细解释： 1. **冒泡排序**： 冒泡排序是一种简单的排序算法，其核心...

    最全的Java面试题整理(含算法题)

    根据给定的信息，本文将对Java面试中常见的算法题进行详细的解析与总结，特别是针对冒泡排序和选择排序这两种基础但重要的排序算法。 ### 冒泡排序 #### 算法原理 冒泡排序是一种简单的排序算法。它重复地遍历要...

    10万字总结java面试题和答案(八股文之一)Java面试题指南

    Java中的IO与NIO面试题 Java反射面试题 Java序列化面试题 Java注解面试题 多线程&并发面试题 JVM面试题 Mysql面试题 Redis面试题 Memcached面试题 MongoDB面试题 Spring面试题 Spring Boot面试题 Spring Cloud面试题...

    最新Java面试题视频网盘，Java面试题84集、java面试专属及面试必问课程

    面试题包含了不同技术层面的面试问题,同时也能对一些没有面试开发经验的小白给予不可估量的包装, 让你的薪水绝对翻倍, 本人亲试有效.Java面试题84集、java面试专属及面试必问课程,所有的面试题有视屏讲解, 解答方案....

    JAVA经典算法40题面试题案例.pdf

    在Java面试中，算法题是考察候选人编程能力的重要环节。这里我们探讨三个常见的算法问题及其解决方案。 **问题1：斐波那契数列（Fibonacci Sequence）** 斐波那契数列是一个序列，其中每个数字是前两个数字的和。...

    JAVA数据结构和算法+面试题

    同时，《JAVA面试题》提供了真实的面试场景，让你提前熟悉可能遇到的问题，提高应试能力。 总之，Java数据结构和算法是开发者必备的技能，通过不断学习和练习，可以提升编程效率和代码质量，为职业发展打下坚实的...

    JAVA经典算法40面试题

    JAVA经典算法40面试题 本资源摘要信息涵盖了JAVA经典算法40面试题，包含基本的算法面试代码题。以下是对标题、描述、标签和部分内容的详细解释： 一、标题：“JAVA经典算法40面试题” 该标题表明该资源是关于JAVA...

    java面试题（算法+数据库）

    在Java面试中，面试官通常会考察候选人的算法基础以及数据库操作能力。这包括但不限于数据结构的理解、算法设计与分析、以及SQL的熟练运用。以下是相关知识点的详细介绍： 1. **算法基础**： - **古典算法**：包括...

    java笔试面试算法题

    在Java笔试面试中，算法题是考察候选者编程能力、逻辑思维和问题解决能力的关键环节。这些题目通常涵盖数据结构、排序、搜索、图论等多个领域，涉及到的基础知识包括但不限于以下内容： 1. **基础算法**：如冒泡...

    Java 算法与编程面试题

    【Java 算法与编程面试题】是针对求职者准备的一个重要环节，尤其是在IT行业中，熟练掌握算法和编程能力是必备技能。本题主要涵盖了两方面内容：身份证号码合法性验证以及两个文件中单词的交替合并。 首先，我们来...

    java经典算法90题含源码及答案.rar

    在JAVA经典算法40题.doc中，可能包含的题目类型有递归、分治、贪心、回溯、动态规划等。例如，经典的二分查找、快速排序、斐波那契数列、最小路径和等问题，都是锻炼算法思维的好例子。每道题目的解答通常会涉及到对...

    面试知识点总结--java笔试算法题及答案.pdf

    在 Java 中，字符串分割算法是非常常见的面试题之一。本文中提供了一个使用 StringTokenizer 类实现字符串分割的示例代码，然而，该方法已不再被推荐使用，取而代之的是使用 String 类的 split 方法，该方法更简洁、...

    最全的Java面试题整理(含算法题).pdf

    Java面试中的算法题是考察候选人在编程基础和问题解决能力上的重要环节。冒泡排序作为经典的基本排序算法，经常在面试中出现，因为它的逻辑相对简单，适合测试面试者的编程思维和对时间复杂度的理解。 冒泡排序的...

    Java面试题全集（上）（中）（下）合集

    这里我们将根据"Java面试题全集（上）（中）（下）合集"来探讨这些核心知识点。 1. **基础语法**：这部分通常考察Java的基本数据类型、变量、运算符、流程控制（if，switch，for，while，do...while）、方法的定义...

    java面试常遇到的算法

    以下是对给定文件中提及的几个经典算法题目的深入解析，旨在帮助准备Java面试的开发者们全面掌握相关知识点。 ### 1. 打印九九乘法表 在Java中实现九九乘法表的打印，主要涉及到嵌套循环的应用。代码示例中，外层...

    java面试题以及经典算法实现

    本资料集合了Java面试中常见的问题和经典算法的实现，旨在帮助应聘者提升自己的技能水平，顺利通过面试。 1. **Java基础知识** - **内存管理**：Java使用自动垃圾回收机制，理解如何分配、使用和回收内存是基础。...

    java面试题目 java面试最常问问题 java面试题集

    以下是一些Java面试中最常被问到的知识点，包括但不限于核心概念、数据结构与算法、多线程、集合框架、异常处理、IO流、网络编程以及设计模式等。 1. **核心概念**： - Java的特点：一次编写，到处运行（Write ...

Magicbox
Global site tag (gtag.js) - Google Analytics