剑指Offer的一些数据结构面试题目

1.一个二维数组，每一行从左到右递增，每一列从上到下递增．输 入一个二维数组和一个整数，判断数组中是否含有整数。

代码演示
package ArrayTest;

public class Find {

    public static boolean find (int[] [] array, int number) {
        if(array==null) {
            return false;
        }
        /**
         * 从第一个二维数组的最大值开始查找
         */
        int column = array[0].length-1;
        int row = 0;
        while(row<array.length &&column>=0) {
            if(array[row][column]==number) {
                return true;
            }else if(array[row][column]>number) {
                System.out.println("column:"+column);
                column--;
            }else {
                System.out.println("row:"+row);
                row++;
            }
            
        }
        return false;
    }
    
    public static void main(String[] args) {
        int[][] testarray = new int[4][4];
        testarray[0][0] = 1;
        testarray[0][1] = 2;
        testarray[0][2] = 8;
        testarray[0][3] = 9;
        testarray[1][0] = 2;
        testarray[1][1] = 4;
        testarray[1][2] = 9;
        testarray[1][3] = 12;
        testarray[2][0] = 4;
        testarray[2][1] = 7;
        testarray[2][2] = 10;
        testarray[2][3] = 13;
        testarray[3][0] = 6;
        testarray[3][1] = 8;
        testarray[3][2] = 11;
        testarray[3][3] = 15;
        System.out.println(find(testarray, 6));
    }
}

2.请实现一个函数，把字符串中的每个空格替换成“%20”。

代码演示

package StringTest;

public class ReplaceBlank {

    public static void main(String[] args) {
        String s = "We are happy";
        System.out.println(replaceBlank(s));
    }
    
    public static String  replaceBlank(String s) {
        if(s==null||"".equals(s)) {
            return null;
        }
        StringBuffer sbuf = new StringBuffer();
        for(int i=0;i<s.length();i++) {
            if(s.charAt(i)==' ') {
                sbuf.append("%");
                sbuf.append("2");
                sbuf.append("0");
            }else {
                sbuf.append(String.valueOf(s.charAt(i)));
            }
        }
        return new String(sbuf);
    }
}

3.输入二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设前 序遍历和中序遍历结果中都不包含重复的数字，例如输入的前序遍历序列 {1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}重建出如图所示的二叉树。

首先理一下前序遍历、中序遍历、后序遍历

1. 前序遍历：先根节点，再左节点，最后右节点
2. 中序遍历：先左节点，再根节点，最后右节点
3. 后序遍历：先左节点，再右节点，最后根节点

4.判断二进制数中1的个数

public class Problem01 {

    public static void main(String[] args) {
        
        Problem01 test = new Problem01();
        System.out.println(test.numberOf1(4));
    }
    public int numberOf1(int n) {
        int count=0;
        while(n!=0) {
            count++;
            n=(n-1) & n;
        }
        return count;
    }
}

5.给定一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分,所有偶数位于数组的后半部分,时间复杂度为o(n),空间复杂度为o(1)

public static int[] function_Application(int[] arr){
    
    int left=0;
    int right=arr.length-1
    int flag;
    while(){
        if(arr[left]%2==0){
            left++;//说明arr[left]是奇数
            continue;
        }
        if(arr[right]%2!=0{
            right--;
            continue;
        }
        if(left<right){
            flag=arr[left];
            arr[left++]=arr[right];
            arr[right--]=flag;
            continue;
        }
    }
}

6.冒泡排序

public int[] bubbleSort(int[] arr){
    
    if(arr.length==0)
    return arr;
    int flag=0;
    
    for(int i=0;i<arr.length;i++){
        for(int j=0;j<arr.length-i;j++){
            if(arr[j+1]<arr[j]){
                flag=arr[j+1];
                arr[j+1]=arr[j];
                arr[j]=flag;
            }
        }
    }
    return arr;
}

7.快速排序

public int[] sort(int[] arr, int low, int high){

    int start = low;
    int end = high;
    int key = arr[low];
    int temp = 0;
    while(end>start){
        //从后往前比较
        while(end>start&&arr[end]>=key)
            end--;
        //如果没有比关键值小的,就比较下一个,直到有比关键值小的交换位置，然后又从前往后比较
        if(arr[end]<key){
            temp = arr[start]
            arr[start] = arr[end];
            arr[end] = temp;
        }

        //从前往后比较
        while(end>start && arr[start]<=key)
        //如果没有比关键值大的就比较下一个,直到有比关键值大的交换位置
            start++;
        if(arr[start]>key){
            temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //此时第一次循环结束,关键值的位置已经确定了,左边序列的值都比关键值小,右边都比关键值大,但是两边的顺序可能还不一样。
    }
    //递归调用
    if(start>low) sort(arr,low,start+1);
    if(end<high sort(arr,end+1;high);
}

8.输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

listNode 是链表，只能从头遍历到尾，但是输出却要求从尾到头，这是典型的"先进后出"，我们可以想到栈！

LinkedList 中有个方法是 add(index,value)，可以指定 index 位置插入 value 值，所以我们在遍历 listNode 的同时将每个遇到的值插入到 list 的 0 位置，最后输出 listNode 即可得到逆序链表

public class Solution {
    
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList();
        if(listNode!=null){
            printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
    }
}

转载于:https://www.cnblogs.com/Mr-RanX/p/11462826.html