精华内容
下载资源
问答
  • 在一维数组删除指定位置元素,现定义第一个元素位置为1,一维数组元素个数不确定,需要动态输入,并返回删除元素后的数组以及被删除的元素。 例如输入数组个数为n = 4;将要删除的数组元素位置是2; 在这里插入...

    题目
    在一维数组删除指定位置元素,现定义第一个元素位置为1,一维数组元素个数不确定,需要动态输入,并返回删除元素后的数组以及被删除的元素。
    例如输入数组个数为n = 4;将要删除的数组元素位置是2;

    #include <stdio.h>
    #include <string.h>
    #define MAXN 20
    void delete_arr(int *a, int M, int *val, int *n);   /*删除指定位置的元素*/
    int main(void){
        int N, M;             //N是数组个数
        int i;
        int a[MAXN];
        int val;              //val是用来存储被删除的元素
        printf("请输入数组个数:");
        scanf("%d", &N);
        printf("请输入将要删除元素的位置(1-%d):", N);
        scanf("%d", &M);      //M是待删除的元素的位置,第一个元素位置为1;
        if(M < 1 || M > N)
            return 0;
        printf("输入数组%d个元素:", N);
        for(i = 0;i < N; i++){
            scanf("%d", &a[i]);
        }
        delete_arr(a, M, &val, &N);
    
        printf("删除的元素是:%d\n", val);
        printf("输出删除元素后的数组:");
        for(i = 0;i < N; i++){
            printf("%d ", a[i]);
        }
        printf("\n");
        return 0;
    }
    
    void delete_arr(int *a, int M, int *val, int *n){  //M是位置,val是被删除的值,n是数组个数
        *val = a[M - 1];
        for(int i = M; i < *n; i++){
            a[i - 1] = a[i];
        }
        *n = *n - 1;
    }
    

    输出结果如下:
    在这里插入图片描述

    展开全文
  • 元素x插入到顺序表L(数组)的第i个数据元素之前 function InsertSeqlist(L, x, i) { // 将元素x插入到顺序表L的第i个数据元素之前 if(L.length == Maxsize) { console.log('表已满'); return; } ...

     将元素x插入到顺序表L(数组)的第i个数据元素之前

    function InsertSeqlist(L, x, i) {
        // 将元素x插入到顺序表L的第i个数据元素之前
        if(L.length == Maxsize) {
            console.log('表已满');
            return;
        }
        if(i < 1 || i > L.length) {
            console.log('位置错');
            return;
        }
        for(var j = L.length;j >= i;j--) {
            L[j] = L[j - 1]; // 向右移一位
        }
        //L.length++;
        L[i - 1] = x;
    
        return L;
    }
    
    var L = [1, 2, 3, 4, 5, 6, 7];
    var Maxsize = 10;
    
    console.log(InsertSeqlist(L, 'new1', 5));
    console.log(InsertSeqlist(L, 'new2', 7));

     删除线性表L中的第i个数据结构

    function DeleteSeqList (L, i) {
        // 删除线性表L中的第i个数据结构
        if(i < 0 || i > L.length) {
            console.log('非法位置');
            return;
        }
        delete L[i];
        for(var j = i;j < L.length;j++); {
            L[j - 1] = L[j];    // 向左移动
        }
        L.length--;
        return L;
    }

     

    转载于:https://www.cnblogs.com/lqcdsns/p/6438071.html

    展开全文
  • Java 实现从数组删除指定位置元素

    千次阅读 2016-04-02 17:37:37
    Java 实现从数组删除指定位置元素,比较通过遍历和copy array两种方式的性能差别

    思路

    1.  因为数组长度在初始化的时候是指定的并且不可变的,所以不能在原有的数组上直接进行删除操作,需要新建一个长度为当前长度减1的数组

    2.  向新数组写数据


    /**
         * remove element at the specified position from the given array by loop
         * 
         * @param array
         * @param position
         * @return
         */
        public static String[] removeElementByLoop(String[] array, int position) {
            if (position < 0 || position > array.length) {
                throw new IndexOutOfBoundsException("the position is out of the array indices");
            }
            long startTime = System.currentTimeMillis();
            String[] newArray = new String[array.length - 1];
            int index = position - 1;
            for (int i = 0; i < array.length; i++) {
                if (i < index) {
                    newArray[i] = array[i];
                } else if (i > index) {
                    newArray[i - 1] = array[i];
                }
            }
            System.out.println("took:" + (System.currentTimeMillis() - startTime) + " ms by loop solution");
            return newArray;
        }
    
        /**
         * remove element at the specified position from the given array by copy
         * 
         * @param array
         * @param position
         * @return
         */
        public static String[] removeElementByCopy(String[] array, int position) {
            int length = array.length;
            if (position < 0 || position > length) {
                throw new IndexOutOfBoundsException("the position is out of the array indices");
            }
            long startTime = System.currentTimeMillis();
            String[] newArray = new String[array.length - 1];
            int index = position - 1;
            System.arraycopy(array, 0, newArray, 0, index);
            if (index < length - 1) {
                System.arraycopy(array, index + 1, newArray, index, length - index - 1);
            }
            System.out.println("took:" + (System.currentTimeMillis() - startTime) + " ms by copy solution");
            return newArray;
        }

    对比:
    从时间复杂度来说removeElementByCopy的性能能优于removeElementByLoop,因为removeElementByLoop是0(n)而removeElementByCopy是0(1)。

    从空间复杂度来说removeElementByLoop的性能能优于removeElementByCopy,因为removeElementByCopy需要更多次的swap。


    下面是测试结果
    1. 当原数组长度较少的时候.

    List<String> elements = new ArrayList<String>();
    for (int i = 0; i < 90000; i++) {
        elements.add(i + "");
    }
    String[] array = elements.toArray(new String[elements.size()]);
    int position = 80000;
    removeElementByCopy(array, position);
    removeElementByLoop(array, position);
    ---->
    took:0 ms by copy solution
    took:2 ms by loop solution

    2.
    List<String> elements = new ArrayList<String>();
    for (int i = 0; i < 1000000; i++) {
        elements.add(i + "");
    }
    String[] array = elements.toArray(new String[elements.size()]);
    int position = 80000;
    removeElementByCopy(array, position);
    removeElementByLoop(array, position);
    ---->
    took:7 ms by copy solution
    took:88 ms by loop solution


    从测试结果可以看出来,在执行时间上的花费,removeElementByCopy的效率明显高于removeElementByLoop


    展开全文
  • 容器-ListedList删除指定位置元素的源码分析(十一) 根据索引删除元素 import java.util.LinkedList; import java.util.List; public class LinkedListTest { public static void main(String[] args) { List<...

    容器-ListedList删除指定位置元素的源码分析(十一)

    1. 根据索引删除元素

      import java.util.LinkedList;
      import java.util.List;
      
      public class LinkedListTest {
          public static void main(String[] args) {
              List<String> list= new LinkedList<>();
              //添加元素
              list.add("a");
              list.add("b");
              list.add("c");
              list.add("a");
              list.add(2,"aaaa");
              
              //根据索引删除元素
              list.remove(2);
              ]
          }
      
    2. 看remove的源代码,先Ctrl进去

          E remove(int index);
      
      • 在用Ctrl+Alt选择remove方法的LinkedList接口实现类

        /**
             * Removes the element at the specified position in this list.  Shifts any
             * subsequent elements to the left (subtracts one from their indices).
             * Returns the element that was removed from the list.
             *
             * @param index the index of the element to be removed
             * @return the element previously at the specified position
             * @throws IndexOutOfBoundsException {@inheritDoc}
             */
            public E remove(int index) {
                checkElementIndex(index);//校验索引是否正常
                return unlink(node(index));
            }
        
      • 我们看 checkElementIndex(index);方法

            private void checkElementIndex(int index) {
                if (!isElementIndex(index))
                    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
                //如果isPositionIndex返回的是true,再取非,则不执行if条件语句,证明索引没问题
                //如果isPositionIndex返回的是false,再取非,则执行if条件语句,抛出异常
            }
        
      • 在进去看isElementIndex(index)

          /**
             * Tells if the argument is the index of an existing element.
             */
            private boolean isElementIndex(int index) {
                return index >= 0 && index < size;//注意这里的是索引要小于元素的个数,不能取等于,因为索引的个数是要比元素的个数少一个数的
            }
        
      • 当校验索引没有问题,就要看 unlink方法了,里面还有个node的方法。

            public E remove(int index) {
                checkElementIndex(index);//校验索引是否正常
                return unlink(node(index));
            }
        
      • 先看node方法

          /**
             * Returns the (non-null) Node at the specified element index.
             */
            Node<E> node(int index) {
                // assert isElementIndex(index);
        
                if (index < (size >> 1)) {
                    Node<E> x = first;
                    for (int i = 0; i < index; i++)
                        x = x.next;
                    return x;
                } else {
                    Node<E> x = last;
                    for (int i = size - 1; i > index; i--)
                        x = x.prev;
                    return x;
                }
            }
        
        
      • node的原理图
        在这里插入图片描述

      • 然后我们回去看 unlink方法,假设我们现在删除的是索引为2的节点,也就是删除已33为地址的节点。

        /**
             * Unlinks non-null node x.
             */
            E unlink(Node<E> x) {
                // assert x != null;
                final E element = x.item;//就是那个被删除的节点返回回去
                final Node<E> next = x.next;
                final Node<E> prev = x.prev;
        
                if (prev == null) {//删除的是头节点才会用到
                    first = next;
                } else {//假设我们现在删除的是索引为2的节点
                    prev.next = next;
                    x.prev = null;
                }
        
                if (next == null) {//删除的是最后一个节点,显然现在不是,我们走else
                    last = prev;
                } else {
                    next.prev = prev;
                    x.next = null;
                }
        
                x.item = null;//把33节点制为空,
                size--;//元素被删掉一个,被减一个
                modCount++;
                return element;//就是返回那个被删除的节点
            }
        
        
      • unlink方法,也就是删除指定元素的关键方法,就是把要删除的那个节点的两边的节点,想办法断开,在引用到两边的节点。原理图:
        在这里插入图片描述

    展开全文
  • 转载:http://www.php.cn/js-tutorial-412053.html
  • a = [0,1,2,3] del a[0] print(a)
  • insert插入: //在最前面的元素前插入8 v.insert(v.begin(),8); //在第二个元素前插入新元素1 v.insert(v.begin()+2,1); //在末尾插入新元素1 ... //删除单个元素,从0开始计数,删除第二个元素 ...
  •  printf("未找到该元素!\n"); } void Test2(SeqList *Seq) {  init(Seq);  PushBack(Seq, 0);  PushBack(Seq, 1);  PushBack(Seq, 2);  PushBack(Seq, 3);  PushBack(Seq, 4);  PushBack(Seq, 5)...
  • //功能:删除指定位置节点 //参数:头节点指针 void delete_list(struct list *head); //功能:回收内存 //参数:头节点指针 void destory(struct list *head); int main(){ struct list *head; head=setList...
  • 用vector 处理下就好了 我用vector进行的删除操作 注意 vector删除操作会造成所有数据平移,就像我们平时自己写代码把1------n赋值给0-----n-1一样 消耗比较大 感觉用list效果更好     #include #include...
  • pytorch 删除tensor中的指定位置元素

    千次阅读 2020-09-13 00:40:47
    删除指定位置元素或者具体某个值需要先用nonzero()获取到要删除的元素的索引位置,之后使用torch.cat()进行删除操作 import torch a = torch.randn(4,5).int() #生成一个随机的4,5 tensor print(a, a.size()) ...
  • C++将单个元素插入到数组指定位置或者删除指定位置的数组元素 在C++的三种容器中,string 和 vector都有插入和删除的函数,数组的插入是将目标位置的元素及之后的元素向后移一位,而删除操作是将目标位置之后的所有...
  • 相信大家的js的编写过程中一定会遇到这个问题,当我持有一个数组对象的时候,有时候需要往数组里面去插入元素删除元素,如果你要插入或删除元素是在数组的末尾,那么事情就很简单了,push and pop~ 但是如果我...
  • vector 我喜欢用位置表示元素,这里和别人用个数解释的不一样 删除元素:vec.erase(vec.begin()+i)  ...删除指定区间元素:vec.erase(vec.begin()+i,vec.begin()+j)  删除的是[i, j-1]位置元素。如果要包括j位
  • 删除指定位置上的元素
  • .pop()是删除list中指定位置元素,然后返回被删除的元素值。默认删除最后一个
  • -----------------------------------------使用DOM4J向xml中写入文档和删除指定元素、在指定位置插入元素------------------------------------ 将student对象写入xml文档中 Student类package cn.tx.dom4j;...
  • //在指定位置删除元素: cout 输入插入要删除的链表元素的位置:"; cin >> site; deleteE(list, site); outputList(list); //清空链表 cout 是否清除链表的所有节点? 输入1或0:"; int ifDelete; cin >> ifDelete; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,318
精华内容 1,327
关键字:

删除指定位置元素