精华内容
下载资源
问答
  • 什么是ArrayList ArrayList是JDK自带的基础工具类 存储路径在:java.util.ArrayList ...boolean add(Element e) //增加指定元素链表尾部. void add(int index, Element e) //增加指定元素到链表指定位置....

    什么是ArrayList

    ArrayList是JDK自带的基础工具类
    存储路径在:java.util.ArrayList
    可以使用类似于数组的索引
    也可以使用链表的方式添加和删除数据

    ArrayList常用方法

    增加元素到链表中

    boolean add(Element e) //增加指定元素到链表尾部.
    void add(int index, Element e) //增加指定元素到链表指定位置.

    从链表中删除元素

    void clear() //从链表中删除所有元素.
    E remove(int index) //删除链表中指定位置的元素.
    protected void removeRange(int start, int end) //删除链表中从某一个位置开始到某一个位置结束的元素。

    获取链表中的元素

    E get(int index) //获取链表中指定位置处的元素.
    Object[] toArray() //获取一个数组,数组中所有元素是链表中的元素.(即将链表转换为一个数组)

    修改某个元素

    E set(int index, E element) //将链表中指定位置上的元素替换成新元素。

    搜索元素

    boolean contains(Object o) //如果链表包含指定元素,返回true.
    int indexOf(Object o) //返回元素在链表中第一次出现的位置,如果返回-1,表示链表中没有这个元素。
    int lastIndexOf(Object o) //返回元素在链表中最后一次出现的位置,如果返回-1,表示链表中没有这个元素。

    检查链表是否为空

    boolean isEmpty() //返回true表示链表中没有任何元素.
    获取链表大小
    int size()//返回链表长度(链表包含元素的个数).

    创建和使用ArrayList

    ArrayList Lst = new ArrayList();//创建Arraylist
    
    for(in i = 0; i < 10; i++)
    	Lst.add(i);//给ArrayList添加元素
    int size = Lst.size();//获取ArrayList元素个数
    
    //遍历ArrayList
    for(int i=0; i < 10; i++)
    {
    	int now = (int) Lst.get(i);
    	System.out.println("遍历到:" + now);
    }
    
    Lst.add(4, 5);//在第五个位置插入元素5
    Lst.set(4, 6);//将第五个元素修改为6
    Lst.remove(4);//删除第五个元素
    boolean ct = Lst.contains(3);//检查ArrayList中是否包含3这个元素
    int idf = Lst.indexOf(9);//9这个元素第一次在ArrayList中出现的位置
    int idl = Lst.lastIndexOf(2);//2这个元素最后一次在ArrayList中出现的位置
    
    //将ArrayList转换为数组
    int[] values = (int[])Lst.toArray(typeof(int));
    
    Lst.removeRange(1, 3);//删除第二个到第四个元素
    Lst.clear();//清空ArrayList
    boolean ept = Lst.isEmpty();//检查ArrayList是否为空
    
    展开全文
  • Java实现循环链表

    千次阅读 2016-03-30 22:03:17
    本案例需要完成的任务定义如下:实现一个循环链表(单链表),具备增加元素、删除元素、打印循环链表等功能。网上许多同类问题的实现方式过于复杂、难懂,本文旨在提出一种实现循环链表的简单、易懂的方法。 对于...

    本案例需要完成的任务定义如下:实现一个循环链表(单链表),具备增加元素、删除元素、打印循环链表等功能。

    网上许多同类问题的实现方式过于复杂、难懂,本文旨在提出一种实现循环链表的简单、易懂的方法。

     

    定义链表节点:

    对于每一个链表节点,关键要素是节点自身数值data以及所指向的下一个节点next。

    package circularLinkedList;
    
    public class Node {
    	//元素类型为int的节点
    	private int data;
    	private Node next;
    	//定义构造器
    	public Node(int i, Node nt){
    		data = i;
    		next = nt;
    	}
    	public Node(int i){
    		this(i,null);
    	}
    	public Node(){
    		this(0,null);
    	}
    	//更改元素数值
    	public void setData(int i){
    		data = i;
    	}
    	//读取元素数值
    	public int getData(){
    		return data;
    	}
    	//更改元素的指向
    	public void setNext(Node nt){
    		next = nt;
    	}
    	//读取元素的指向
    	public Node getNext(){
    		return next;
    	}
    }
     

    定义循环链表:

    对于循环链表而言,关键要素是指定链表的头节点head、尾节点tail以及链表大小size;该数据结构支持在头部增加节点、在尾部增加节点,从头部删除节点及从尾部删除节点等。

    package circularLinkedList;
    
    public class Linkedlst {
    	private Node head;
    	private Node tail;
    	int size;
    	//构造器
    	public Linkedlst(){
    		tail = head = null;
    		size = 0;
    	}
    	
    	//在链表头部增加节点
    	public void addHead(Node hd){
    	//如果使用该方法增加链表的第一个节点,则head=tail=hd,且next指向自身。
    		if(size==0){
    			hd.setNext(hd);
    			tail = head = hd;
    			size++;
    		}
    		else{
    				tail.setNext(hd);
    				hd.setNext(head);
    				head = hd;
    				size++;
    		}
    	}
    	
    	//在链表尾部增加节点
    	public void addTail(Node tl){
    	//如果使用该方法增加链表的第一个节点,则tail=head= hd,且next指向自身。
    		if(size==0){
    			tl.setNext(tl);
    			tail = head = tl;
    			size++;
    		}
    		else{
    			tail.setNext(tl);
    			tl.setNext(head);
    			tail = tl;
    			size++;
    		}
    	}
    	
    	//删除头部节点,被删掉的head将被自动回收
    	public void delHead(){
    		if(size>1){
    			head = head.getNext();
    			tail.setNext(head);
    			size--;
    		}
    		else if(size==1){
    			head = tail = null;
    			size--;
    		}
    		else{
    			System.out.println("There is no elements in the linked list.");
    		}
    	}
    	
    	//删除尾部节点
    	public void delTail(){
    		if(size>1){
    			Node nd = new Node();
    			nd = head;
    			while(nd.getNext()!=tail){
    				nd = nd.getNext();
    			}
    			nd.setNext(head);
    			size--;
    		}
    		else if(size==1){
    			head = tail = null;
    			size--;
    		}
    		else{
    			System.out.println("There is no elements in the linked list.");
    		}		
    	}
    	
    	//打印全部节点
    	public void printList(){
    		Node nd = new Node();
    		nd = head;
    		try{
    			while(nd.getNext()!=head){
    				System.out.print(nd.getData());
    				System.out.print("->");
    				nd = nd.getNext();
    			}		
    			System.out.print(nd.getData());
    			System.out.print("->");
    			System.out.print(head.getData());
    		}
    		catch(Exception e){			
    			e.printStackTrace();
    		}
    		
    	}
    }

     

    测试程序:

    测试了打印循环链表元素、删除首端节点等方法,运行正常。

    package circularLinkedList;
    
    public class LinkedlstTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Linkedlst lst = new Linkedlst();
    		Node head = new Node(11,null);
    		lst.addHead(head);
    		lst.addTail(new Node(22));
    		lst.addTail(new Node(33));
    		System.out.println("打印链表:");
    		lst.printList();
    		System.out.println();
    		System.out.println("删除首端节点:");
    		lst.delHead();
    		lst.printList();
    		System.out.println();
    		System.out.println("删除首端节点:");
    		lst.delHead();
    		lst.printList();		
    	}
    
    }
    


    展开全文
  • java链表及数组的区别

    2017-12-14 09:45:11
    如图所示 数组在删除或者增加的时候 起他元素的位置要改变,但是链表删除增加的 之后只需要改变他的next 和previous就可以。而数组的位置是固定的所以查找很方便,但是链表的查找需要从头或者尾部(size/2法则)去一...

    数组:数组在查询上通过索引会效率很高,但是在删除增加上面效率很低

    链表:java链表都是双向链表,在删除和增加上面效率会很高,但是在查询上面效率很低

    如图所示 数组在删除或者增加的时候 起他元素的位置要改变,但是链表在删除增加的 之后只需要改变他的next 和previous就可以。而数组的位置是固定的所以查找很方便,但是链表的查找需要从头或者尾部(size/2法则)去一个一个查找所以就慢,(ArrayList就是用数组实现,而LinkList就是链表实现)

    展开全文
  • 链表的C#代码实现

    2017-11-09 18:26:00
    尾部增加元素  2. 删除值为value的元素  3.反转链表 思路: 增加和反转都没啥说的,就删除的时候需要考虑到的情况比较多,直接上代码,回头再分析 1 class LinkNode<T> 2 { 3 public LinkNode...

    题目:  1.在尾部增加元素

         2. 删除值为value的元素

         3.反转链表

    思路:

    增加和反转都没啥说的,就删除的时候需要考虑到的情况比较多,直接上代码,回头再分析

      1     class LinkNode<T>
      2     {
      3         public LinkNode<T> Next { get; set; }
      4         public T Value { get; set; }
      5 
      6         public LinkNode<T> AddNodeToEnd(T value, LinkNode<T> head)
      7         {
      8             if (value != null)
      9             {
     10                 if (head == null)
     11                 {
     12                     head = new LinkNode<T>();
     13                     head.Value = value;
     14                     head.Next = null;
     15                 }
     16                 else
     17                 {
     18                     LinkNode<T> temp = head;
     19                     while (temp != null)
     20                     {
     21                         if (temp.Next == null)
     22                         {
     23                             temp.Next = new LinkNode<T>();
     24                             temp.Next.Value = value;
     25                             break;
     26                         }
     27                         temp = temp.Next;
     28                     }
     29                 }
     30             }
     31             return head;
     32         }
     33 
     34         //public LinkNode<T> Remove(T value, LinkNode<T> head)
     35         //{
     36         //    LinkNode<T> pre = null;
     37         //    LinkNode<T> now = null;
     38         //    if (value != null)
     39         //    {
     40         //        if (head != null)
     41         //        {
     42         //            pre = head;
     43         //            if (head.Value.Equals(value) && head.Next == null)
     44         //            {
     45         //                head = null;
     46         //                return head;
     47         //            }
     48         //            if (head.Next != null) { now = head.Next; }
     49         //            while (now != null)
     50         //            {
     51         //                if (head.Value.Equals(value))
     52         //                {
     53         //                    head.Next = null;
     54         //                    head = now;
     55         //                    pre = head;
     56         //                    if (head.Next != null) { now = head.Next; }
     57         //                    else now = head; 
     58         //                }
     59         //                if (now.Value.Equals(value))
     60         //                {
     61         //                    if (now.Next != null)
     62         //                    {
     63         //                        LinkNode<T> next = now.Next;
     64         //                        pre.Next = next;
     65         //                        now.Next = null;
     66         //                        pre = pre.Next;
     67         //                        now = pre.Next;
     68         //                        continue;
     69         //                    }
     70         //                    else
     71         //                    {
     72         //                        if (pre == now) return null;
     73         //                        pre.Next = null;
     74         //                        break;
     75         //                    }
     76         //                }
     77         //                pre = now;
     78         //                now = now.Next;
     79 
     80         //            }
     81         //        }
     82         //    }
     83         //    return head;
     84         //}
     85 
     86         public LinkNode<T> Remove(T value, LinkNode<T> head)
     87         {
     88             LinkNode<T> pre = null;
     89             LinkNode<T> now = null;
     90             if (value != null)
     91             {
     92                 if (head != null)
     93                 {
     94                     //如果只有一个元素head
     95                     if (head.Next == null)
     96                     {
     97                         //如果head就是要找的那个
     98                         if (head.Value.Equals(value))
     99                         {
    100                             head = null;
    101                         }
    102                     }   
    103                     //如果有两个以上的元素                
    104                     else
    105                     {
    106                         pre = head;
    107                         now = head.Next;
    108                         while (now != null)
    109                         {
    110                             if (pre.Value.Equals(value))
    111                             {
    112                                 //如果第一个就遇到了value
    113                                 if (pre == head)
    114                                 {
    115                                     head = head.Next;
    116                                     pre = head;
    117                                     if (pre == null) break;
    118                                     if (pre.Next != null) now = pre.Next;
    119                                     else now = pre;
    120                                 }
    121                                 else
    122                                 {                                    
    123                                     if (now.Next != null)
    124                                     {
    125                                         pre.Next = now.Next;
    126                                         now = now.Next;
    127                                     }
    128                                     else break;
    129                                 }
    130                             }
    131                             else
    132                             {
    133                                 if (now.Value.Equals(value))
    134                                 {
    135                                     if (now.Next != null && pre == head)
    136                                     {
    137                                         pre.Next = now.Next;
    138                                         now = pre.Next;
    139                                         continue;                                     
    140                                     }
    141                                     else if (now.Next != null)
    142                                     {
    143                                         now = now.Next;
    144                                     }                                    
    145                                     else pre.Next = null;
    146                                 }
    147                                 if (now.Next != null)
    148                                 {
    149                                     now = now.Next;
    150                                     pre = pre.Next;
    151                                 }
    152                                 else break;
    153                             }
    154                                                       
    155                         }
    156                     }                   
    157                 }
    158             }
    159             return head;
    160         }
    161         public LinkNode<T> Revert(LinkNode<T> head)
    162         {
    163             LinkNode<T> pre = null;
    164             LinkNode<T> now = null;
    165             LinkNode<T> next = null;
    166 
    167             if (head != null && head.Next != null)
    168             {
    169                 pre = head;
    170                 now = head.Next;
    171                 while (now != null)
    172                 {
    173                     if (pre == head && now.Next == null)
    174                     {
    175                         pre = head;
    176                         now.Next = pre;
    177                         head = now;
    178                         pre.Next = null;
    179                         return head;
    180                     }
    181                     else
    182                     {
    183                         if (pre == head)
    184                         {
    185                             pre.Next = null;
    186                         }
    187                         next = now.Next;
    188                         now.Next = pre;
    189                         pre = now;
    190                         now = next;
    191                     }
    192                 }
    193                 head = pre;
    194             }
    195             return head;
    196         }
    197     }

    主函数:

     1  static void Main(string[] args)
     2         {
     3             LinkNode<string> s = new LinkNode<string>();
     4             s = s.AddNodeToEnd("1", null);
     5             s = s.AddNodeToEnd("2", s);
     6             s = s.AddNodeToEnd("3", s);
     7             s = s.AddNodeToEnd("5", s);
     8             s = s.AddNodeToEnd("1", s);
     9             s = s.Remove("3", s);
    10             s = s.Revert(s);
    11             Console.ReadKey();
    12         }

     

     

         

    转载于:https://www.cnblogs.com/hehe625/p/7810834.html

    展开全文
  • 链表失去了顺序表随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大,但对存储空间的使用要相对灵活。 链表与顺序表的各种操作复杂度如下所示: 操作 链表 顺序表 访问元素 O(n) O(1...
  • 链表与顺序表的对比

    2017-12-04 19:09:38
    链表失去了顺序表随机读取的优点,同时链表由于增加了节点的指针域,空间开销比较大,但对存储空间的使用要相对灵活。...在尾部插入/删除链表O(n),顺序表O(1) 在中间插入/删除链表O(n),顺序表O(n)
  • 即使增加尾部节点的引用,也只能支持O(1)时间的首端元素加入/删除和尾端加入.如果希望两端插入和删除操作都能高效的完成,就必须修改结点的基本设计,加入另一个方向的链接,这样就得到了双向链接表,简称双链表...
  • 基础知识 顺序表就是一个数组!!! 只不过数组是被限制的 顺序表是内存地址连续的, 顺序表方便查询 追加 遍历 不适合做删除和插入 因为会频繁的进行赋值操作 ...增加链表删除链表都得找到谁? 要操作的...
  • 【6】:追加操作,在单链表的表尾增加元素 【7】:在指定位置前,插入一个结点 【8】:在指定位置之后,插入一个结点 【9】:删除单链表中指定位置的结点 【10】:取单链表中指定位置的数据元素 【11】:按值查找...
  • 第二章 栈、队列、链表 完整代码下载 第一节 队列 首先,引入两个整形变量 head 和 tail 分别...队列 : 队列是一种特殊的线性结构,它只允许在队列的首部(head)进行删除操作,这称为“出队”,而在队列的尾部(ta...
  • ArrayList的用法和定义 ...增加指定元素到链表尾部. void add(int index, Element e) 增加指定元素到链表指定位置. 1.1.2从链表中删除元素 void clear() 从链表中删除所有元素. E remove(int index) 删除链...
  • 单链表操作

    2020-12-17 21:43:57
    链表尾部添加元素 链表指定位置添加元素 链表删除节点 查找节点是否存在 二:代码实现 (一):定义节点类 作用:数据保存在节点中,通过增加节点达到增加数据的目的 class Node: def __init__(self,elem): self....
  • 文章目录线性表线性表的定义抽象数据类型数据类型抽象抽象数据类型线性表的抽象数据类型定义顺序表顺序表的两种基本实现方式顺序表的地址计算方法顺序表的操作获得元素操作增加元素删除操作插入和删除的时间复杂度...
  • 数据结构

    2019-09-24 09:20:09
    add:会在链表尾部增加元素 contains:判断一个元素在不在链表中 list.listIterator(n)会返回一个迭代器,在索引为n这个元素的前面 尽量不要用get方法来遍历链表(不能直接过去,需要从头...
  • C++实现LRU Cache

    2019-08-02 16:50:14
    1、算法思路: put操作思路: 用一个双向链表和一个哈希表; 每添加一个(key, value),先判断是否在哈希...最后判断是否超过capacity,若超过则弹出链表尾部元素删除哈希表中该键值对。 优化: 哈希表中保存<...
  • 时间复杂度的对比: ...从尾部删除元素 O(n) O(1) 在中间插入元素 O(n) O(n) 总结: 链表失去了顺序表随机读取的优点,同时链表由于增加了节点的指针域,空间开销比较大,但对存...
  • ArrayList与LinkedList

    2019-05-27 15:16:53
    1)ArratList底层采用数组实现,LinkedList底层采用双向链表实现 2)当执行插入或删除操作时,采用LinkedList...增加指定元素链表尾部. void add(int index, Element e) 增加指定元素到链表指定位置. 从链表...
  • 4单链表

    2020-07-10 12:06:17
    1.链表创建不需确定大小,增加删除元素效率高,查找慢。 2.链表就像一个火车,车厢保存元素(人),链接指向下一个车厢 3.链表中的常见操作: append(element):向链表尾部添加一个新的项; insert...
  • addLast(E e):在链表尾部添加一个元素删除: remove() :移除链表中第一个元素; remove(index i):移除指定元素; pop():删除第一个元素 poll():返回第一个元素并移除 查: get(int index):按照下标获取元素...
  • 跳表

    2021-04-02 22:55:43
    跳表,在有序链表的基础上增加了"跳跃"的功能,使得有序链表的的搜索,删除,添加的平均时间复杂度是O(logn) Redis中的SortedSet,LevelDB中的MemTable都用到了跳表 Redis,LevelDB都是著名的Key-Value数据库 ...
  • 成员函数:初始化、在尾部增加元素、查询指定数据的元素、在指定元素前插入一新元素删除指定元素、遍历链表中的元素、输出所有链表中的元素、将一个单链表逆序(选作)。 原理 类的成员可以是其他类的对象,称为...
  • 用Java语言实现栈

    2021-02-19 14:06:01
    栈的底层其实就是线性表,可以用链表或者动态数组实现,且由其在线性表尾部频繁增加删除元素的特点,使用链表与动态数组的性能差不多。 出栈: 入栈: 链表的接口设计 方法声明 功能介绍 int size() 返回...
  • 跳表(Skip List)

    2020-09-22 20:08:17
    跳表(SkipList) 1. 跳表,又叫做跳跃表、跳跃列表...1. 从顶层链表的首元素开始,从左往右搜索,直至找到一个大于或等于目标的元素,或者到达当前层链表尾部 2. 如果该元素等于目标元素,则表明该元素已被找到 3.
  • 和数据结构中的普通链表一样,可以在其头部和尾部添加新的元素。在插入时,如果该键不存在,Redis将为该键创建一个新的链表。与此相反,如果链表中所有的元素均被移除,那么该键也将会被从数据库中删除。 一、增 ...
  • LinuxC语言——通讯录

    2020-09-09 10:25:44
    LinuxC语言——通讯录制作通讯录的一些基础知识功能代码链表节点创建节点插入 增加节点到链表头节点插入 增加节点到链表尾部节点查找(姓名、号码)节点删除显示节点主函数逻辑运行效果 通讯录是许多手机等电子产品...
  • 1.5 Redis之List类型

    2021-04-11 10:25:27
    和数据结构中的普通链表 一样,我们可以在其头部(left)和尾部(right)添加新的元素。在插入时,如果该键并不 存在,Redis将为该键创建一个新的链表。与此相反,如果链表中所有的元素均被移 除,那么该键也将会被从...
  • 只写了 增加元素的代码,删除修改类似。 增加元素  增加元素分为首部,尾部,任意位置三种,  首部,首先判断head是否为空,head不为空时将新加的元素的next 指向 原head的内存地    尾部,需要通过扫描找....
  • Python数据结构与算法:第3-8课时:单链表与顺序表的对比 链表与顺序表的对比 链表失去了顺序表随机读取的优点,同时链表由于增加了结点的指针域...因为除了目标元素尾部的特殊情况,顺序表进行插入和删除时需要对

空空如也

空空如也

1 2 3
收藏数 52
精华内容 20
关键字:

链表尾部增加删除元素