精华内容
下载资源
问答
  • 队列中元素删除
    千次阅读
    2019-11-06 16:33:07

    队列中可以用一级指针或者二级指针来进行元素的删除操作,若采用一级指针时,需找到删除元素的前一个元素,然后将删除元素的前一个元素的指针指向删除元素的后一个元素,然后再将要删除的元素delete;若采用二级指针,先移动指针的地址到要删除的元素位置 ppointer = &(pointer) ,注意不要直接更改二级指针的值*ppointer = pointer, 这样做会将前边的元素也一起删除。

    更多相关内容
  • 在这种情况下,要使代码正常工作,您需要删除如下: PriorityQueue[] P = new PriorityQueue[10]; P[1] = new PriorityQueue(); ClassEntry entry = new ClassEntry(10,4); P[1].add(entry); //remove object with the...

    ClassEntry必须覆盖并实现Object.equals(Object o)以便移除才能工作.例如:

    class ClassEntry{

    float a;

    int b;

    public ClassEntry(float a, int b){

    //...

    }

    @Override

    public boolean equals(Object o){

    if(o instanceof ClassEntry){

    ClassEntry c = (ClassEntry)o;

    return a == c.a && b == c.b;

    }

    return false;

    }

    }

    编辑:正如@Jim Garrison所指出的,如果你没有实现等于默认行为,即使用引用来比较对象.在这种情况下,要使代码正常工作,您需要删除如下:

    PriorityQueue[] P = new PriorityQueue[10];

    P[1] = new PriorityQueue();

    ClassEntry entry = new ClassEntry(10,4);

    P[1].add(entry);

    //remove object with the same reference as the added one

    P[1].remove(entry);

    展开全文
  • } } } //向上调整 在堆增加元素 public Boolean isFull(){ return this.usedsize==this.elem.length; } public void shiftUp(int data){ if(isFull()){ this.elem= Arrays.copyOf(this.elem,2*this.elem.length);...
    public class MyHeap {
        int elem[];
        int usedsize;
        MyHeap(){
            this.elem=new int[10];
        }
        //向下调整,将堆变为大根堆
        public void shiftdown(int parent,int len){
        int child=(parent*2)+1;
        while(child<len){
            if(child+1<len && this.elem[child]<this.elem[child+1]){
                child++;
            }
            if(this.elem[child]>this.elem[parent]){
                int temp=this.elem[parent];
                this.elem[parent]=this.elem[child];
                this.elem[child]=temp;
                parent=child;
                child=parent*2+1;
            }else{
                break;
            }
        }
        }
        //向上调整  在堆中增加元素
        public Boolean isFull(){
            return this.usedsize==this.elem.length;
        }
        public void shiftUp(int data){
            if(isFull()){
                this.elem= Arrays.copyOf(this.elem,2*this.elem.length);
            }
            this.elem[this.usedsize]=data;
            int parent=(this.usedsize-1)/2;
            int child=this.usedsize;
            while(parent>=0){
                if(this.elem[child]>this.elem[parent]){
                    int temp=this.elem[child];
                    this.elem[child]=this.elem[parent];
                    this.elem[parent]=temp;
                    child=parent;
                    parent=(child-1)/2;
                }else{
                    break;
                }
            }
            this.usedsize++;
        }
        //出队列
        public boolean isempty(){
            if(this.usedsize==0){
                return true;
            }
            return false;
        }
        public void deleteElem(){
            if(isempty()){
                return;
            }
            this.elem[0]=this.elem[this.usedsize-1];
            this.usedsize--;
            createHeap();
        }
        //获取堆顶元素
        public int getTop(){
            return this.elem[0];
        }
        public void travel(int[]elem){
            for(int i=0;i<elem.length;i++){
                this.elem[i]=elem[i];
                this.usedsize++;
            }
        }
       //大根堆创建函数
        public void createHeap(){
            for(int i=(this.usedsize-1)/2;i>=0;i--){
                shiftdown(i,this.elem.length);
            }
        }
        public void display(){
            for(int i=0;i<usedsize;i++){
                System.out.print(this.elem[i]+" ");
            }
            System.out.println();
        }
    }

    图示:

     

     

    展开全文
  • 添加元素(Sift Up) 不断往上比较是否大于父节点元素,...//交换动态数组的位置 public void swap(int i,int j){ if(i&lt; 0 || i&gt;=size || j&lt;0 || j&gt;=size) throw new Illegal...

    添加元素(Sift Up)

    不断往上比较是否大于父节点元素,一直比较小于父节点的时候,位置找到了

    这就有点像上浮,不断往上交换

    交换代码

    //交换动态数组中的位置
        public void swap(int i,int j){
        	if(i< 0 || i>=size || j<0 || j>=size)
        		throw new IllegalArgumentException("下标错误");
        	
        	E t=data[i];
        	data[i]=data[j];
        	data[j]=t;
        }

    添加元素,添加末尾,

    然后比较一直循环比较,交换

        //向堆中添加元素
    	public void add(E e){
    		data.addLast(e);
    		siftUp(data.getSize()-1);
    	}
    	
    	//上浮siftUp
    	private void siftUp(int k){
    		
    		while(k >0 && data.get(parent(k)).compareTo(data.get(k)) < 0){
    			data.swap(k,parent(k));//交换位置
    			k=parent(k);
    		}
    	}

     

     

    取出元素(Sift Down)

    取出元素和上浮一样的思路,但是是下浮,

    不断往下比较,一直找到大于左节点、右节点的位置,结束

    取出最大的元素,也就是队首,取出来之后就为0然后与队尾进行交换,然后循环比较

        //看堆中的最大元素
    	public E findMax(){
    		if(data.getSize() ==0)
    			throw new IllegalArgumentException("没有元素");;
    		return data.get(0);
    	}
    	
    	//取出堆中最大元素
    	public E extractMax(){
    		
    		E ret =findMax();
    		
    		data.swap(0, data.getSize()-1);//交换最后的元素
    		data.removeLast();//删除最后一个元素
    		siftDown(0);//下浮,不断往下面进行匹配 直到找到符合的位置
    		
    		return ret;
    	}
    	
    	//下浮 和上浮一样的思路 只是往下一直循环进行交换位置
    	private void siftDown(int k){
    		
    		//k的左节点小于最大元素 循环条件
    		while(leftChild(k) < data.getSize()){
    			
    			int j=leftChild(k);
    			if(j+1 <data.getSize() &&
    					data.get(j+1).compareTo(data.get(j)) >0)//左节点小于右节点 条件允许
    				j=rightChild(k);
    			//data[j]是leftChild和rightChild中最大值
    
    			//当父节点都大于左节点和右节点都符合 位置就找到了 循环结束
    			if(data.get(k).compareTo(data.get(j)) >=0)
    				break;
    			
    			//否则一直交换
    			data.swap(k, j);
    			k=j;
    		}
    	}

     

    展开全文
  • * @Abstract : 去除数组特定值 * @Crete Date : 11/10/2018. * @Author : shaoguang. */ #include &lt;math.h&gt; // fabs /** * @param pArray : 要去除数据的原数组。 * @param nLen : 要...
  • 学习记录:利用指针删除数组中特定元素' #include<stdio.h> #define N 10 void del( int *p, int *q, int k ); int main(){ int a[N] = {0,1,2,3,4,5,6,7,8,9,}; int k, i; printf ("Please input number...
  • 原创: SnailClimb JavaGuide今天带各位回顾一下线性数据结构:数组、链表、栈、队列,相信通过下面的文字,你会加深对这几种数据结构的认识。一 数组数组(Array) 是一种很常见的数据结构。它是由相同类型的元素...
  • 一、创建一个列表只要把逗号分隔的不同的数据项使用方括号括起来即可。与字符串的索引一样,列表索引从0开始。列表可以进行截取、组合等。...如下所示:以上实例输出结果:四、删除列表元素可以使用...
  • python中删除某个元素的3种方法

    千次阅读 2019-11-04 14:56:09
    python关于删除list的某个元素,一般有三种方法:remove、pop、del 1.remove: 删除单个元素删除首个符合条件的元素,按值删除 举例说明: >>> str=[1,2,3,4,5,2,6] >>> str.remove(2) >>...
  • redis对于删除list的某个元素

    千次阅读 2019-05-22 15:57:00
    对于list中特定值的删除。我们打算获取全部的list全部的内容,然后便来你找到要删除的值,通过LREM key count value 删除。 LREM key count value 根据参数 count 的值,移除列表与参数 value 相等的元素...
  • C++之list删除元素

    千次阅读 2020-12-25 13:43:49
    (1)clear():删除list容器的所有元素 (2)remove(value):删除容器所有为value的元素 (3)remove_if():删除容器满足条件的元素 (4)unique():删除容器相邻的重复元素,只留下一个 (5)...
  • 然而在某些情况下,我们需要找到最大值,最小值,或某些特定元素进行删除,这个时候我们就可以用优先队列来实现这种需求。 1.1 最大优先队列 可以获取并删除最大的值。 实现方式和上篇讲的堆大同小异,因此不再...
  • Java 数据结构—— 队列、栈 【Java】Java队列Queue使用详解 压入元素(添加):add()、offer() 弹出元素(删除):remove()、poll() 获取队头元素(不删除):element()、peek() java 栈的实现 Stack: ArrayDeque: 采用...
  • 与日常生活的排队相类似,队列是一种遵循先进先出原则的数据结构。本文主要介绍了队列的定义、利用数组实现队列、利用链表实现队列等内容。
  • java栈和队列

    2021-03-06 20:52:47
    一、栈(stack) ...查看堆栈顶部的对象,但不从堆栈移除它。 3 Object pop( ) 移除堆栈顶部的对象,并作为此函数的值返回该对象。 4 Object push(Object element) 把项压入堆栈顶部。 5 int search(Object
  • 双向队列:支持插入删除元素的线性集合 特性: 插入、删除、获取操作支持两种形式: 快速失败和返回null或true/false 既具有FIFO特点又具有LIFO特点,即是队列又是栈 不推荐插入null元素,null作为特定返回值表示队...
  • java实现队列(queue)数据结构

    千次阅读 2022-02-01 21:57:08
    概念 队列是一种非原始(特殊)的线性表,是一种先进先出(FIFO)的数据结构。...队列中两个主要操作 插入值操作:insert ——》 enqueue(入队) ——》参数是要插入的数据data 删除值操作:remove ——》 deque
  • 今天我们来盘点一下Java的Queue家族,总共涉及到18种Queue。这篇恐怕是市面上最全最细讲解Queue的。本篇主要内容如下:本篇主要内容帮你总结好的阻塞队列:18种Queue总...
  • 文章目录线性表栈队列二叉树 ...线性表、堆栈和队列三者的数据元素之间的逻辑关系完全相同,差别是:线性表的插入和删除操作不受限制,而堆栈只能在栈顶插入和删除队列只能在队尾插入,在队头删除。 堆栈和队列
  • 1.概述 ...同步阻塞队列(SynchronousQueue):队列中不存储元素队列中放入元素后,只有该元素被消费完成,才能重修放入元素; 优先级无界阻塞队列(PriorityBlockingQueue):底层基于数组的无界队列,支
  • 队列是一种先进先出 (First Input First Output,FIFO) 的数据结构,元素队列尾追加,而从队列删除。 入队列队列 优先队列元素被赋予优先级。当访问元素时,具有最高优先级的元素最先删除。优先队列具有...
  • Java队列 Deque

    2021-10-18 16:21:10
    我们知道,Queue 是队列,只能一头进,另一头出。 如果把条件放松一下,允许两头都进,两头都出,这种队列叫双端队列(Double Ended Queue),学名Deque。...添加元素到队尾 add(E e) / offer(E e) addLast(E e) / o
  • 删除数组中特定元素 $arr1 = array(1,3, 5,7,8); $key = array_search(3, $arr1); if ($key !== false){  array_splice($arr1, $key, 1); } var_dump($arr1); 输出: array(1, 5,7,...
  • 数据结构——栈和队列 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。 数据结构简介 顺序结构 我们对...
  • 队列的每个方法都以两种形式存在:一种是当操作失败时抛异常,另一种是返回一个特定的值(null或者false,取决于具体操作)。 后一种形式的插入操作是专门设计用于有界队列实现的,在大多情况下,插入操作不会失败。...
  • 前言 queue :一个队列就是一个先入先出(FIFO)的数据结构 ...它的出队顺序与元素的优先级有关,对PriorityQueue调用remove()或poll()方法,返回的总是优先级最高的元素。而对于什么是优先级最高的
  • 转 kafka 清理数据

    2020-12-24 21:17:54
    由于项目原因,最近经常碰到Kafka消息队列拥堵的情况。碰到这种情况为了不影响在线系统的正常使用,需要大家手动的清理Kafka Log。但是清理Kafka Log又不能单纯的去删除中间环节产生的日志,中间关联的很多东西需要...
  • 特定元素入队循环队列\n" "3. 出队循环队列\n" "4. 展示当前循环队列中的存储情况\n\n"); scanf("%d", &opt); switch (opt) { case 1: InitQueue(&Q); // 传入地址,给指针变量接收 break; case 2: printf("\n要...
  • 数据结构之阻塞队列

    2022-03-15 16:46:51
    本文一起来看下Java阻塞队列相关内容。 1:队列 队列是一种先进先出FIFO的数据结构,是一种线性数据结构,一般有两种实现方式,一种是基于数组实现,另外一种是基于链表实现。接下来分别来看下。 1.1:基于数组...
  • 队列是另外一种限定性的线性表,只允许在表的一端插入元素,在另一端删除元素 队列具有先进先出的特性 允许插入的一端叫做队尾 允许删除的一端叫做队头 队列应用:操作系统的作业排队 队头和队尾都是动态变化的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,556
精华内容 27,422
关键字:

删除队列中的特定元素