原来极客学院已经有了
- two-sum
给定一个整数数组，找到2个数字，这样他们就可以添加到一个特定的目标号。功能twosum应该返回两个数字，他们总计达目标数，其中index1必须小于index2。请注意，你的答案返回（包括指数和指数）不为零的基础。你可以假设每个输入都有一个解决方案。 输入数字numbers= { 2，7，11，15 }，目标= 9输出：index1 = 1，index2= 2
public int[] twoSum(int[] numbers, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < numbers.length; i++){
//发现target的另一个加数
if(map.get(numbers[i]) != null){
int[] result = {map.get(numbers[i]) + 1, i+1};//index+1
return result;
}else {
//numbers[i]为第一个加数，map的key为target的另一个加数，value为数组的index
map.put(target - numbers[i], i);
}
}
int[] result = {};
return result;
}
结果输出：result=1//2
- 二维数组查找
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
public boolean find(int[][] array,int target){
int rows=array.length;
int columns=array[0].length;
if(rows> 0 && columns > 0){
int row=0;
int column=columns-1;
while(row >= 0){
int value=array[row][column];
if(value == target){
return true;
}else if(value < target){
row++;
}else if(value > target){
column--;
}
}
}
return false;
}
查找结果：
int[][] nums={{1,2,3},{4,5,6},{7,8,9}};
int target=8;
result=true;
- 打印1到最大的n位数
输入数字n，按顺序打印出从1最大的n位十进制数。比如输入3，则打印出1、2、3一直到最大的3位数即999。
/**
* 输入数字n，按顺序打印出从1最大的n位十进制数。比如输入3，则打印出1、2、3 一直到最大的3位数即999。
*
* @param n 数字的最大位数
*/
public static void printOneToNthDigits(int n) {
// 输入的数字不能为小于1
if (n < 1) {
throw new RuntimeException("The input number must larger than 0");
}
// 创建一个数组用于打存放值
int[] arr = new int[n];
printOneToNthDigits(0, arr);
}
/**
* 输入数字n，按顺序打印出从1最大的n位十进制数。
*
* @param n 当前处理的是第个元素，从0开始计数
* @param arr 存放结果的数组
*/
public static void printOneToNthDigits(int n, int[] arr) {
// 说明所有的数据排列选择已经处理完了
if (n >= arr.length) {
// 可以输入数组的值
printArray(arr);
} else {
// 对
for (int i = 0; i <= 9; i++) {
arr[n] = i;
printOneToNthDigits(n + 1, arr);
}
}
}
/**
* 输入数组的元素，从左到右，从第一个非0值到开始输出到最后的元素。
*
* @param arr 要输出的数组
*/
public static void printArray(int[] arr) {
// 找第一个非0的元素
int index = 0;
while (index < arr.length && arr[index] == 0) {
index++;
}
// 从第一个非0值到开始输出到最后的元素。
for (int i = index; i < arr.length; i++) {
System.out.print(arr[i]);
}
// 条件成立说明数组中有非零元素，所以需要换行
if (index < arr.length) {
System.out.println();
}
}
- 查找字符串第一个不重复字符 abbcdd-----> c
public void getCharByStr(String str){
LinkedHashMap<Character,Integer> map=new LinkedHashMap<>(str.length());//保证插入顺序和输出顺序一致
for(char c:str.toCharArray()){
map.put(c,map.containsKey(c)?map.get(c)+1:1);
}
for(Map.Entry<Character,Integer> entry : map.entrySet()){
if(entry.getValue() == 1){
System.out.print(entry.getKey());
}
}
}
- 快速排序
算法规则： 本质来说，快速排序的过程就是不断地将无序元素集递归分割，一直到所有的分区只包含一个元素为止。
由于快速排序是一种分治算法，我们可以用分治思想将快排分为三个步骤：
1.分：设定一个分割值，并根据它将数据分为两部分
2.治：分别在两部分用递归的方式，继续使用快速排序法
3.合：对分割的部分排序直到完成
public int dividerAndChange(int[] args, int start, int end) {
//一般以数组第一个元素为分割值start=0
int key = args[start];
while (start < end) {
//从后往前找，小于分割值的索引
while (start < end && args[end] >= key) {
end--;
}
//然后进行交换
if (start < end) {
swap(args, start, end);
}
//从前往后找，大于分割值的索引
while (start < end && args[start] < key) {
start++;
}
if (start < end) {
swap(args, start, end);
}
}
//此时start应非0，将数组分割成两部分
args[start] = key;
return start;
}
private void swap(int[] args, int start, int end) {
//交换
int temp = args[start];
args[start] = args[end];
args[end] = temp;
}
public void sort(int[] args, int start, int end) {
if (end - start > 1) {//分治的元素大于1才有意义
int mid = dividerAndChange(args, start, end);
sort(args, start, mid);//前半部分
sort(args, mid + 1, end);//后半部分
}
}
