学习JAVA—数据结构之单链表与数组的区别、以及实现zt

学习JAVA—数据结构之单链表与数组的区别、以及实现

http://blog.csdn.net/gg811/article/details/8466614 这是大牛地址

 
javaJavaJAVA单链表 数组数据结构

          第一部分是首先说下数组与链表的区别~数组是大家常用的而熟知的，利用链表对比数组这样可以加深对链表的记忆。第二部分就是链表的代码实现，加深理解。

关于单链表：

1、概念

                在单链表中由于数据元素的存储空间一般不是连续的，因此为了完善的表示单链表的逻辑结构，其中每一个数据元素必须由两部分构成：一部分是数据元素中的数据值，另一部分是数据元素的地址值。这两部分信息构成了单链表的一个节点。因此，在用单链表表示线性表时，每个结点的存储地址是任意的，即存储位置是无序的。

2、结构

                对于单链表来说，每个节点的结构都是（data，next），节点中有两个部分：data域—存放结点值的数据域，next—存放结点的直接后续的地址的链域。

 

数组与链表的区别：

1、基于空间的考虑

            数组的存储空间是静态，连续分布的，初始化的过大造成空间浪费，过小又将使空间溢出机会增多。而链表的存储空间是动态分布的，只要内存空间尚有空闲，就不会产生溢出；链表中每个节点出了数据域外，还有链域（指向下一个节点），这样空间利用率就会变高。

2、基于时间的考虑

            具体的来说 数组查询快，插入与删除慢，单链表查询慢，插入与删除快。细说的话：数组中任意节点都可以在O（1）内直接存储访问，而链表中的节点，需从头指针顺着链表扫描才能获取到；而链表任意位置进行插入和删除，都只需要修改指针，而数组中插入删除节点，平均要移动一半的节点。

 

           （静态）数组从栈中分配空间，对于程序员方便快速，但是自由度小。链表从堆中分配空间，自由度大但是申请管理比较麻烦。

              数组中的数据在内存中按顺序存储的，而链表是随机存储的！

              要访问数组中的元素可以按下标索引来访问，速度快，如果对他进行插入操作的话，就得移动很多元素，所以对数组进行插入操作效率很低！

              由于链表是随机存储的，链表在插入，删除操作上有很高的效率（相对于数组），如果要访问链表中的某个元素的话，就得从链表的头逐个遍历，直到找到所需要的元素为止，所以链表的随机访问的效率就比数组要低。（这里会在下面代码中显示出来，在此做一个特殊的符号标记一下生气，嗯就是这个把）。

 

单链表的实现代码，走你~：

首先定义一个节点类~记录每个节点使用：

[java] view plaincopy
 
  1. public class Node {  
  2.   
  3.     String data;//数据域  
  4.     Node next;//链域  
  5.   
  6.     public Node(String data) {  
  7.         this.data = data;  
  8.         next = null;  
  9.     }  
  10.   
  11. }  

 

下列代码就是构造了一个单链表，并且实现了各种操作：

 

[java] view plaincopy
 
  1. public class LinkedList {  
  2.   
  3.     int lenght;// 链表的长度  
  4.     Node head;// 定义头结点  
  5.   
  6.     public LinkedList() {  
  7.         head = null;// 链表中的头结点  
  8.         lenght = 0;  
  9.     }  
  10.   
  11.     /** 在链表末尾添加一个元素 */  
  12.     public void addElement(Node n) {  
  13.         if (lenght == 0) {// 如果链表为空，则直接添加。  
  14.             head = n;  
  15.         } else {  
  16.             Node t = head;  
  17.             while (t.next != null) {// 沿链表第一个元素向后寻找，直到找到末尾  
  18.                 t = t.next;  
  19.             }  
  20.             t.next = n;// 在末尾添加元素，也就是给最后一个next赋值~让链域不为空，这样链域为空的就成了链表中最后一个元素  
  21.         }  
  22.         // 在主函数中调用这个的方法为addElement(new Node("张三"))，  
  23.         // 其中new一个Node 就确定了这个Node的数据域（data）为"张三"，链域（next）为null，  
  24.         // 而这个函数的作用就是确定把这个新new出来Node放在谁的next中  
  25.         lenght++;// 修改长度  
  26.     }  
  27.   
  28.     /** 在链表中特定位置添加一个元素 */  
  29.     public boolean insert(Node n, int index) {  
  30.         if (index > lenght && index < 0) {// 如果插入位置超出链表长度  
  31.             System.out.println("超出范围！！");  
  32.             return false;  
  33.         } else {  
  34.             Node t = head;  
  35.             if (index == 0) {  
  36.                 n.next = head;// 让传入的节点指向头节点  
  37.                 head = n;// n作为新的头节点  
  38.             } else {  
  39.                 for (int i = 0; i < index - 1; i++) {// 找到要插入的位置的前一个位置  
  40.                     t = t.next;  
  41.                 }  
  42.                 n.next = t.next;// 新插入的节点指向当前位置节点  
  43.                 t.next = n;  
  44.                 // 这里需要用图解释的更为清晰  
  45.                 // 可见本文下方图—1；  
  46.             }  
  47.             lenght++;  
  48.             return true;  
  49.         }  
  50.     }  
  51.   
  52.     /** 删除链表最后一个节点 */  
  53.     public void removeLastElement() {  
  54.         if (lenght == 0) {  
  55.             System.out.println("链表中没有元素");  
  56.             return;  
  57.         }  
  58.         Node t = head;  
  59.         if (lenght == 1) {  
  60.             head = null;  
  61.         } else {  
  62.             for (int i = 0; i < lenght - 1; i++) {// 找到末尾节点的前一个节点  
  63.                 t = t.next;  
  64.             }  
  65.             t.next = null;  
  66.         }  
  67.         lenght--;  
  68.     }  
  69.   
  70.     /** 删除指定位置的节点 */  
  71.     public void removeElement(int index) {  
  72.         if (lenght == 0) {  
  73.             System.out.println("链表没有元素！");  
  74.             return;  
  75.         }  
  76.         if (index > lenght && index < 0) {  
  77.             System.out.println("超出范围！！");  
  78.             return;  
  79.         }  
  80.         Node t = head;  
  81.         if (index == 0) {  
  82.             head = head.next;  
  83.             t.next = null;  
  84.             lenght--;  
  85.             return;  
  86.         }  
  87.   
  88.         for (int i = 0; i < index - 1; i++) {// 找到要删除位置的前一位置  
  89.             t = t.next;  
  90.         }  
  91.         Node temp = t;  
  92.         t.next = t.next.next;  
  93.         temp.next = null;// 让该节点的next指向空  
  94.         lenght--;  
  95.   
  96.     }  
  97.   
  98.     /** 清空链表 */  
  99.     public void clearList() {  
  100.         head = null;  
  101.         lenght = 0;  
  102.     }  
  103.   
  104.     /** 打印链表中的所有元素 */  
  105.     public void printList() {  
  106.         if (lenght == 0) {  
  107.             System.out.println("链表为空！");  
  108.             return;  
  109.         }  
  110.         Node t = head;  
  111.         while (t!= null) {  
  112.             System.out.print(t.data + " ");  
  113.             t = t.next;  
  114.         }  
  115.     }  
  116. }  

 

                                

                                                                                        图—1

 

再接下来就是调用这个链表的各个操作了~顺便瞎说说~在我没学链表前~我看过严蔚敏老师的数据结构一书~其中的好多伪代码我都曾尝试用数组来解决，但是发现并没有想象中那么容易实现~在学链表之后~再回顾数据结构这本书~其中大多数伪代码都可以用链表来实现~我就觉得这个是我研究算法的一个好工具~嗯~废话就这么多，以上这个栗子要是懒得动手打的话~我这还是会有一个打好的，同样下载不要分数哦~~（http://download.csdn.net/detail/gg811/4963474）点击打开链接

posted on 2014-05-07 00:26  麦兜布熊  阅读(3431)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 麦兜布熊
Powered by .NET 8.0 on Kubernetes