精华内容
下载资源
问答
  • 链表增删改查代码练习: 了解链表增删改查操作步骤: ... import java.util.LinkedList; public class DemoLinkedList { private int size = 0;... //无参构造方法 public DemoLinkedList(){ /

    链表的增删改查代码练习:

    了解链表的增删改查的操作步骤:

    package cn.tedu.Test;
    import java.util.LinkedList;
    public class DemoLinkedList {
    
    	private int size = 0; // 节点个数
    	private Node first; // 第一个节点
    	private Node last; // 最后一个节点
    
    	//无参构造方法
            public DemoLinkedList(){
            	//this();
            	LinkedList list=new LinkedList();
            }
            //添加元素
    	public void add(String str) {
    		Node node =new Node(null,str,null);
    		if(size==0){
    			this.first=node;
    			this.last=node;
    		}else{
    			this.last.next=node;//新插入的node等于当前链表的最后一个的下一个
    			node.prev=this.last;//新插入的node等于当前列表的最后一个
    			this.last=node;//当前列表的最后一个变成node
    		}
    		size++;
    	}
            //插入
    	public void add(int index, String str) {
    		//最后插入的调用add方法
    		if(index==size){
    			this.add(str);
    			return;
    		}
    		Node node =new Node(null,str,null);
    		if(index==0){
    			//在链表的最前面
    			node.next=this.first.prev;//node的下一个变成当前列表的第一个的前一个
    			this.first.prev=node;//当前列表的第一个的前一个变成node
    			this.first=node;
    		}else{
    			Node node1 =this.getNode(index);
    			node1.prev.next=node;//新插入的node等于原本node1的前一个的下一个位置上
    			node.prev=node1.prev;//将原本的node1的前一个的信息传递给当今插入的node的前一个
    			node1.prev=node;//将原本位置上的node1的前一个变为插入的node
    			node.next=node1;//node的下一个变为原本的node1
    		}
    	}
            // 获取指定位置的节点
    	private Node getNode(int index) {
    		Node node = this.first;
    		for(int i=0;i<index;i++){
    			node=node.next;
    		}
    		return node;
    		
    		
    	}
            //删除
    	public void remove(int index) {
    		if(index==0){//如果删除的是第一个
    			this.first.next.prev=null;//把链表的第二个的前一个索引变为空
    			this.first=this.first.next;//将这条链表的第一个位置上的值变成第二个的值
    			
    		}else if(index==size-1){//如果删除的是最后一个
    			this.last.prev.next=null;
    			this.last=this.last.prev;
    		}else{
    			Node node =this.getNode(index);
    			node.prev.next=node.next;//node[index-1]下一个=node[index+1]
    			node.next.prev=node.prev;//node[index+1]前一个=node[index-1]
    		}
    	}
            //返回节点的内容
    	public String get(int index){
    		return this.getNode(index).data;
    	}
    	// 返回元素个数
    	public int size(){
    		return size;
    	}
    	//利用节点存储数据
    	private class Node {
    		Node prev; // 上一个节点
    		String data; // 元素
    		Node next; // 下一个节点
    
    		public Node(Node prev, String data, Node next) {
    			super();
    			this.prev = prev;
    			this.data = data;
    			this.next = next;
    		}
    	}
    }
    
    

    栈和队列的peek和pop方法等:

    package cn.tedu.stack;
    
    import java.util.LinkedList;
    import java.util.Stack;
    
    public class Demo {
    	public static void test(){
    		//如果栈为空,那么peek和pop都会出现运行时异常
    		//push方法表示压栈,peek和pop表示返回栈顶元素,peek不弹栈
    		Stack stack =new Stack();
    		stack.push("hello");
    		stack.push("abcd");
    		System.out.println(stack);//从栈低到栈顶的输出方式   [hello, abcd]
    		//都是返回栈顶的第一个元素,pop是弹出
    		System.out.println(stack.pop());//弹栈的方式,将数据弹出    abcd
    		System.out.println(stack.peek());//hello
    	}
    	public  static void test2(){
    		LinkedList<String> list =new LinkedList<>();
    		list.push("hello");
    		list.push("hello1");
    		list.push("hello2");
    		list.push("hello3");
    		//输出的是栈顶到栈底
    		System.out.println(list);  //[hello3, hello2, hello1, hello]
    		System.out.println(list.pop());//hello3
    		System.out.println(list);//[hello2, hello1, hello]
    	}
    	public static void main(String[] args) {
    		test();
    		test2();
    		LinkedList<String> list =new LinkedList<>();
    		System.out.println(list.poll());//null
    		System.out.println(list);//[]
    		list.offer("a");
    		list.offer("a2");
    		list.offer("a1");
    		System.out.println(list.poll());//会弹出队列数据    a
    		System.out.println(list.peek());//a2
    		System.out.println(list);//[a2, a1]
    	}
    }
    
    

    map和set的数据的使用和练习:

    package cn.tedu.demo;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Scanner;
    import java.util.Set;
    
    public class Demo {
    	public static void test(){
    		Map<String,Object>  map=new HashMap<>();
    		//添加元素
    		map.put("a", 97);
    		map.put("x", 95);
    		//如果k相同,则改变原来的value值
    		map.put("a", 98);
    		map.put("c", 90);
    		map.remove("c");
    		//获取内部的值
    		System.out.println(map.get("a"));//98
    		//如果k不存在,则返回值为null
    		System.out.println(map.get("c"));//null
    		
    	}
    	public static void test2(){
    		Map<String,Object> stu = new HashMap<>();
    		stu.put("id", "201900001");
    		stu.put("name", "admin");
    		stu.put("phone", "1563333333");
    		stu.put("age", 18);
    		//对于信息较多的可以使用类表示一个对象
    		//stu.put("address", new Address("",""));
    		stu.put("address", "光谷软件园");
    		
    		System.out.println(stu.containsKey("name"));
    		System.out.println(stu.containsValue("admin"));
    		
    		
    	}
    	public static void test3(){
    		Map<String,Object> stu = new HashMap<>();
    		stu.put("id", "201900001");
    		stu.put("name", "admin");
    		stu.put("phone", "1563333333");
    		stu.put("age", 18);
    		stu.put("address", "光谷软件园");
    		//第一种方式
    		//得到一个key集合
    		Set<String> keys = stu.keySet();
    		for(String key:keys){
    			System.out.println(key+":"+stu.get(key));
    		}
    		//第二种方式
    		//返回一个实体对象
    		System.out.println("-----------------------");
    		Set<Entry<String,Object>>stus = stu.entrySet();
    		for(Entry<String,Object> e:stus){
    			System.out.println(e.getKey()+" :"+e.getValue());
    		}
    		//第三种方式
    		//
    		System.out.println("-----------------------");
    		stu.forEach((k,v)->System.out.println(k+" :"+v));
    		
    		//输出一个值的集合
    		System.out.println("---------------------------");
    		Collection<Object> coll=stu.values();
    		for(Object obj:coll){
    			System.out.println(obj);
    		}
    		stu.put(null, null);
    	}
    	public static void test4(){
    		//接收键盘输入一个字符串,统计字符的个数
    		Scanner sc=new Scanner(System.in);
    		System.out.println("input one String:");
    		String str=sc.next();
    		Map<Character,Integer> s = new HashMap<>();
    		int count =0;
    		for(int i=0;i<str.length();i++){
    			char c=str.charAt(i);
    			//s.put(i, c);
    			if(s.containsKey(c)){
    				
    				//s.get(c);
    				++count;
    				s.put(c,++count);
    			}else{
    				s.put(c, 1);
    			}
    			
    		}s.forEach((k,v)->System.out.print(k+"="+v+"个   "));
    		/*Set<Integer> keys = s.keySet();
    		for(Integer key:keys){
    			System.out.println(key+":"+s.get(key));
    		}*/
    	}
    	public static void main(String[] args) {
    		test4();
    		
    	}
    
    }
    
    
    展开全文
  • 队列的常用方法

    2021-01-16 20:14:17
    // 无序队列 Queue<Integer> q=new LinkedList<>(); // 插入元素 q.offer(2); q.offer(1);...// 返回队列头部元素 System.out.println(q.peek());...// 移除并返回队列头部元素 System.out.println
    //        无序队列
            Queue<Integer> q=new LinkedList<>();
    //        插入元素
            q.offer(2);
            q.offer(1);
            q.offer(3);
    //        返回队列头部元素
             System.out.println(q.peek());
    //         移除并返回队列头部的元素
             System.out.println(q.poll());
    //         队列长度
             System.out.println(q.size());
    
    
    //        有序队列
            Queue<Integer> qq=new PriorityQueue<>();
    //        插入元素
            qq.offer(4);
            qq.offer(2);
            qq.offer(1);
            qq.offer(3);
            qq.offer(5);
    //        返回队列头部元素
            System.out.println(qq.peek());
    
    展开全文
  • } } public Integer peek() { return null != head ? head.val : null; } public int length() { int len = 0; Node temp = head; while(temp != null) { temp = temp.next; len++; } ...
    class Node {
    	int val;
    	Node next;
    	public Node(int val) {
    		this.val = val;
    		this.next = null;
    	}
    }
    class FakeQueue {
    	Node head;
    	Node tail;
    	public void offer(int val) {
    		Node node = new Node(val);
    		if(null == head) {
    			head = node;
    			tail = node;
    		} else{
    			tail.next = node;
    		}
    	}
    	public Integer poll() {
    		if (head != null) {
    			int val = head.val;
    			Node temp = head;
    			head = head.next;
    			temp = null;
    			return val;
    		} else {
    			return null;
    		}
    	}
    	public Integer peek() {
    		return null != head ? head.val : null;
    	}
    	public int length() {
    		int len = 0;
    		Node temp = head;
    		while(temp != null) {
    			temp = temp.next;
    			len++;
    		}
    		return len;
    	}
    }
    
    展开全文
  • 它是一种先进先出的数据结构,队列的主要操作就是入队和出队以及读取队头的元素,这个操作叫做peek()。该操作返回队头元素,但不把它从队列中删除。除了读取队头元素,我们还想知道队列中存储了多少元素,可以使用...

    队列是一种列表,不同的是只能在队尾插入元素,在队首删除元素。它是一种先进先出的数据结构,队列的主要操作就是入队和出队以及读取队头的元素,这个操作叫做peek()。该操作返回队头元素,但不把它从队列中删除。除了读取队头元素,我们还想知道队列中存储了多少元素,可以使用length属性满足该需求;要想清空队列中的所有元素,可以使用clear() 方法来实现。

    1、入队enqueue

    首先,dataStore是我申请的一个数组,它是在方法内部被定义,即dataStore = [ ];

    入队操作首先要获取当前数组dataStore的长度,因为队列是从队尾添加数据,所以我只需要将传入的数据data添加到数组的最后一个数据的下一个位置就可以了,那为什么是length呢?数组下标是从0开始取的,一般来说,它的最后一个下标是length-1,现在我要添加数据,很显然就应该在队尾,也就是length-1的下一个位置,即length;

    //进队列,从尾部添加数据
    this.enqueue=function (data) {
        var length = this.dataStore.length;
        this.dataStore[length]=data;
    }

    2、出队dequeue

    队列是先进先出的,所以,删除数据应该从队首开始;

    首先,将队首的数据存储到head里;

    然后,你想啊,如果我把队首删除了之后,是不是应该有新的队首,所以,我后面的数据是不是都应该往前移动一位?现在我需要做的就是让它的dataStore数组里的后一位等于前一位,其实,这里就是赋值,即dataStore[i-1]=dataStore[i];

    接下来,我把除队首以外所有数据都往前移动了一位,那么最后的那个位置是不是就没数据了啊?当然不是,最后的那个位置的数还是原来的数据,我只是把它的后一个数据的值赋值给前一个数据,所以这里是覆盖,并不是真正意义上的移动。因此,我要将最后那位数据置空,然后让数组长度减1,那个空数据就不会再占位置了,就实现了删除的效果。

    //从队列头部删除数据,并且获得这个数据
    this.dequeue=function () {
        var length = this.dataStore.length;
        var head = this.dataStore[0];
        for(var i=1;i<length;i++){
            this.dataStore[i-1]=this.dataStore[i];
        }
        this.dataStore[length-1]=null;
        this.dataStore.length--;
        return head;
    }

    3、获得队列最前面数据front

    想必这个就不用多说了,就是第一个位置的数据,下标显然是0,最后一个数据,下标是length-1。

    //获得队列最前面的数据
    this.front=function(){
        return this.dataStore[0];
    }

    4、获得队列最后面数据back

    //获得队列最后面的数据
    this.back=function () {
        return this.dataStore[this.dataStore.length-1];
    }

    5、返回数据toString

    //依次返回当前队列的数据
    this.toString=function () {
        var length = this.dataStore.length;
        for(var i=0;i<length;i++){
            return this.dataStore;
        }
    }

    6、判断是否为空empty

    如果数组长度为0,说明此时队列里面没有数据,返回为真,反之则假。

    //判断当前队列是否为空
    this.empty=function () {
        if(this.dataStore.length==0){
            return true;
        }
        else{
            return false;
        }
    }

    7、遍历数据forEach

    遍历出队列里面的数据,最后返回的是队列里面的数据以及它的下标。

    //遍历当前队列的数据
    this.forEach=function (call) {
        var length = this.dataStore.length;
        for(var i=0;i<length;i++){
            call(this.dataStore[i],i);
        }
    }

     

    展开全文
  • 整理一下JAVA中栈和队列的常用方法

    千次阅读 2019-06-19 13:43:55
    整理一下JAVA中栈和队列的常用方法 栈 JAVA中栈类是继承了Vector实现的,基本特征是先进后出,并且只能在一侧进出。 方法 作用 Stack() 定义一个空栈 empty() 栈空返回真,否则返回假 peek() 获取栈顶值...
  • Java 阻塞队列常用方法及区别 文章目录Java 阻塞队列常用方法及区别前言1.第一组方法1.1 add 方法1.2 remove 方法1.3 element 方法2.第二组方法2.1 offer 方法2.2 poll 方法2.3 peek 方法3.第三组方法3.1 ...
  • 队列里面各种方法offer,pool, put,take,add,remove,peek,element等, 返回true或者false, 是否抛出异常, 傻傻分不清楚。 在此总结一下, 画张图,下次直接记住这张图就好。 总结为三大类, 添加方法, 查询方法, ...
  • 编写一个类,用两个栈实现队列,支持队列的基本操作(add、poll、peek); 需要满足的条件: 如果 stackPush 要往 stackPop 中压入数据,那么必须一次性把 stackPush 中的数据全部压入 如果 stackPop 不为空,...
  • 一,栈和队列的概念 栈和队列都是数据结构中比较重要的线性表,其中,栈是“先进后出”的线性表,队列是“先进先出”的线性表。 二,栈的链表实现 栈是指限定在表尾进行插入或者删除操作的线性表,栈的表尾成为...
  • 方法 解释 push(e) 压栈 pop() 出栈 peek() 取栈顶元素(不删除) boolean empty() 判断栈是否为空 队列(Queue):先进先出(FIFO) 方法 解释 add(e) / ofter(e) 入队列,add()抛出异常,offer()...
  • 阻塞队列的使用 BlockingQueue 队列常用的操作方法: 1.往队列中添加元素: add(), put(), offer() 2.从队列中取出或者删除元素: remove() element() peek() poll() take() 每个方法的说明如下: offer()方法往...
  • 模拟实现栈和队列常用方法栈概念方法模拟实现栈队列概念方法模拟实现队列 栈 概念 栈:是一种特殊线性表,只允许在固定一端进行插入和删除元素操作。进行插入和删除叫做栈顶,另一端叫做栈底。栈遵循先进...
  • Java 队列中的add和offer,element和peek,remove和poll都是结果一样的方法,所以在...2.element()和peek()方法:用来在队列的头部查询元素,区别如下: 1.在队列为空时,element()抛出一个异常,即NoSuchElementExce
  • 它们区别仅在于特殊情况:当队列满了无法添加元素,或者是队列空了无法移除元素时,不同组的方法对于这种特殊情况会有不同处理方式 抛出异常:add、remove、element 返回结果但不抛出异常:offer、poll、peek...
  • peek()获取队列的投,但是不移除队列的头,如果次队列为空,则返回null。 ②element()获取队列的头,但是不移除队列的头,如果队列为空,则将跑出NoSuchElementException异常。 (3)添加元素的方法 offer
  • peek 入栈顶 出栈,删栈顶 出栈,不删栈顶 push pop peek 2、Queue add offer remove poll peek 数据入队,超过容量则报错 数据入队,超过容量返回false 数据出队,队空...
  • 在Queue中,有 offer、add、poll、remove、peek、element六个方法 public interface Queue<E> extends Collection<E> { boolean add(E e); boolean offer(E e); E remove(); .
  • 队列是一种特殊线性表,它只允许在表前端进行删除操作,而在表后端进行插入操作。 LinkedList类实现了Queue接口,因此我们可以把LinkedList当成Queue来用。 Java中Queue有一些常用的方法: offer、...
  • 用栈实现队列的下列操作 push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 Example: MyQueue queue = new MyQueue(); ...
  • 它们区别仅在于特殊情况:当队列满了无法添加元素,或者是队列空了无法移除元素时,不同组的方法对于这种特殊情况会有不同处理方式: 抛出异常:add、remove、element 返回结果但不抛出异常:offer、poll、peek...
  • Java Queue常用方法 add 增加一个元索 如果队列已满,则抛出一个IIIegaISlabEepeplian异常 remove 移除并返回队列头部元素 如果队列为空,则抛出一个NoSuchElementException异常 element 返回队列头部元素 ...
  • poll方法的区别如下表所示。 方法 作用 结果 add 添加一个元索 如果队列已满,则抛出一个IIIegaISlabEepeplian异常 offer 添加一个元素并返回true 如果队列已满,则返回false ...
  • 阻塞队列存在四组API,分别对应着四种队列的阻塞情况。 阻塞队列 抛出异常 有返回值 等待阻塞 等待超时 入队方法 add() offer() put() offer(值,超时时间,超时单位) 出队方法 remove() poll() take() poll...
  • 使用队列实现栈的下列操作: ...你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque...
  • Queue 中 element() 和 peek() 区别

    万次阅读 2019-05-06 15:48:24
    Queue 中 element() 和 peek()都是用来返回队列的头元素,不删除。 在队列元素为空的情况下,element() 方法会抛出NoSuchElementException异常,peek() 方法只会返回 null。 JDK1.8 /** * Retrieves, but ...
  • 队列的常见操作

    2021-04-10 17:45:27
    队列不做任何变动(不移除元素,只返回元素信息与Stack类的peek方法非常类似); isEmpty(): 如果队列中不包含任何元素,返回true,否则返回false; size(): 返回队列包含的元素个数,与数组的length属性...
  • 目录 LinkedList 数据存储基础结构 单 Node 信息图示 LinkedList 数据存储关系图示 LinkedList 作为栈使用 ...peek():查看队列头部元素,不改变队列结构 poll():返回头部元素,并从队列删除该元素 LinkedL.
  • Queue队列:先进先出属性:Count返回元素个数方法: Enqueue(T value)添加元素到集合尾部 Dequeue()删除并返回集合第一个元素 Peek()返回集合第一个元素 Contains(T value)检索元素是否存在,返回true,否则...
  • 本文实例讲述了JavaScript栈和队列相关操作与实现方法。分享给大家供大家参考,具体如下: 一、栈介绍 栈就是和列表类似一种数据结构,数据只能在栈顶添加或者删除。栈是一种特殊列表,栈内元素只能通过列表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 576
精华内容 230
关键字:

队列的peek方法