第1章认识复杂度和简单排序算法作业

1. 成绩排序

题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩都按先录入排列在前的规则处理。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;

public class Main {
	public static class Student {
		String name;
		int score;
		public Student(String name, int score) {
			this.name = name;
			this.score = score;
		}
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		while (br.ready()) {	// 非阻塞
			int n = Integer.parseInt(br.readLine());
			Student[] students = new Student[n];	
			int sortedType = Integer.parseInt(br.readLine());
			
			for (int i = 0; i < n; i++) {
				String inputString = br.readLine();
				students[i] = new Student(inputString.split(" ")[0], Integer.parseInt(inputString.split(" ")[1]));
			}
			
			InsertionSort(students, sortedType);
			
			for (int i = 0; i < n; i++) {
				String res = students[i].name + " " + students[i].score;
				System.out.println(res);
			}
		}
	}

	// 插入排序
	private static void InsertionSort(Student[] students, int sortedType) {
		for (int i = 1; i < students.length; i++) {
			if (sortedType == 1) {
				for (int j = i - 1; j >= 0 && students[j].score > students[j+1].score; j--) {
					students[j].score = students[j].score ^ students[j+1].score;
					students[j+1].score = students[j].score ^ students[j+1].score;
					students[j].score = students[j].score ^ students[j+1].score;
					String temp = students[j].name;
					students[j].name = students[j+1].name;
					students[j+1].name = temp;
				}
			} else {
				for (int j = i - 1; j >= 0 && students[j].score < students[j+1].score; j--) {
					students[j].score = students[j].score ^ students[j+1].score;
					students[j+1].score = students[j].score ^ students[j+1].score;
					students[j].score = students[j].score ^ students[j+1].score;
					String temp = students[j].name;
					students[j].name = students[j+1].name;
					students[j+1].name = temp;
				}
			}
		}
	}
}

2.  二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

• 暴力，时间复杂度是 
• 二分查找，时间复杂度是 

public class Solution {
	public boolean Find(int target, int[][] array) {
		for (int i = 0; i < array.length; i++) {
			boolean res = BinarySearch(target, array[i]);
			if (res == true) {
				return res;
			}
		}
		return false;
    }
    private boolean BinarySearch(int target, int[] array) {
		int left = 0;
		int right = array.length - 1;
		int mid = 0;
		while (left <= right) {
			mid = left + ((right - left) >> 1);
			if (array[mid] == target) {
				return true;
			} else if (array[mid] > target) {
				right = mid - 1;
			} else if (array[mid] < target) {
				left = mid + 1;
			}
		}
		return false;
	}
}

• 3. 利用二维数组由上到下，由左到右递增的规律选取左下角or右上角的元素array[i][j]与target比较（这里选取左下角）
• 当target大于array[i][j]时，那么target一定在array[i][j]的右边，即j++
• 当target小于array[i][j]时，那么target一定在array[i][j]的上边，即i--
• 时间复杂度: O(2N)

public class Solution {
    public boolean Find (int target, int[][] array) {
        if (array == null || array.length == 0) return false;
        int i = array.length - 1;
        int j = 0;
        while (i >= 0 && j <= array[0].length - 1) {
            if (target > array[i][j]) {
                j++;
            } else if (target < array[i][j]) {
                i--;
            } else {
                return true;
            }
        }
        return false;
    }
}

3. 斐波那契数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。

public class Solution {
    public int Fibonacci(int n) {
    	if (n == 0) {
    		return 0;
    	} else if (n == 1) {
			return 1;
		}
    	int[] arr = new int[n+1];
    	arr[0] = 0;
    	arr[1] = 1;
    	for (int i = 2; i <= n; i++) {
			arr[i] = arr[i-2] + arr[i-1];
		}
    	return arr[n];
    }
}