OPPO面试和恒生电子笔试20190317

记录今天面试oppo和笔试恒生电子的总结

oppo面试题

1. 进程和线程的区别
   答：进程是操作系统进行资源分配和管理的基本单位，而线程是进程下具体执行的最小基本单元，一个进程可以有多个线程。
   补：线程是CPU调度的基本单元，一个进程至少有一个线程，且多个线程共享进程的资源，进程的销毁会导致该进程下的所有线程同时销毁，而线程的结束不会影响进程。线程创建和销毁的时间比进程少，操作系统的所有执行功能都需要创建线程去完成。进程的创建依靠fork或者vfork，而线程的创建依靠pthread_create。

2. TCP/IP协议的五层网络模型？TCP工作在哪一层?TCP和UDP的区别？TCP建立连接的方法？HTTP工作在哪一层？
   答：物理层，数据链路层，网络层，传输层，应用层。传输层。一个是可靠传输一个不可靠。三次握手。应用层。
   补：TCP协议通过三次握手建立连接，且通过校验机制，拥塞控制等来保证可靠交付，无乱序，不重复，无丢失，是面向连接的传输。但同时资源要求较高，时效性不高，工作效率不高，控制机制较多容易被利用因此安全性不及UDP。

3. 快速排序的代码实现

import java.util.Arrays;

public class quickSort {
	public static void main(String[] args) {
		int[] arr = new int[] {5,32,21,14,4,3,12,7,9,34,12};
		QuickSort(arr,0, arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	public static void QuickSort(int[] arr,int begin,int end) {
		if(begin<end) {
			//标记出事下标
			int low = begin;
			int high = end;
			//规定基准值
			int stand = arr[begin];
			
			while(low<high) {
				while(low<high&&arr[high]>=stand) {
					high--;
				}arr[low]=arr[high];
				while(low<high&&arr[low]<=stand) {
					low++;
				}arr[high]=arr[low];
			}
			arr[high]=stand;
			QuickSort(arr, begin, low);
			QuickSort(arr, low+1, end);
		}

4. list 和set的区别
   答：list和set同为集合类两者都有数组实现，其中list有序可重复，set中的数据无需不可重复。
   补：继承了Collection接口。

5. 面向对象和面向过程的区别
   答：面向过程是把问题分解成一个个步骤，利用相应的函数来一步步解决问题，而面向对象则把每一个步骤的属性封装成一个个类来组合解决问题。
   补：对每一步骤进行相应的抽象，形成对象，通过不同对象间的调用，组合解决问题。把属性和行为封装成对象，基于对象及对象的能力来进行业务逻辑的实现。

恒生电子笔试题

递归遍历二叉树

public class TestBinaryTree {
	public static void main(String[] args) {
		//创建树对象
		BinaryTree Btree = new BinaryTree();
		//创建根节点对象
		TreeNode root = new TreeNode(1);
		//将创建的根节点赋值树对象
		Btree.setRoot(root);
		//为根节点创建左右节点，先创建，在赋值
		TreeNode lNode = new TreeNode(2);
		root.setLeftNode(lNode);

		//赋值给根节点
		TreeNode rNode = new TreeNode(3);
		root.setRightNode(rNode);
		
		lNode.setLeftNode(new TreeNode(4));
		lNode.setRightNode(new TreeNode(5));
		
		rNode.setLeftNode(new TreeNode(6));
		rNode.setRightNode(new TreeNode(7));
		
		Btree.frontshow();
		System.out.println();
		Btree.midshow();
		System.out.println();
		Btree.lastshow();
	}
}
class BinaryTree {
	//设定成员
	TreeNode root;
	//构造方法
	public BinaryTree() {
		
	}
	//set方法
	public void setRoot(TreeNode root) {
		this.root = root;
	}
	public TreeNode getRoot() {
		return root;
	}
	public void frontshow() {
		root.frontshow();
		
	}
	public void midshow() {
		root.midshow();
	}
	public void lastshow() {
		root.lastshow();
	}
}
class TreeNode {
	//成员变量
		int value;
		//构造方法
		TreeNode leftNode;
		TreeNode rightNode;
		public TreeNode(int value) {
			this.value = value;
		}
		//set方法
		public void setLeftNode(TreeNode leftNode) {
			this.leftNode = leftNode;
		}
		public void setRightNode(TreeNode rightNode) {
			this.rightNode = rightNode;
		}
		//前序遍历
		public void frontshow() {
			System.out.print(value+"\t");
			if(leftNode!= null) {
				leftNode.frontshow();//形成递归
			}
			if(rightNode!=null) {
				rightNode.frontshow();
			}
			
		}
		//中序遍历
		public void midshow() {
			if(leftNode!=null) {
				leftNode.midshow();
			}
			System.out.print(value+"\t");
			if(rightNode!=null) {
				rightNode.midshow();
			}
		}
		//后序遍历
		public void lastshow() {
			if(leftNode!=null) {
				leftNode.lastshow();
				
			}
			if(rightNode!=null) {
				rightNode.lastshow();
			}
			System.out.print(value+"\t");
		}
	}

输出结果:

1	2	4	5	3	6	7	
4	2	5	1	6	3	7	
4	5	2	6	7	3	1