笔试题目练习

最新推荐文章于 2022-01-23 17:19:32 发布
最新推荐文章于 2022-01-23 17:19:32 发布
阅读量628 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d8282048/article/details/11124523
版权

 1、一个单词单词字母交换，可得另一个单词，如army->mary，成为兄弟单词。提供一个单词，在字典中找到它的兄弟。描述数据结构和查询过程。评点：同去年9月份的一道题，见此文第3题：http://blog.csdn.net/v_july_v/article/details/6803368。

统计每个字母出现的次数

4、算法题1
一个url指向的页面里面有另一个url,最终有一个url指向之前出现过的url或空，这两种情形都定义为null。这样构成一个单链表。给两条这样单链表，判断里面是否存在同样的url。url以亿级计，资源不足以hash。

环？

5、算法题2

数组al[0,mid-1] 和 al[mid,num-1]，都分别有序。将其merge成有序数组al[0,num-1]，要求空间复杂度O(1)

插入排序


 1、删除字符串开始及末尾的空白符，并且把数组中间的多个空格（如果有）符转化为1个。

package com.duoduo.test;

public class StringFilterBlank {
	public static String filter(String a) {
		if (a == null || a.equals("")) {
			return a;
		}
		int N = a.length();
		int M = 0;
		char[] str = a.toCharArray();
		// step 1：统计去白后的字符串长度M
		int head = 0, tail = N - 1;
		while (head < N && str[head] == ' ') {
			head++;
		}
		while (tail >= 0 && str[tail] == ' ') {
			tail--;
		}
		for (int i = head; i <= tail; i++) {
			if (str[i] != ' ') {
				M++;
			} else if (str[i - 1] != ' ') {
				M++;
			}
		}
		if (M == 0) {
			return "";
		}
		// StdOut.println(M + " N: " + N + " head: " + head + " tail:" + tail);
		// 第二部 将空白除去
		int index = 0;

		while (index < M) {
			if (str[head] != ' ') {
				str[index++] = str[head++];
			} else {
				if (str[head - 1] != ' ') {
					str[index++] = str[head++];
				} else {
					head++;
				}
			}
		}

		return new String(str, 0, M);
	}

	public static void main(String args[]) {
		String[] TEST = new String[] { "abc dae bc ", "   abc dae bc ",
				"  abc  dae bc ", "  abc  dae   bc  ",
				"  a b c  d a e   b c  ", "", "  ", "         a", "b        " };
		for (String str : TEST) {
			System.out.println(filter(str));
		}
	}
}



找出两个单链表里交叉的第一个元素 

问题1：如何判断俩单链表（俩单链中均无环）是否交叉？
第一条链遍历至尾部，记此结点指针为p1；第二条链也遍历至尾部，此记结点指针为p2。则若此时p1与p2相等，俩单链交叉。

问题2：如果交叉，如何找到交叉点？
 若较长链表为head1。设两指针p1和p2分别对链表head1和head2从头遍历，步长均为1，让p1先移动nLen1 - nLen2步，再让p1和p2同时移动，则p1与p2相遇处即为交叉点处。


 9、字符串移动（字符串为*号和26个字母的任意组合，把*号都移动到最左侧，把字母移到最右侧并保持相对顺序不变），要求时间和空间复杂度最小

 从后向前遍历：

step 1、head记录星星的个数,如果为*则head++，否则a[i+head] = a[i]

step 2、将0~head位置赋值为*

http://blog.csdn.net/cxllyg/article/details/7985681

 10、时间复杂度为O(1)，怎么找出一个栈里的最大元素   

辅助栈如图


2、线程和进程区别和联系。什么是“线程安全”

http://blog.csdn.net/gaopo_y/article/details/8080987

判断一个数字序列是BST(binary search tree)后序遍历的结果，现场写代码。

http://blog.csdn.net/hopeztm/article/category/1201028

2. 给出大小为N的数组，用最快的办法找出前M个大的数字

package com.duoduo.test;

import java.util.PriorityQueue;


public class QueueTest {
	public static void main(String args[]) {
		PriorityQueue<Integer> queue = new PriorityQueue<Integer>();
		int[] S = new int[] { 2, 1, 4, 5, 7, 11, 2, 1, 5, 7, 8, 3, 5, 7, 8, 3,
				2, 6 };
		int M = 10;
		int index = 0;
		while (index < M) {
			queue.add(S[index++]);
		}
		
		while (index < S.length) {
			if (queue.peek() < S[index]) {
				queue.remove();
				queue.add(S[index]);
			}
			index++;
		}
		System.out.println(queue);
		for (int i = 0; i < M; i++) {
			System.out.print(queue.poll() + " ");
		}
	}
}

活动安排问题（贪心算法）

http://blog.csdn.net/a9529lty/article/details/4042019


1. 数组乘积
输入： 一个长度为n的整数数组input
输出： 一个长度为n的数组result，满足result[i] = input数组中，除了input[i] 之外的所有数的乘积，不用考虑溢出
例如 input
{2, 3, 4, 5}
output:
{60, 40, 30, 24} 
package com.duoduo.test;

public class MulLR {
	public static void main(String[] args) {
		int[] a = { 2, 3, 4, 5 };
		int N = a.length;
		int[] r = new int[N];
		int left, right;
		for (int i = 0; i < N; i++) {
			left = right = 1;
			for (int j = 0; j < i; j++) {
				left *= a[j];
			}
			for (int j = N - 1; j > i; j--) {
				right *= a[j];
			}
			r[i] = left * right;
		}
		for (int i = 0; i < N; i++) {
			System.out.print(r[i] + " ");
		}
	}
}


3. 朋友圈
假如已知有n个人和m对好友关系，如果两个人是直接或者间接有好友关系，则认为他们属于同一个朋友圈。写程序判断里面有多少朋友圈。
例如 
n = 5, m = 3  r = {(1,2), (2, 3), (4, 5)}  1 2 3 是一个朋友圈， 4 5 是一个朋友圈。
所以输出是2. 
无向图的连同问题（深度优先） 
package com.duoduo.test;

import java.util.LinkedList;
import java.util.Queue;

public class GraphTest {
	private class Graph {
		private int V;
		private int E;
		private LinkedList<Integer>[] adj;

		public Graph(int V) {
			this.V = V;
			this.E = 0;
			adj = (LinkedList<Integer>[]) new LinkedList[V];
			for (int v = 0; v < V; v++) {
				adj[v] = new LinkedList<Integer>();
			}
		}

		public void addEdge(int v, int w) {
			E++;
			adj[v].add(w);
			adj[w].add(v);
		}

		public Iterable<Integer> adj(int v) {
			return adj[v];
		}

		public String toString() {
			StringBuilder s = new StringBuilder();
			String NEWLINE = System.getProperty("line.separator");
			s.append(V + " vertices, " + E + " edges " + NEWLINE);
			for (int v = 0; v < V; v++) {
				s.append(v + ": ");
				for (int w : adj[v]) {
					s.append(w + " ");
				}
				s.append(NEWLINE);
			}
			return s.toString();
		}
	}

	private int count;

	private boolean[] marked;
	private int[] id;
	private Graph G;

	public GraphTest(int V, int[][] edges) {
		this.marked = new boolean[V];
		this.id = new int[V];
		this.G = new Graph(V);
		for (int[] edge : edges) {
			this.G.addEdge(edge[0] - 1, edge[1] - 1);
		}
		for (int v = 0; v < V; v++) {
			if (!marked[v]) {
				dfs(v);
				count++;
			}
		}

	}

	private void dfs(int v) {
		marked[v] = true;
		id[v] = count;
		for (int w : this.G.adj(v)) {
			if (!marked[w]) {
				dfs(w);
			}
		}
	}

	public boolean connected(int v, int w) {
		return id[v] == id[w];
	}

	public Graph G() {
		return this.G;
	}

	public int count() {
		return count;
	}

	public static void main(String[] args) {
		int V = 5;
		int[][] edges = { { 1, 2 }, { 2, 3 }, { 4, 5 }, { 3, 4 } };
		GraphTest gt = new GraphTest(V, edges);
		System.out.println(gt.G());
		System.out.println(gt.count());
	}
}

9月19日，创新工厂笔试题：
给定一整型数组，若数组中某个下标值大的元素值小于某个下标值比它小的元素值，称这是一个反序。
即：数组a[]; 对于i < j 且 a[i] > a[j],则称这是一个反序。
 给定一个数组，要求写一个函数，计算出这个数组里所有反序的个数。
归并排序 
package com.duoduo.test;

public class NiXu {
	private static int[] aux;
	private static int count;

	private NiXu() {
	}

	public static int count() {
		return count;
	}

	public static void sort(int[] a) {
		aux = new int[a.length];
		count = 0;
		sort(a, 0, a.length - 1);
	}

	private static void sort(int[] a, int lo, int hi) {
		if (lo < hi) {
			int mid = lo + (hi - lo) / 2;
			sort(a, lo, mid);
			sort(a, mid + 1, hi);
			if (a[mid] > a[mid + 1]) {
				merge(a, lo, mid, hi);
			}
		}
	}

	// lo ~ mid 应为 小序列，如果mid~hi
	//以下为引用网上一哥们的解释：
	// 举个例子，原序列是9 10 2 4 3
	// 最后要合并的两个左右序列是2 9 10 和 3 4
	// 刚开始a[i]=2 a[j] = 3，a[i]<a[j]不存在逆序对，将i++,a[i]->9
	// 这时候a[i]>a[j],存在逆序对，并且前一个序列中a[i+1...mid]因为是已经排序的，
	// 后面的每个数肯定也大于a[i],当然也大于a[j],当然也和a[j]成逆序对，这时候的逆序对的个数应该为mid-i+1
	private static void merge(int[] a, int lo, int mid, int hi) {
		for (int k = lo; k <= hi; k++) {
			aux[k] = a[k];
		}
		int i = lo;
		int j = mid + 1;
		int k = lo;
		while (i <= mid && j <= hi) {
			if (aux[i] <= aux[j]) {
				a[k++] = aux[i++];
			} else {
				count += (mid - i + 1);
				a[k++] = aux[j++];
			}
		}
		while (i <= mid) {
			a[k++] = aux[i++];
		}
		while (j <= hi) {
			a[k++] = aux[j++];
		}
	}

	public static void main(String[] args) {
		int[] a = { 9, 10, 2, 4, 3 };
		sort(a);
		System.out.println(count());
		for (int i : a) {
			System.out.print(i + " ");
		}
	}

}

9月20日，创新工厂南京站笔试：
已知字符串里的字符是互不相同的，现在任意组合，比如ab，则输出aa，ab，ba，bb，编程按照字典序输出所有的组合。
全排列 
mport java.util.Arrays;

public class QP {
	private char[] a;
	private int N;
	private char[] b;

	public QP(String str) {
		a = str.toCharArray();
		b = new char[a.length];
		N = a.length;
		Arrays.sort(a);
		perm(0);
	}

	private void perm(int pos) {
		if (pos == N) {
			print(b);
		} else {
			for (int i = 0; i < N; i++) {
				b[pos] = a[i];
				perm(pos + 1);
			}
		}
	}

	private void print(char[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]);
		}
		System.out.println();
	}

	public static void main(String[] args) {
		QP qp = new QP("abc");
	}
}


栈即可解决

package com.duoduo.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.Map.Entry;

public class KuHao {
	private final static Map<Character, Character> map;
	private final static Map<Character, Character> reverse_map;
	static {
		map = new HashMap<Character, Character>();
		reverse_map = new HashMap<Character, Character>();
		map.put(')', '(');
		map.put(']', '[');
		map.put('}', '{');
		Iterator<Entry<Character, Character>> iter = map.entrySet().iterator();
		while (iter.hasNext()) {
			Entry<Character, Character> entry = iter.next();
			reverse_map.put(entry.getValue(), entry.getKey());
		}
	}

	public static boolean isValidSeq(String input) {
		Stack<Character> stack = new Stack<Character>();
		int N = input.length();
		for (int i = 0; i < N; i++) {
			char ch = input.charAt(i);
			// ch 为左括号的话直接入栈
			if (!map.containsKey(ch)) {
				stack.push(ch);
			} else {
				if (stack.size() == 0) {
					return false;
				}
				if (map.get(ch) != stack.pop()) {
					return false;
				}
			}
		}
		if (stack.size() > 0) {
			return false;
		}
		return true;
	}

	public static String fixSeq(String input) {
		if (isValidSeq(input)) {
			return input;
		}
		Stack<Character> stack = new Stack<Character>();
		List<Character> result = new ArrayList<Character>();
		int N = input.length();
		for (int i = 0; i < N; i++) {
			char ch = input.charAt(i);
			// ch 为左括号的话直接入栈,加入结果集
			if (!map.containsKey(ch)) {
				stack.push(ch);
				result.add(ch);
			} else {
				// 如果栈为空，则将对应的左括号和右括号加入结果集
				if (stack.size() == 0) {
					result.add(map.get(ch));
					result.add(ch);
					continue;
				} else {
					// 如果栈不为空，并且不匹配，则找到左括号然后将ch加进去
					if (map.get(ch) != stack.peek()) {
						result.add(map.get(ch));
						result.add(ch);
					} else {
						// 匹配直接加入右括号
						stack.pop();
						result.add(ch);
					}
				}

			}
		}
		while (!stack.isEmpty()) {
			result.add(reverse_map.get(stack.pop()));
		}
		int M = result.size();
		char[] r = new char[M];
		for (int i = 0; i < M; i++) {
			r[i] = result.get(i);
		}
		return new String(r);

	}

	public static void main(String[] args) {
		String[] test = { "{}", "{{}", "{[]}", "{[{({})}]}", "{[]]}", "]]}"

		};
		for (String str : test) {
			System.out.println(isValidSeq(str));
			System.out.println(fixSeq(str));
			System.out.println(" == ");
		}

	}
}


死锁

死锁的四个必要条件

互斥条件（Mutual exclusion）：资源不能被共享，只能由一个进程使用。
请求与保持条件（Hold and wait）：已经得到资源的进程可以再次申请新的资源。
非剥夺条件（No pre-emption）：已经分配的资源不能从相应的进程中被强制地剥夺。
循环等待条件（Circular wait）：系统中若干进程组成环路，改环路中每个进程都在等待相邻进程正占用的资源。

http://blog.csdn.net/wlq1983/article/details/3022157

d8282048
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
sql练习题目
11-14
sql练习题目， 比较不错，面试前可以参考
基础数据结构和算法十四：Directed Graphs
George's dev dream port
12-15 877
  In directed graphs, edges are one-way: the pair of vertices that defines each edge is an ordered pair that specifies a one-way adjacency. Many applications (for example, graphs that represent the ...
算法（第4版） Chapter 4.1 无向图
weixin_33738555的博客
01-15 181
Algorithms Fourth EditionWritten By Robert Sedgewick & Kevin WayneTranslated By 谢路云Chapter 4 Section 1 无向图 以下内容修改自http://www.cnblogs.com/skyivb...http://www.cnblogs....
算法7-2：图论接口
白色咖啡
06-17 1117
本节介绍如何在程序中表示一张图。 顶点 在程序中，顶点用整数表示就可以了。因为整数可以作为数组的下标，也可以作为哈希表的键。所以用整数是最方便的。 当然，在一张图中可能会出现一些异常情况，比如自己连接自己，两个顶点之间存在多个边。这些异常情况也是要考虑的。 接口 为了表示一张图，就要创建专
用邻接表实现无向图
正在路上的专栏
02-20 1205
import java.util.LinkedList; /** * 用邻接表(其实就是前面博客实现的哈希表)实现无向图 * @author xxxu * */ public class Graph { private final int V;//顶点数目 private int E; //边的数目 private LinkedList[] adj; //邻接表(其实就是前面
图类算法总结
weixin_33743661的博客
08-17 172
在開始各类图算法之前，先将图的结构进行分类。 图的表示，在实际实现过程中。有下面几种主要的方式能够来表示图。 1） 邻接矩阵：对于较小或者中等规模的图的构造较为适用。因为须要V*V大小的空间。 2） 边的数组：使用一个简单的自己定义edge类，还有两个变量，分别代表边的两个端点编号，实现简单，可是在求每一个点的邻接点的时候实现较为困难。 3） 邻接表数组：较为经常...
100条经典C语言笔试题目.rar
02-17
适合大一入门C语言的题目，适合刚学C语言的小白，资源包含C语言各个模块的经典练习题，可以查漏补缺，巩固基础
三星电子GSAT题目类型练习
03-23
网上找到的三星电子GSAT笔试题类型介绍，有一些例题及答案。只是资料题目是英文的，南京的考的是中文。
Python面试练习题目 Python面试题进阶版 Python笔试题目整理归纳 共7页.pdf
06-17
Python面试练习题目 Python面试题进阶版 Python笔试题目整理归纳 目录 Python面试题 1 1 基础面试 2 1.1 Python如何实现单例模式？ 2 1.2 什么是lambda函数？ 2 1.3 Python是如何进行类型转换的？ 3 1.4 Python如何...
2024年米哈游笔试题目.zip米哈游笔试题目### 内容概要 本博客为初学者提供了一个关于2024年米哈游笔试题目的全面指南
最新发布
03-10
米哈游笔试题目### 内容概要 本博客为初学者提供了一个关于2024年米哈游笔试题目的全面指南。从米哈游的简介开始，逐步介绍了笔试题目的类型，包括编程题和数据结构与算法题。博客还提供了准备建议，如学习编程语言...
算法第四版4.1-无向图详解
weixin_34107955的博客
03-24 703
四种重要的图模型： 无向图（简单连接） 有向图（连接有方向性） 加权图（连接带有权值） 加权有向图（连接既有方向性又带有权值） 无向图 定义：由一组顶点和一组能够将两个顶点相连的边组成。 特殊：自环（一条连接一个顶点和其自身的边）；平行边（连接同一对顶点的两条边） 数学家将含有平行边的图称为多重图；将没有平行边或自环的图...
图--有向图
点滴文字，记录成长
03-26 266
有向图由一组顶点和一组有方向的边组成 有向图的API public class Digraph - Graph(int v) Graph(In in) int V() 顶点数 int E() 边数 void addEdge(int v, int w) 添加边v-w Iterable adj(int v) 和v相
java语言程序设计第二十章部分答案1，4，11，14，16题
weixin_42822658的博客
08-24 1869
1. public class Test2001 { public static void main(String[] args) throws FileNotFoundException { File file=new File(“D:\1code\test.txt”); Scanner input=new Scanner(file); ...
六十六.广度优先搜索C语言实现(无向图)
JiangYu200015的博客
10-03 423
#include<stdio.h> int main() { int i,j,n,m,a,b,cur,book[101]= {0},e[101][101]; int que[10001],head,tail; scanf("%d %d",&n,&m); //初始化二维矩阵 for(i=1;i<=n;i++) for(j=1;j<=m;j++) if(i==j) e[i][j] = 0
算法4第4章无向图/拓扑排序讲解
cyj88jyc的专栏
06-16 3029
//有向图由一组顶点和一组有方向的边组成，每条有方向的边连接着一对有序顶点示意图如下 //在一副有向图中，一个顶点的出度为该顶点指出的边的总数，入度为指向该顶点边的总数 //有向边的实现和无向边类似，只是在添加边时是有方向的，代码实现如下 import java.util.NoSuchElementException; import StdLib.In; import StdLib.StdO...
【程序填空题】查最贵的书和最便宜的书。【问题描述】编写程序，从键盘输入n（n＜10）种书的名称和定价并存入结构体数组中，从中查找定价最高及最低的书名和定价，并输出。【输入形式】先输入书
baiseyema的博客
01-23 3866
【程序填空题】查最贵的书和最便宜的书。 【问题描述】 编写程序，从键盘输入n（n<10）种书的名称和定价并存入结构体数组中，从中查找定价最高及最低的书名和定价，并输出。 【输入形式】 先输入书总数n（整型，n<10），再依次输入每种书的名称（字符串）和定价。 【输出形式】 输出定价最高及最低的书名和定价。 【样例输入】（下画线部分表示输入） Input n:3 Input the name,price of the 1 book:C 21.5 Input the name,p
小米面试题 朋友圈 并查集
miao6664659的专栏
12-07 2799
http://blog.csdn.net/w397090770/article/details/8032898#comments 以下是我自己的解法：以后如果有新的解法会持续更新的   首先给出一个我的自己的结构，没有按照题目的接口，之后按照题目的接口，能够写出来效率更加高的算法。 首先贴出如下代码： #define N 5 int Edge[N][N]; int set[N]; v
[LeetCode]-Python刷题第二周（链表）
就是这个七昂的博客
03-06 3097
4.Median of Two Sorted Arrays 求两个有序数组的中位数（Hard） There are two sorted arraysnums1andnums2of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity s...
哔哩哔哩服务端开发笔试题目
08-30
对于哔哩哔哩服务端开发的笔试题目，根据引用的内容，可以考虑学习《Essential C》，这是一本关于C编程的书籍，可以帮助你掌握C语言的基础知识和常用编程技巧。此外，还可以关注黑马C的教学视频，这是一个包含314个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值