做过的笔试题

1.有一数组S[] = {good,apple,fix,king,soft,god,food},要求将这个数组按照首字母分成多个数组，使其成为{apple},{fix,food},{good,god}这种，每一个数组内都是这样有序的。

import java.util.ArrayList;


public class strings {

    public ArrayList<ArrayList<String>> get(String[] s){
        ArrayList<ArrayList<String>> array = new ArrayList<ArrayList<String>>();
        for(int i=0;i<s.length;i++){
            ArrayList<String> array1 = null;
            if(null!=s[i]){
                array1= new ArrayList<String>();
                array1.add(s[i]);
                char a=s[i].toString().charAt(0);
                for(int j=i+1;j<s.length;j++){
                    if(null!=s[j]&&a==s[j].toString().charAt(0)){
                        array1.add(s[j]);
                        s[j]=null;
                    }
                }
                s[i]=null;
                if(null!=array1){
                    array.add(array1);
                }
            }
            
        }
        return array;
    }
    /**
     * @param args
     */
    public static void main(String[] args) {

        String[] s = {"asdf","fsadf","as","fsfs"}; 
        strings ab=new strings();
        ArrayList<ArrayList<String>> array = new ArrayList<ArrayList<String>>();
        array = ab.get(s);
        for (ArrayList<String> a:array) {
            for(String t: a){
                System.out.println(t);
            }
        }
    }

}

采取双ArrayList形式，不知道还有没有其他改进形式，欢迎讨论

******************************************************************************************

2.完成函数，将一个数组顺序移动循环右移n位。并写出其时间复杂度和空间复杂度。

import java.util.LinkedList;


public class MArray {

    public void Move(int [] array,int n){
        int t = n%array.length;
        int[] tempArray = new int[t];
        for(int i=array.length-1;!(i<0);i--){
            if((i+t)>(array.length-1)){
                tempArray[i+t-array.length] = array[i];
            }else{
                array[i+t]=array[i];
            }
        }
        for(int i=0;i<t;i++){
            array[i]=tempArray[i];
        }
    }
    
    public void Move2(int [] array,int n){
        int t = n%array.length;
        while(t>0){
            int temp=0;
            for(int i=array.length-1;i>0;--i){
                if(i==(array.length-1)){
                    temp = array[0];
                    array[0] = array[i];
                    array[i] = temp;
                }else{
                    temp = array[i+1];
                    array[i+1] = array[i];
                    array[i] = temp;
                }
            }
            --t;
        }
    }
    
    public void Move3(int[] array,int n){
        int t = n%array.length;
        LinkedList <Integer> queue = new LinkedList<Integer>();
        for(int i=t;i>0;i--){
            queue.offer(array[array.length-i]);
        }
        for(int i=0;i<array.length-t;i++){
            queue.offer(array[i]);
        }
        for(int i=0;i<array.length;i++){
            array[i] = queue.poll();
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {

        int[] array = {1,2,3,4,5,6,7,8,9,0};
        int n = 3;
        MArray ma = new MArray();
        ma.Move3(array, n);
        for(int i:array){
            System.out.println(i);
        }

    }

}

方法一：延长数组n位，n为移动的位数，将数组向右移动，然后将延长的n项，覆盖原数组的前n项。时间复杂度o(n)，n为数组长度，空间复杂度为o(n)，n为移动位数。

方法二：定义一个变量，将原数组每次右移以为，共完成n次。时间复杂度o(n^2)，空间复杂度o(1)。

方法三：定义一个队列，先将欲移动的n项按原数组顺序入队列，然后将剩下的N-n项按原数组顺序入队列，然后，全部出队列。时间复杂度o(n)，空间复杂度o(n)。

******************************************************************************************

3.有一个表testa如下图所示

查询总成绩大于135的人       查询每门课程的最高分

第一问：SELECT sname FROM testa GROUP BY sname HAVING SUM(score)>135

 在 SQL 中增加 HAVING 子句原因是，WHERE 关键字无法与合计函数一起使用。

SELECT SUM(score) from testa group by class

第二问：SELECT class,sname,MAX(score) FROM testa GROUP BY class

******************************************************************************************

4.将一个二叉树按中序输出的顺序，转换成一个双向链表，树和链表的节点结构如下图：

解法：

package BinaryTree2Array;

import java.util.LinkedList;

public class BinaryTree2Array {
    
    public LinkedList<Node> getArray(Node root){
        Node currentNode = root;
        Node parrentNode = null;
        LinkedList<Node> stack = new LinkedList<Node>();
        LinkedList<Node> result = new LinkedList<Node>();
        while (currentNode!=null) {
            if(null!=currentNode.left){
                stack.push(currentNode);
                currentNode = currentNode.left;
            }else{
                if(stack.size()>0){
                    parrentNode = stack.pop();
                    result.offer(currentNode);
                    result.offer(parrentNode);
                    currentNode = parrentNode.right;
                }else{
                    currentNode = null;
                }
            }
            
        }
        return result;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Node g = new Node(null, null, 7);
        Node f = new Node(null, null, 6);
        Node e = new Node(null, null, 5);
        Node d = new Node(null, null, 4);
        Node c = new Node(f, g, 3);
        Node b = new Node(d, e, 2);
        Node a = new Node(b, c, 1);
        Node temp = null;
        
        BinaryTree2Array bTree2Array = new BinaryTree2Array();
        LinkedList<Node> rs = bTree2Array.getArray(a);
        for(int i=0;i<rs.size()-1;i++){
            rs.get(i).right=rs.get(i+1);
            rs.get(i+1).left=rs.get(i);
        }
        temp = rs.peek();
        while (temp!=null) {
            System.out.print(temp.value);
            temp=temp.right;
        }
    }

}

class Node{
    Node left;
    Node right;
    int value;
    public Node(Node left,Node right,int value){
        this.left = left;
        this.right = right;
        this.value = value;
    }
}

******************************************************************************************

5.找出100以内所有质数

质数定义：所谓质数就是只能被1和它本身整除的数。那么对于某一个数a，可以试着让它除以a-1......2，如果有任意一次除法的余数为零，这个数a就不是质数。1既不是质数，也不是合数。

public static void test4() {
         boolean bool;
         for (int i = 3; i < 100; i+=2) {
             bool = true;
             for (int j = 3; j <= Math.sqrt(i); j++) {
                 if (i % j == 0) {
                     bool = false;
 　　　　　　　　　　　　break;
                 }
             }
             if (bool)
                 System.out.print(i + " ");
         }
     }

 

******************************************************************************************

6.取出字符串中的数字，并求其和。例如，贾屌生于1988年12月23日。取出其中的数字，算起和得2023

public class testString {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String str = "aaa17ffff10fsfsfsf11";
        String[] array = str.split("\\D");
        int sum = 0;
        for(String s : array){
            if(!s.equals("") ){
                sum += Integer.valueOf(s);
            }
        }
        System.out.println(sum);
    }

}

******************************************************************************************

7.一个数组中的一个元素出现的次数，超过整个数组的长度的1/2。求这个元素

public class FindMost {

    public int find(int[] array){
        int result = 0;
        int temp = 0;
        for(int i=0;i<array.length;++i){
            if(temp == 0){
                result =array[i];
                temp++;
            }else{
                if(result==array[i]){
                    temp++;
                }else{
                    temp--;
                }
            }
        }
        return result;
    }
    public static void main(String[] args) {

        int[] array = {1,15,31,15,1,51,15,1,34,1,1,1,1};
        FindMost fm = new FindMost();
        System.out.println(fm.find(array));

    }
}