剑指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);
		}
    }
}