浅谈Java链表

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

数据结构分为3大部分，1、逻辑结构 2、物理（存储）结构 3、对数据施加的运算  。

1、逻辑结构就是数据之间存在的关系。

逻辑结构分为线性结构和非线性结构。

线性：有且只有一个开始结点和终端 结点，并且所有的结点都最多只有一个直接前驱和直接后继。

非线性：每个结点可以有不止一个直接前驱和直接后继。

线性结构：线性表、（顺序表，链表，栈，（顺序栈，链栈）和队列（顺序队列、链队列））

非线性结构：树（二叉树），图（又叫网）

集合：有时候是线性的有时候是非线性的，主要是通过封装一些方法实现对对象的操作。

2、物理结构

数据间的关系（逻辑结构）在计算机中物理层面上 的存储实现，存储结构是逻辑结构在计算机中的存储映像。是逻辑结构用计算机语言（高级语言）的实现。常见的存储结构有：顺序存储、链式存储、索引存储和散列存储（哈希表）。

它包括数据元素的表示和关系的表示。在计算机中表示信息的最小单位是二进制数的一位；数据元素之间的关系在计算机中有两种不同的表示方法：顺序映像和非顺序映像，并由此得到两种不同的存储结构：顺序存储和链式存储。

 

存储结构分四类：顺序存储、链接存储、索引存储 和 散列存储。

顺序结构和链接结构适用在内存结构中。

索引结构和散列结构适用在外存与内存交互结构。

 

顺序存储：在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构。

特点：

1、随机存取表中元素。

2、插入和删除操作需要移动元素。

顺序存储结构通常借助程序设计语言中的数组来加以实现。

链接存储：在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点。

特点：

1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。
2、逻辑上相邻的节点物理上不必相邻。
3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。
4、查找结点时链式存储要比顺序存储慢。
5、每个结点是由数据域和指针域组成。

 

索引存储：除建立存储结点信息外，还建立附加的索引表来标识结点的地址。索引表由若干索引项组成。

特点：

索引存储结构是用结点的索引号来确定结点存储地址，其优点是检索速度快，缺点是增加了附加的索引表,会占用较多的存储空间。

 

散列存储：散列存储，又称hash存储，是一种力图将数据元素的存储位置与关键码之间建立确定对应关系的查找技术。

散列法存储的基本思想是：由节点的关键码值决定节点的存储地址。散列技术除了可以用于查找外，还可以用于存储。

特点：

散列是数组存储方式的一种发展，相比数组，散列的数据访问速度要高于数组，因为可以依据存储数据的部分内容找到数据在数组中的存储位置，进而能够快速实现数据的访问，理想的散列访问速度是非常迅速的，而不像在数组中的遍历过程，采用存储数组中内容的部分元素作为映射函数的输入，映射函数的输出就是存储数据的位置，这样的访问速度就省去了遍历数组的实现，因此时间复杂度可以认为为O(1)，而数组遍历的时间复杂度为O(n)。

 

package edu.xalead;
class ArrayList{
    private int length = 20;
    private int[] data = new int[length];
    private int size = 0;

    public Integer get(int i){
        if(i < 0 || i >= size){
            return null;
        }
        return data[i];
    }

    public void remove(int i){
        if(i < 0 || i >= size){
            return;
        }
        if(i == size - 1) size--;//{20,30,44}   size:2
        for(int t = i ; t < size - 1 ;t++ ){
            data[t] = data[t + 1];
        }
        size--;
    }

    public void add(int d){
        if(size < length) {
            this.data[size] = d;
        }else{
            length *= 2;
            int[] b = new int[length];
            for(int i = 0 ; i < size ; i++){
                b[i] = data[i];
            }
            data = b;
            data[size] = d;
        }
        size++;
    }


}

public class 集合的概念 {
    public static void main(String[] args) {
        LinkedList bb = new LinkedList();
        bb.add(20);
        bb.add(222);
        bb.add(23);
        remove(5);
        System.out.println(bb.get(5));
		
    }


}

使用数组的好处就是访问数据特别快比如在查询的时候，缺点就是增添和删除比较慢，因为空间复杂度和时间复杂度都很高。

除了使用数组这种线性存储来存储数据，还有一种更灵活更方便的存储方式就是链式存储。

链式存储每个元素分为两部分：1、是数据 2、引用（地址）  指向下一个结点的地址。拿到应用就可以操作下一个元素的数据。

它不像数组需要一个一块很大的内存，因为数组是连续存储的，并且数组越界的时候非常麻烦，需要创建一块更大的内存，再将数组拷过来。但是链式存储则不会出现这样的情况，new对象的时候再内存哪里new都可以， 最后只需要指针保存到对象的地址就行。但是缺点就是访问的时候需要一个一个去访问查找。查询的时候没有数组快，所以链式存储结构增、删、改的时候很方便。

 

 

 

 

package edu.xaled;
class Node{
    private int data;

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    private Node next;

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

}

public class 初识链表 {

public static void main(String [] args){
      Node head=new Node();
      head.setData(20);
      Node n=new Node();
      n.setData(50);
      head.setNext(n);
      n=new Node();
      n.setData(30);
      head.getNext().setNext(n);
      System.out.println(head.getNext().getNext().getData());
    }
}

package edu.xaled;
public class LinkList {
        private class Node{
            private int data;

            public Node getNext() {
                return next;
            }

            public void setNext(Node next) {
                this.next = next;
            }

            private Node next;

            public int getData() {
                return data;
            }

            public void setData(int data) {
                this.data = data;
            }


        }
        private Node head = null;//代表链表里面没有数据
        private int size = 0;
        public Integer get(int i){//i is suoyin
            if(i == 0) return head.getData();
            if(i < 0 ||i >= size) return null;
            Node temp = head;
            for(int t = 0; t < i ; t++) {
                temp = temp.getNext();
                if(temp == null) return null;
            }
            return temp.getData();
        }
        public void add(int d){
            Node n = new Node();//要添加数据必须先创建一个节点
            n.setData(d);
            if(head == null)
                head = n;
            else{
                Node temp = head;
                for(int i = 0 ; i < size - 1 ; i++){
                    temp = temp.getNext();
                }
                temp.setNext(n);
            }
            size++;
        }
        public void remove(int i){

        }

    public static void main(String[] args) {
        LinkList dd = new LinkList();
        dd.add(20);
        dd.add(220);
        System.out.println(dd.get(-1));
        System.out.println(dd.get(0));
        System.out.println(dd.get(1));
        System.out.println(dd.get(2));
        System.out.println(dd.get(3));
    }
}

 

 

补充：

浅谈Java中的对象和对象引用

　　在Java中，有一组名词经常一起出现，它们就是“对象和对象引用”，很多朋友在初学Java的时候可能经常会混淆这2个概念，觉得它们是一回事，事实上则不然。今天我们就来一起了解一下对象和对象引用之间的区别和联系。

1.何谓对象？

　　在Java中有一句比较流行的话，叫做“万物皆对象”，这是Java语言设计之初的理念之一。要理解什么是对象，需要跟类一起结合起来理解。下面这段话引自《Java编程思想》中的一段原话：

　　“按照通俗的说法，每个对象都是某个类（class）的一个实例（instance），这里，‘类’就是‘类型’的同义词。”

　　从这一句话就可以理解到对象的本质，简而言之，它就是类的实例，比如所有的人统称为“人类”，这里的“人类”就是一个类（物种的一种类型），而具体到每个人，比如张三这个人，它就是对象，就是“人类”的实例。

2.何谓对象引用？

　　我们先看一段话：

　　“每种编程语言都有自己的数据处理方式。有些时候，程序员必须注意将要处理的数据是什么类型。你是直接操纵元素，还是用某种基于特殊语法的间接表示（例如C/C++里的指针）来操作对象。所有这些在 Java 里都得到了简化，一切都被视为对象。因此，我们可采用一种统一的语法。尽管将一切都“看作”对象，但操纵的标识符实际是指向一个对象的“引用”（reference）。”　　

　　这段话来自于《Java编程思想》，很显然，从这段话可以看出对象和对象引用不是一回事，是两个完全不同的概念。举个例子，我们通常会用下面这一行代码来创建一个对象：

1	Person person = new Person("张三");

　　有人会说，这里的person是一个对象，是Person类的一个实例。

　　也有人会说，这里的person并不是真正的对象，而是指向所创建的对象的引用。

　　到底哪种说法是对的？我们先不急着纠结哪种说法是对的，再看两行代码：

1 2	Person person; person = new Person("张三");

　　这两行代码实现的功能和上面的一行代码是完全一样的。大家都知道，在Java中new是用来在堆上创建对象用的，如果person是一个对象的话，那么第二行为何还要通过new来创建对象呢？由此可见，person并不是所创建的对象，是什么？上面的一段话说的很清楚，“操纵的标识符实际是指向一个对象的引用”，也就是说person是一个引用，是指向一个可以指向Person类的对象的引用。真正创建对象的语句是右边的new Person("张三");

　　再看一个例子：

1 2 3

Person person; person = new Person("张三"); person = new Person("李四");

　　这里让person先指向了“张三”这个对象，然后又指向了“李四”这个对象。也就是说，Person person，这句话只是声明了一个Person类的引用，它可以指向任何Person类的实例。这个道理就和下面这段代码一样：

1 2 3

int a; a=2; a=3;

　　这里先声明了一个int类型的变量a，先对a赋值为2，后面又赋值为3.也就是说int类型的变量a，可以让它的值为2，也可以为3，只要是合法的int类型的数值即可。

　　也就是说，一个引用可以指向多个对象，而一个对象可不可以被多个引用所指呢？答案当然是可以的。

　　比如：

1 2	Person person1 = new Person("张三"); Person person2 = person1;

　　person1和person2都指向了“张三”这个对象。