一看就懂的java顺序表和链表的基础操作

顺序存储结构是一种在物理地址上连续，逻辑上也连续的存储结构，它的本质是使用数组实现，但是当数据个数较多且无法确定数据的个数时，对这些数据进行插入，删除等一系列操作时，消耗较大
链式存储结构是一种在物理地址上不连续，逻辑上连续的存储结构，它的想法和糖葫芦一样，用一根签串起所有的山楂，而链式存储结构的节点就如山楂，它的结构中包含数据域和指针域（或引用），通过引用，将各个节点串联起来。链式存储结构不需要确定数据的具体个数，且对数据进行插入，删除等操作时，消耗较小。
下面将展示顺序表和链表的基础操作

顺序存储结构

package com.company;

import java.util.Arrays;

public class MyArrayList {
    int usedSize;//有效数据的个数
    int[] elem;

    public MyArrayList() {
        this.usedSize = 0;
        this.elem = new int[10];
    }

    public void add(int pos, int data) {   //在pos位置新增元素
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("输入位置不合法");
        }
        if (this.usedSize == this.elem.length) {
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);  //扩容
        }
        for (int i = this.usedSize - 1; i > pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

    public void print() {//打印
        for (int i = 0; i < this.usedSize; i++) {
            System.out.println(elem[i]);
        }
        System.out.println();
    }

    public boolean contains(int tofind) {//查找是否包含所寻找的值
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == tofind) {
                System.out.println("已找到");
                return true;
            }
        }
        System.out.println("未找到");
        return false;
    }

    public int search(int tofind) {//查找是否有所寻找的值，若有，返回下标
        int result = 0;
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == tofind) {
                result = i;
                System.out.println("下标为" + result);
                return i;
            }
        }
        System.out.println("未找到");
        return -1;
    }

    public int getpos(int tofind) {//查找是否有所寻找的值，若有，返回该值
        int data = 0;
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == tofind) {
                data = this.elem[i];
                System.out.println("data=" + data);
                return data;
            }
        }
        System.out.println("未找到");
        return -1;
    }
    public void setpos(int pos,int data){//将pos位置的值改为data
        if(pos<0||pos>=this.usedSize){
            return;
        }
        this.elem[pos]=data;
    }

    public void MyArrayListLength(){//输出顺序表的长度
        int length=this.usedSize;
        System.out.println("length="+length);
    }

    public void DeleteAllData1(){//第一种情况：数组里面存放的是普通类型
        this.usedSize=0;
    }
    public void DeleteAllData2(){//第二种情况：数组里面存放的是引用类型
        for (int i = 0; i <this.usedSize ; i++) {
            //this.elem[i]=null;
        }
    }
    public void DeleteOneData(int toDelete){//删除指定元素：首先确定该元素位置，然后将其后面的元素依次向前移动一位
        int pos=0;
        for (int i = 0; i <this.usedSize ; i++) {
            if(this.elem[i]==toDelete){
                pos=i;
            }
           }
            for (int j=pos;j<this.usedSize-1;j++){
                this.elem[j]=this.elem[j+1];
            }
        this.usedSize--;
    }
}



MyArrayList类的测试主函数
public class Main{
    public static void main(String[] args) {
MyArrayList myArrayList=new MyArrayList();
myArrayList.add(0,24);
myArrayList.add(1,58);
myArrayList.add(2,98);
myArrayList.add(3,125);
myArrayList.add(4,54);
myArrayList.add(5,41);
myArrayList.print();
myArrayList.contains(54);
myArrayList.search(54);
myArrayList.getpos(54);
myArrayList.MyArrayListLength();

myArrayList.DeleteOneData(54);
myArrayList.print();
    }

}

链式存储结构

//链表 MyLinkedList的测试函数
public class Main{
    public static void main(String[] args) {
MyLinkedList myLinkedList=new MyLinkedList();
        myLinkedList.addFirstData(7);
        myLinkedList.addFirstData(6);
        myLinkedList.addFirstData(4);
        myLinkedList.addFirstData(3);
        myLinkedList.addFirstData(2);
        myLinkedList.addFirstData(1);
        //myLinkedList.print();
        myLinkedList.addLastData(8);
        myLinkedList.addLastData(9);
        myLinkedList.addLastData(10);
        myLinkedList.addLastData(1);
        //myLinkedList.print();
        myLinkedList.addIndexData(5,5);
        //myLinkedList.print();
       myLinkedList.RemoveOneData(5);
        //myLinkedList.print();
        myLinkedList.RemoveAllData(1);
        myLinkedList.print();
        int length=myLinkedList.getlength();
        System.out.println("length="+length);
    }
}


package com.company;
//单项不带头循环链表
 class Node{
    int data;//数据域
    Node next;//指针域（引用）

    public Node(int data) {
        this.data = data;
    }
}

public class MyLinkedList {
    public Node head; //指向头节点
    public void print(){  //打印
        Node cur;
        cur=this.head;
        while(cur!=null){
            System.out.println(cur.data+"");
            cur=cur.next; //新的cur变为原来cur的next
        }
    }

public int getlength(){ //找该链表的长度
    int usedSize=0; //有效长度
       Node cur=this.head;
       while (cur!=null){
           cur=cur.next;
           usedSize++;
       }
       return usedSize;
}

public boolean IndexLawful(int index){ //判断index（位置）是否合法
        if(index<0||index>this.getlength()){
            return false;
        }else{
            return true;
        }
}

    public void addFirstData(int data){//头插法
        Node node=new Node(data);
        node.next=head;
        this.head=node;
    }

    public void addLastData(int data){//尾插法
       Node node=new Node(data);
       if(this.head==null){           //考虑当该链表一个结点都没有的时候的情况
           this.head=node;
       }else{
           Node cur=this.head;
           while (cur.next!=null){      //寻找尾结点
               cur=cur.next;
           }
           cur.next=node;
       }
    }

    public void addIndexData(int index,int data){//从任意位置插入（插入位置为index）
        Node node=new Node(data);
       if(this.IndexLawful(index)){
           if(index==0){
               this.addFirstData(data);
               return;
           }
           if(index==this.getlength()){
               this.addLastData(data);
               return;
           }
           Node cur=this.head;
           for (int i = 1; i <index-1 ; i++) {
              cur=cur.next;
            }
           node.next=cur.next;
           cur.next=node;
       }
         }

         public Node SearchPrey(int index){//寻找index的前驱
        Node cur=this.head;
        int count=0;
        while (count<index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }

    public boolean contains(int key){//查找key的值是否在该链表当中
        Node cur=this.head;
        while(cur!=null){
            if(cur.data==key){
                return true;
            }else{
                cur=cur.next;
            }
        }
        return false;
         }

    // 删除节点数据为key的结点
        public Node SearchKeyPrey(int key){  //寻找key的前驱节点
           Node cur=this.head;
           while (cur.next!=null){    // 当cur为最后一项时，没找到，若是cur！=null，则会超出范围
               if(cur.next.data==key){
                   return cur;
               }
               cur=cur.next;
           }
         return null;
    }
        public void RemoveOneData(int key){
        if(this.head==null){
            return;
        }
        if(this.head.data==key){
            this.head.next=this.head;
            return;
        }
        Node cur=this.SearchKeyPrey(key);
        cur.next=cur.next.next;
        }


        public void RemoveAllData(int key){
            Node cur=head.next;   //cur指向第二个节点，然后指向需要删除的节点
            Node prev=head;       //prev指向cur的前驱
            while(cur!=null){
                if(cur.data==key){
                    prev.next=cur.next;
                    cur=cur.next;
                }else{
                    prev=cur;
                    cur=cur.next;
                }
            }
            if(head.data==key){    //先删除除头节点外的其他节点，再删除头节点
                head=head.next;
            }
        }

        public void CleanLinkedList(){
        this.head=null;           //将头节点置为空，则后续节点都没有被引用，系统会自动回收
        }
}