# 几个面试经典算法题Java解答

## 题目一：

public class testClockwiseOutput {
//顺时针打印一个矩阵

@Test
public void test(){
int[][] num = new int[100][100];
int n = 6;
int count =1;

for(int i=0;i<n;i++){
for(int j =0;j<n;j++){
num[i][j]=count++;
}
}
output(num,0,n-1);
}

public void output(int[][] num,int start,int end){
if(start>end || end<=0)return;
for(int i=start;i<=end;i++){
System.out.println(num[start][i]);
}
for(int i=start+1;i<=end;i++){
System.out.println(num[i][end]);
}

for(int i=end-1;i>=start;i--){
System.out.println(num[end][i]);
}
for(int i=end-1;i>start;i--){
System.out.println(num[i][start]);
}

output(num,start+1,end-1);
}
}

## 题目二：

//给出一个排序好的数组和一个数，求数组中连续元素的和等于所给数的子数组

@Test
public void test(){
int[] num = {1,2,2,3,4,5,6,7,8,9};
int sum = 7;
findSum(num,sum);
}

public void findSum(int[] num,int sum){
int left=0;
int right=0;

for(int i=0;i<num.length;i++){
int curSum = 0;
left = i;
right = i;
while(curSum<sum){
curSum += num[right++];
}
if(curSum==sum){
for(int j=left;j<right;j++){
System.out.print(num[j]+" ");
}
System.out.println();
}
}
}

## 题目三：

//字符数组组成的所有字符串

@Test
public void test(){
//char[] cs = {'a','b','c','d','e'};
char[] cs = {'a','b','c'};
int length = cs.length;
recursionSwap(cs,0,length);
}

public void swap(char[] cs,int index1,int index2){
char temp = cs[index1];
cs[index1]=cs[index2];
cs[index2]=temp;
}

public void recursionSwap(char[] cs,int start,int length){
if(start>=length-1){
print(cs);
return;
}
for(int i=start;i<length;i++){
swap(cs,start,i);
recursionSwap(cs,start+1,length);
swap(cs,start,i);
}
}

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

## 题目四：

//数组组成的最小数

@Test
public void test(){
int[] num={1,5,9,13,442,44,6,21,211};
qsort(num,0,num.length-1);
System.out.println(Arrays.toString(num));
}

public void qsort(int[] num,int left,int right){
if(left<right){
int partition = partition(num,left,right);
qsort(num,left,partition-1);
qsort(num,partition+1,right);
}
}

public int partition(int[] num,int left,int right){
int partition = num[left];
while(left<right){
while((num[right]==partition || isMBigerThanN(num,num[right],partition)) && left<right){
right--;
}
swap(num,left,right);
while((num[left]==partition || isMBigerThanN(num,partition,num[left])) && left<right){
left++;
}
swap(num,left,right);
}

return left;
}

public void swap(int[] num,int m,int n){
int temp = num[m];
num[m]=num[n];
num[n]=temp;
}

public boolean isMBigerThanN(int[] num,int m,int n){
String num1 = String.valueOf(m);
String num2 = String.valueOf(n);

int temp1 = Integer.parseInt(num1+num2);
int temp2 = Integer.parseInt(num2+num1);

if(temp1>temp2){
return true;
}
else{
return false;
}
}

## 题目五：

//子数组最大和
@Test
public void test(){
int[] num = {1,-2,3,10,-4,7,2,-5};
//int[] num = {1,-2,3,10,-4,10,2,-5};
System.out.println(maxSum(num));
}

public int maxSum(int[] num){
int curSum = 0;
int curMaxSum = -99999999;
int start = 0;
int end = 0;

for(int i=0;i<num.length;i++){
if(curSum<=0){
curSum = num[i];
start = i;
}
else{
curSum += num[i];
}
if(curSum>curMaxSum){
curMaxSum = curSum;
end = i;
}
}
for(int i = start;i<=end;i++){
System.out.println(num[i]);
}
return curMaxSum;
}

## 题目六：

public class testMinStack {
//自定义栈，min函数得到当前最小值

@Test
public void test(){
MinStack ms = new MinStack();
ms.push(5);
System.out.println(ms.min());
ms.push(6);
ms.push(2);
ms.push(1);
System.out.println(ms.min());
ms.pop();
System.out.println(ms.min());
ms.pop();
System.out.println(ms.min());

}
}

class MinStack{
private Stack<Integer> minStack = new Stack<Integer>();
private Stack<Integer> stack = new Stack<Integer>();

public int pop(){
minStack.pop();
return stack.pop();
}

public void push(int num){
if(minStack.size()<=0){
minStack.push(num);
return;
}
Integer min = minStack.lastElement();
if(num<min){
minStack.push(num);
}
else{
minStack.push(min);
}
stack.push(num);
}

public int min(){
if(minStack.size()<=0){
return -1;
}
return minStack.lastElement();
}
}

## 题目七：

//找出数组中出现次数大于一半的数

@Test
public void test(){
int[] num = {1,2,2,2,2,2,2,4,2,4,6,4,2,6,8,2,7,7};
System.out.println(moreThanHaft(num));
}

public int moreThanHaft(int[] num){
int result = -1;
int times = 0;
for(int i=0;i<num.length;i++){
if(times==0){
result = num[i];
times++;
}
else{
if(num[i]==result){
times++;
}
else{
times--;
}
}
}

return result;
}

## 题目八：

//判断一个数组是否是另一个栈的出栈顺序

@Test
public void test(){
int[] num = {1,2,3,4,5};
int[] num1={1,2,3,5,4};
int[] num2={2,1,5,3,4};
int[] num3 = {2,1,5,4,3};
Stack<Integer> s1 = new Stack<Integer>();
Stack<Integer> s2 = new Stack<Integer>();
for(int i=4;i>=0;i--){
s2.push(num3[i]);
}

System.out.println(testOrder(num,s1,s2));
}

public boolean testOrder(int[] num,Stack<Integer> s1,Stack<Integer> s2){
int length = num.length;
for(int i=0;i<length;i++){
s1.push(num[i]);
while(!s1.isEmpty() && s2.lastElement().intValue()==s1.lastElement().intValue()){
s1.pop();
s2.pop();
}
}
if(!s1.isEmpty()){return false;
}
return true;
}

## 题目九：

//从扑克牌抽5张牌，0可以为任意数，判断是否是顺子

@Test
public void test(){
int[] num = {0,1,5,3,2};
System.out.println(check(num));
}

public boolean check(int[] num){
//0-13
int[] pai = new int[14];
for(int n : num){
pai[n]+=1;
}
qsort(num,0,num.length-1);
int count = pai[0];
int start = 0;
if(num[0]==0){
start=num[1];
}
else{
start=num[0];
}
for(int i = start;i<=start+5;i++){
if(pai[i]>1)return false;
count += pai[i];
}
if(count == 5)return true;
else return false;

}

public void qsort(int[] num,int left,int right){
if(left<right){
int partition = partition(num,left,right);
qsort(num,left,partition-1);
qsort(num,partition+1,right);
}
}

public int partition(int[] num,int left,int right){
int partition = num[left];
while(left<right){
while(left<right && num[right]>=partition){
right--;
}
swap(num,left,right);
while(left<right && num[left]<=partition){
left++;
}
swap(num,left,right);
}

return left;
}

public void swap(int[] num,int m,int n){
int temp = num[m];
num[m]=num[n];
num[n]=temp;
}

## 题目十：

//输出第k个丑数(因子只有2，3，5)

@Test
public void test(){
findUglyNum(8);
}

public void findUglyNum(int index){
int[] num = new int[index];
int next = 1;
num[0]=1;
int index2=0;
int index3=0;
int index5=0;

while(next<index){
int num2 = num[index2]*2;
int num3 = num[index3]*3;
int num5 = num[index5]*5;

num[next] = getSuitable(num2,num3,num5);

while(num[index2]*2<=num[next]){
index2++;
}
while(num[index3]*3<=num[next]){
index3++;
}
while(num[index5]*5<=num[next]){
index5++;
}
next++;

}
System.out.println(num[index-1]);
}

public int getSuitable(int num2,int num3,int num5){
int s = num2;
if(num3<s){
s = num3;
}
if(num5<s){
s = num5;
}
return s;
}

posted @ 2015-06-23 19:49  Sunnier  阅读(45268)  评论(18编辑  收藏  举报