java算法题常用语法要点
由于算法考试要到了，所以整理一些java的语法，主要是算法题中经常用到的各类问题
其中一部分转载了一些其他博主的文章，具体如下：
Java中list详解
Java二维数组List操作，ArrayList和LinkList相同
java 数组排序 Arrays.sort()用法
java中排序函数sort()使用，Arrays.sort（）和Collections.sort()
##java算法题常用语法要点
函数开头
有部分算法题平台是不给出函数签名的，全部都需要手写，有些朋友可能写完java代码提交后报”Compiler did not create the expected binary“错误，其实就是类名的问题，类名固定要写为Main。
class Main{
public static void main(String[] args) {
System.out.print("test");
}
}
基础输入语句
import java.util.Scanner;
public class TestDemo1007_4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();//only int
System.out.println(a);
Scanner scanner = new Scanner(System.in);
String a = scanner.next();//allow string
System.out.println(a);
}
}
正无穷、负无穷、非数
//Float型：
float a=Float.POSITIVE_INFINITY
float a=Float.NEGATIVE_INFINITY
float a=Float.NaN
//Double型：
double a=Double.POSITIVE_INFINITY
double a=Double.NEGATIVE_INFINITY
double a=Double.NaN
Arrays.sort()
用于对数组排序
//引用
import java.util.Arrays;
import java.util.Comparator;
//升序直接调用，也可对byte型、char型、doubule型数组排序
static void sort(int[] a)
static void sort(int[] a, int fromIndex, int toIndex)
//降序、使用比较器
class cmp implements Comparator<Integer>{
public int compare(Ingeger n1, Ingeger n2){
if (n1 < n2){
return 1;
}else{
return -1;
}
}
}
//例子
public int test(Integer[] nums, int k) {
//升序直接调用
Arrays.sort(nums);
//降序排列
Arrays.sort(nums, new cmp());
for(int i = 0; i <= nums.length - 1; i++){
System.out.println(nums[i]);
}
return nums[k-1];
}
Collections.sort()
java.util.Collections中的静态方法的Collection.sort()主要是针对集合框架中的动态数组，链表，树，哈希表等（ ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap ）进行排序
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
//用Collections的sort()方法对集合进行排序。
/*
* 题目：
* 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
* 例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
*/
public class test3 {
public String PrintMinNumber(Integer [] s) {
if(s==null) return null;
String s1="";
ArrayList<Integer> list=new ArrayList<Integer>(Arrays.asList(s));
// for(int i=0;i<s.length;i++){
// list.add(s[i]);
// }
Collections.sort(list,new Comparator<Integer>(){//数组里的数两两组合比较，按照比较值更得的顺序升序排序
public int compare(Integer str1,Integer str2){
String s1=str1+""+str2;
String s2=str2+""+str1;
return s1.compareTo(s2);//变成-s1.compareTo(s2)就是降序排序了
}
});
for(int j:list){
System.out.println("输出为:"+j);
s1+=j;
}
return s1;
}
public static void main(String[] args) {
Integer [] list={3,32,321};
test3 demo=new test3();
System.out.println(demo.PrintMinNumber(list));
}
}
结果如下：
输出为:321
输出为:32
输出为:3
321323
ArrayList
/*
ArrayList继承AbstractList类，
实现了List和RandomAccess，Cloneable, Serializable接口，
底层是基于动态的数组。
底层使用数组实现,默认初始容量为10.
当超出后，会自动扩容为原来的1.5倍，即自动扩容机制。
List list = Collections.synchronizedList(new ArrayList(...))
//即可线程安全。
// 利用ArrayList类实例化List集合
List<String> list = new ArrayList<String>();
*/
import java.util.*;
public class ArrayListExamples {
public static void main(String args[]) {
// 创建一个空的数组链表对象list，list用来存放String类型的数据
ArrayList<String> list = new ArrayList<String>();
// 增加元素到list对象中
list.add("Item1");
list.add("Item2");
list.add(2, "Item3"); // 此条语句将会把“Item3”字符串增加到list的第3个位置。
list.add("Item4");
// 显示数组链表中的内容
System.out.println("The arraylist contains the following elements: " + list);
// 检查元素的位置
int pos = list.indexOf("Item2");
System.out.println("The index of Item2 is: " + pos);
// 检查数组链表是否为空
boolean check = list.isEmpty();
System.out.println("Checking if the arraylist is empty: " + check);
// 获取链表的大小
int size = list.size();
System.out.println("The size of the list is: " + size);
// 检查数组链表中是否包含某元素
boolean element = list.contains("Item5");
System.out.println("Checking if the arraylist contains the object Item5: " + element);
// 获取指定位置上的元素
String item = list.get(0);
System.out.println("The item is the index 0 is: " + item);
// 遍历arraylist中的元素
// 第1种方法: 循环使用元素的索引和链表的大小
System.out.println("Retrieving items with loop using index and size list");
for (int i = 0; i < list.size(); i++) {
System.out.println("Index: " + i + " - Item: " + list.get(i));
}
// 第2种方法:使用foreach循环
System.out.println("Retrieving items using foreach loop");
for (String str : list) {
System.out.println("Item is: " + str);
}
// 第三种方法:使用迭代器
// hasNext(): 返回true表示链表链表中还有元素
// next(): 返回下一个元素
System.out.println("Retrieving items using iterator");
for (Iterator<String> it = list.iterator(); it.hasNext();) {
System.out.println("Item is: " + it.next());
}
// 替换元素
list.set(1, "NewItem");
System.out.println("The arraylist after the replacement is: " + list);
// 移除元素
// 移除第0个位置上的元素
list.remove(0);
// 移除第一次找到的 "Item3"元素
list.remove("Item3");
System.out.println("The final contents of the arraylist are: " + list);
// 转换 ArrayList 为 Array
String[] simpleArray = list.toArray(new String[list.size()]);
System.out
.println("The array created after the conversion of our arraylist is: " + Arrays.toString(simpleArray));
}
}
ArrayList的优缺点
优点：底层数据结构是数组，查询快，增删慢。
缺点： 线程不安全，效率高
LinkedList
/*
LinkedList继承AbstractList类，
实现了List，Serializable，Queue接口，
LinkedList是通过双向链表去实现的，
既然是链表实现那么它的随机访问效率比ArrayList要低，
顺序访问的效率要比较的高。
每个节点都有一个前驱（之前前面节点的指针）
一个后继（指向后面节点的指针）。
// 利用LinkedList类实例化List集合
List<String> list = new LinkedList<String>();
*/
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
/*
* @desc LinkedList测试程序。
*
* @author skywang
* @email kuiwu-wang@163.com
*/
public class LinkedListTest {
public static void main(String[] args) {
// 测试LinkedList的API
testLinkedListAPIs() ;
// 将LinkedList当作 LIFO(后进先出)的堆栈
useLinkedListAsLIFO();
// 将LinkedList当作 FIFO(先进先出)的队列
useLinkedListAsFIFO();
}
/*
* 测试LinkedList中部分API
*/
private static void testLinkedListAPIs() {
String val = null;
//LinkedList llist;
//llist.offer("10");
// 新建一个LinkedList
LinkedList llist = new LinkedList();
//---- 添加操作 ----
// 依次添加1,2,3
llist.add("1");
llist.add("2");
llist.add("3");
// 将“4”添加到第一个位置
llist.add(1, "4");
System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\"");
// (01) 将“10”添加到第一个位置。 失败的话，抛出异常！
llist.addFirst("10");
System.out.println("llist:"+llist);
// (02) 将第一个元素删除。 失败的话，抛出异常！
System.out.println("llist.removeFirst():"+llist.removeFirst());
System.out.println("llist:"+llist);
// (03) 获取第一个元素。 失败的话，抛出异常！
System.out.println("llist.getFirst():"+llist.getFirst());
System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\"");
// (01) 将“10”添加到第一个位置。 返回true。
llist.offerFirst("10");
System.out.println("llist:"+llist);
// (02) 将第一个元素删除。 失败的话，返回null。
System.out.println("llist.pollFirst():"+llist.pollFirst());
System.out.println("llist:"+llist);
// (03) 获取第一个元素。 失败的话，返回null。
System.out.println("llist.peekFirst():"+llist.peekFirst());
System.out.println("\nTest \"addLast(), removeLast(), getLast()\"");
// (01) 将“20”添加到最后一个位置。 失败的话，抛出异常！
llist.addLast("20");
System.out.println("llist:"+llist);
// (02) 将最后一个元素删除。 失败的话，抛出异常！
System.out.println("llist.removeLast():"+llist.removeLast());
System.out.println("llist:"+llist);
// (03) 获取最后一个元素。 失败的话，抛出异常！
System.out.println("llist.getLast():"+llist.getLast());
System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\"");
// (01) 将“20”添加到第一个位置。 返回true。
llist.offerLast("20");
System.out.println("llist:"+llist);
// (02) 将第一个元素删除。 失败的话，返回null。
System.out.println("llist.pollLast():"+llist.pollLast());
System.out.println("llist:"+llist);
// (03) 获取第一个元素。 失败的话，返回null。
System.out.println("llist.peekLast():"+llist.peekLast());
// 将第3个元素设置300。不建议在LinkedList中使用此操作，因为效率低！
llist.set(2, "300");
// 获取第3个元素。不建议在LinkedList中使用此操作，因为效率低！
System.out.println("\nget(3):"+llist.get(2));
// ---- toArray(T[] a) ----
// 将LinkedList转行为数组
String[] arr = (String[])llist.toArray(new String[0]);
for (String str:arr)
System.out.println("str:"+str);
// 输出大小
System.out.println("size:"+llist.size());
// 清空LinkedList
llist.clear();
// 判断LinkedList是否为空
System.out.println("isEmpty():"+llist.isEmpty()+"\n");
}
/**
* 将LinkedList当作 LIFO(后进先出)的堆栈
*/
private static void useLinkedListAsLIFO() {
System.out.println("\nuseLinkedListAsLIFO");
// 新建一个LinkedList
LinkedList stack = new LinkedList();
// 将1,2,3,4添加到堆栈中
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
// 打印“栈”
System.out.println("stack:"+stack);
// 删除“栈顶元素”
System.out.println("stack.pop():"+stack.pop());
// 取出“栈顶元素”
System.out.println("stack.peek():"+stack.peek());
// 打印“栈”
System.out.println("stack:"+stack);
}
/**
* 将LinkedList当作 FIFO(先进先出)的队列
*/
private static void useLinkedListAsFIFO() {
System.out.println("\nuseLinkedListAsFIFO");
// 新建一个LinkedList
LinkedList queue = new LinkedList();
// 将10,20,30,40添加到队列。每次都是插入到末尾
queue.add("10");
queue.add("20");
queue.add("30");
queue.add("40");
// 打印“队列”
System.out.println("queue:"+queue);
// 删除(队列的第一个元素)
System.out.println("queue.remove():"+queue.remove());
// 读取(队列的第一个元素)
System.out.println("queue.element():"+queue.element());
// 打印“队列”
System.out.println("queue:"+queue);
}
}
LinkedList的优缺点
优点：底层数据结构是链表，查询慢，增删快。
缺点： 线程不安全，效率高
Vector
import java.util.Vector;
import java.lang.*;
import java.util.Enumeration;
public class VectorApp {
public static void main(String args[]) {
Vector v1 = new Vector();
Integer integer1 = new Integer(1);
//加入为字符串对象
v1.addElement("one");
//加入的为integer的对象
v1.addElement(integer1);
v1.addElement(integer1);
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
//转为字符串并打印
System.out.println("The Vector v1 is:\n\t" + v1);
//向指定位置插入新对象
v1.insertElementAt("three", 2);
v1.insertElementAt(new Float(3.9), 3);
System.out.println("The Vector v1(used method
insertElementAt()is:\n\t)"+v1);
//将指定位置的对象设置为新的对象
//指定位置后的对象依次往后顺延
v1.setElementAt("four", 2);
System.out.println("The vector v1 cused method setElmentAt()is:\n\t" + v1);
v1.removeElement(integer1);
//从向量对象v1中删除对象integer1
//由于存在多个integer1,所以从头开始。
//找删除找到的第一个integer1.
Enumeration enum =v1.elements();
System.out.println("The vector v1 (used method removeElememt()is");
while ( enum.hasMoreElements())
System.out.println( enum.nextElement() + "");
System.out.println();
//使用枚举类(Enumeration)的方法取得向量对象的每个元素。
System.out.println("The position of Object1(top-to-botton):" + v1.indexOf(integer1));
System.out.println("The position of Object1(tottom-to-top):" + v1.lastIndexOf(integer1));
//按不同的方向查找对象integer1所处的位置
v1.setSize(4);
System.out.println("The new Vector(resized the vector)is:" + v1);
//重新设置v1的大小，多余的元素被抛弃
}
}
Vector的优缺点
优点：底层数据结构是数组，查询快，增删慢。
缺点：线程安全，效率低
三种list的使用
对数组查询次数多：ArrayList
对数组修改次数多：LinkedList
数组需要更加安全：Vector
数组不需要更加安全：ArrayList或者LinkedList
当需要使用list时，对使用具体哪个list不确定：ArrayList
二维数组
//初始化
List<List<Integer>> result = new LinkedList<>();
ArrayList<ArrayList<Integer>> cutPlan = new ArrayList<>();
//往空二维数组添加一维数组 添加方法1
result.add(new LinkedList<>(Arrays.asList(1, 2, 3, 6)));
result.add(new LinkedList<>(Arrays.asList(2, 3, 4)));
result.add(new LinkedList<>(Arrays.asList(3, 6)));
result.add(new LinkedList<>(Arrays.asList(4, 5)));
//往空二维数组添加一维数组 添加方法2
list3 = new ArrayList<String>();
list3.add("c1");
list3.add("c2");
list3.add("c3");
list3.add("c4");
ArrayList<ArrayList<String>> listTwo = new ArrayList<ArrayList<String>>();
listTwo.add(list1);
listTwo.add(list2);
//往二维数组里的一维数组里添加，删除数
((ArrayList)c.get(i)).add(5);
((ArrayList)c.get(i)).remove(3);
4333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
