数据结构java实现——单链表的顺序存储、链表结构、循环链表（头插尾插）

链表的顺序存储结构

链表头插法和尾插法

单链表顺序存储结构，java实现
涉及到扩容，顺序链表等处理
线性表——单链表笔记
数据结构java实现——栈的顺序存储+共享结构+链式存储

package com.datastruct.hdu.javase;

import com.sun.org.apache.xpath.internal.objects.XObject;
import com.sun.org.apache.xpath.internal.objects.XObjectFactory;
import org.omg.CORBA.NO_IMPLEMENT;

import java.util.Arrays;
import java.util.Scanner;

//实现链表的顺序存储结构
public class LinkTest {
    public static void main(String[] args) {
        //有参构造方法生成对象
        NodeOrder Link=new NodeOrder(5);
        //打印输出
        //Link.LinkPrint();
        System.out.println(Link);
        System.out.println("删除一个元素，并输出");
        System.out.println(Link.LinkDeleteData(6));
        System.out.println("删除某个位置元素，并输出");
        System.out.println(Link.LinkDeletePos(0));
        System.out.println("在指定位置插入一个值");
        Link.LinkInsertPos(100,8);//这可以完善一下 要不重新输入 要不进行扩容处理
        Link.LinkPrint();
        //无参构造方法 生成对象
        NodeOrder Link2=new NodeOrder();
        Link2.LinkInit(3);
        Link2.LinkPrint();
    }
}

class NodeOrder {//想实现接口来着  但是它保错 Cannot resolve symbol 'LinkFun'
    Object[] elements;//有了一个链表的引用
    int lengthLink;
    //实现链表的顺序存储结构
    public NodeOrder(){

    }
    public NodeOrder(int lengthLink) {
        this.lengthLink = lengthLink;
        elements=new Object[this.lengthLink];//用上面引用  指向new的一个对象
        this.LinkCreat();
    }

    public void LinkInit(int lengthLink)//初始化
    {
        this.lengthLink = lengthLink;
        elements=new Object[this.lengthLink];
        this.LinkCreat();
    }

    public void LinkCreat()//生成一个固定 大小的链表
    {
        System.out.println("请依次请输入链表的内容：");
        for(int i=0;i<elements.length;i++){
            Scanner scanner=new Scanner(System.in);
            int num=scanner.nextInt();
            elements[i]=num;
        }
    }

    public void LinkPrint()//打印链表
    {
        System.out.println(toString());

    }

    public Object LinkInsertPos(Object data,int pos)//插入一个新的元素，若不满 直接插入处理  否之进行扩容处理
    {
        Scanner scanner=new Scanner(System.in);

        if(pos<-1){
            System.out.println("pos的值不符合，请重新输入一个大于0的数");
            pos= scanner.nextInt();
        }
        if(pos>=elements.length){
            System.out.println("pos的值不符合，比"+elements.length+"大,请选择：如果需要进行扩容处理，请输入1，重新输入合适的值请输入0，其他则插入失败");
            int x=scanner.nextInt();
            if(x==1){
                lengthLink=(int)(lengthLink+(pos-lengthLink+1));
                this.elements=Arrays.copyOf(elements,lengthLink);
            }
            else if(x==0){
                pos=scanner.nextInt();
            }else{
                return null;
            }
        }
        while(pos>=elements.length||pos<-1) {
            System.out.println("pos的值不符合，请重新输入一个大于0小于" + elements.length + "的整数：");
            pos= scanner.nextInt();
        }
        elements[pos]=data;
        System.out.println("输出位置为："+pos+"的元素--->"+elements[pos]);
        return 0;
    }

    public String LinkDeleteData(Object data)//删除一个元素，并返回其值和原本位置
    {
        //如果返回多个相同的 那么就设计一个栈 依次入栈就行
        Object returndata=null;
        for (int i = 0; i <elements.length ; i++) {//但是它如果链表里没有呢 咋设计
            if(elements[i]==data){//如果有的话 这里就return  跳出函数了    ，要全部保存 就要设计一个栈  依次入栈就行。
                returndata=data;
                elements[i]=null;
                return "元素："+returndata+" 位置："+i;
            }
        }
        return "没找到该元素 删除失败";//只有找到元素 才会这样

    }

    public Object LinkDeletePos(int pos)//删除某个位置的元素
    {
        Scanner scanner=new Scanner(System.in);
        while(pos>=elements.length||pos<-1) {
            System.out.println("pos的值不符合，请重新输入一个大于0小于" + elements.length + "的整数：");
            pos= scanner.nextInt();
        }
        Object obj=elements[pos];
        elements[pos]=null;
        return obj;
    }

    @Override
    public String toString() {
        return "NodeOrder{" +
                "elements=" + Arrays.toString(elements) +
                ", lengthLink=" + lengthLink +
                '}';
    }
}

链式结构

链式结构

package com.datastruct.hdu.javase;

import com.sun.org.apache.xpath.internal.objects.XObject;
import com.sun.org.apache.xpath.internal.objects.XObjectFactory;
import org.omg.CORBA.NO_IMPLEMENT;

import java.util.Arrays;
import java.util.Scanner;

//实现链表的顺序存储结构
public class LinkTest {
    public static void main(String[] args) {
        //顺序存储结构
        //有参构造方法生成对象
        /*NodeOrder Link=new NodeOrder(5);
        //打印输出
        //Link.LinkPrint();
        System.out.println(Link);
        System.out.println("删除一个元素，并输出");
        System.out.println(Link.LinkDeleteData(6));
        System.out.println("删除某个位置元素，并输出");
        System.out.println(Link.LinkDeletePos(0));
        System.out.println("在指定位置插入一个值");
        Link.LinkInsertPos(100,8);//这可以完善一下 要不重新输入 要不进行扩容处理
        Link.LinkPrint();
        //无参构造方法 生成对象
        NodeOrder Link2=new NodeOrder();
        Link2.LinkInit(3);
        Link2.LinkPrint();*/

        //链式存储结构
        //头插法建立结点
        LinkNode l=new LinkNode();
        l.headInsert();
        //l.headInsert();
        l.PrintLink();

        //尾插法建立单链表
        LinkNode l2=new LinkNode();
        l2.tailLink();
        l2.PrintLink();

        //add一个结点
        System.out.println("加入一个结点");
        l2.addnode();
        l2.PrintLink();
        System.out.println("删除一个结点");
        l2.delNode();
        l2.PrintLink();
    }
}


    @Override
    public String toString() {
        return "NodeOrder{" +
                "elements=" + Arrays.toString(elements) +
                ", lengthLink=" + lengthLink +
                '}';
    }
}

//实现单链表
class Node{
    //定义单链表结点结构
    Object datas;//链表元素
    Node next;//链表的下一个结点

    public Node() {
        //this.next=null;
    }

    public Node(Object datas) {
        this.datas = datas;
    }

    @Override
    public String toString() {
        return "Node{" +
                "datas=" + datas +
                '}';
    }
}

class LinkNode{
    Node head;//头结点
    Object elements;

    //上面定义了  按照指针应该可以完成链表
    Scanner scanner=new Scanner(System.in);
    //先定义一个无参构造方法
    public LinkNode() {
        //this.InitLink();
        head=new Node();
        //head.datas="adead";可定义头结点内容
    }
    //头结点为空
    public void InitLink(){
        this.head=null;
    }

    //头插法建立单链表
    public void headInsert(){

        System.out.println("头插法建立单链表，请输入一个结点个数");
        Scanner scanner=new Scanner(System.in);
        int nodenum=scanner.nextInt();
        for (int i = 0; i <nodenum ; i++) {
            Node node1=new Node();
            System.out.println("请输入一个元素");
            //Scanner scanner=new Scanner(System.in);
            int d=scanner.nextInt();
            node1.datas=d;

            Node temp;
            temp=head.next;//保存头结点 后面一个结点
            head.next=node1;
            node1.next=temp;
        }

    }

    //尾插法建立单链表

    public void tailLink() {
        System.out.println("尾插法建立单链表，请输入一个结点个数");
        Scanner scanner=new Scanner(System.in);
        int nodenum=scanner.nextInt();
        for (int i = 0; i <nodenum ; i++) {
            Node node1=new Node();
            System.out.println("请输入一个元素");
            //Scanner scanner=new Scanner(System.in);
            int d=scanner.nextInt();
            node1.datas=d;
            Node temnode=head;
            while (temnode.next!=null){
                temnode=temnode.next;
            }

            temnode.next=node1;

        }
    }

    //add一个节点
    //那么插入的话 无疑按照位置插入或者按照 和元素相关的插入
    //按位置插入的话，那就得利用next进行寻找位置了  从头结点开始
    public void addnode(){
        Node addnode1=new Node();
        System.out.println("请输入一个结点元素");
        Scanner scanner=new Scanner(System.in);
        int addnum=scanner.nextInt();
        addnode1.datas=addnum;

        System.out.println("请输入插入位置");
        int pos=scanner.nextInt();

        Node p;
        int j=0;
        p=head;
        while(p!=null&&j<pos-1){
            //当结点存在  以及为找到合适得顺序前
            p=p.next;
            j++;
        }
        addnode1.next=p.next;
        p.next=addnode1;
    }

    //删除某个位置得结点
    public Object delNode(){
        System.out.println("请输入删除位置");
        int pos=scanner.nextInt();
        Node p=head;
        int i=0;
        while(p!=null&&i<pos-1){
            p=p.next;
            i++;
        }
        //需检验
        if(p.next==null||i>=pos-1){
            System.out.println("输入错误");
            return 0;
        }
        Node q=null;
        q=p.next;
        p.next=q.next;
        //free(q);
        return q;
    }
    public Object PrintLink(){
        Node h=head;
        //System.out.println(h.toString());//输入头结点内容
        while(h.next!=null){
            System.out.println(h.next.toString());
            h=h.next;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "LinkNode{" +
                "elements=" + elements +
                '}';
    }
}

循环单链表

即一个结点有一个前驱指针和后继指针
实现

import java.util.Scanner;

public class DoubleLink implements Nodecir {//有一个接口 就不拿出来了 你懂的
    node head;
    Object elements;
    public DoubleLink(){
        this.InitLInk();
    }

    @Override
    public void InitLInk() {
        head=new node();
        head.post=null;
        head.prec=null;
    }

    //头插法建立新的循环单链表
    public void headInsert(){
        System.out.println("请输入需要建立的结点个数：");
        Scanner scanner=new Scanner(System.in);
        int num=scanner.nextInt();
        for (int i = 0; i < num; i++) {
            if(this.head.post==null){
                System.out.println("建立一个新的结点，请输入结点元素");
                //Scanner scanner=new Scanner(System.in);
                int x=scanner.nextInt();
                node newnode=new node(x);
                this.head.post=newnode;
                newnode.prec=this.head;
            }else {
                System.out.println("建立一个新的结点，请输入结点元素");
                int x = scanner.nextInt();
                node newnode = new node(x);
                node temhead = head.post;//保存head后面的原结点  问题在于最开始的tem只是null，不是一个结点
                head.post = newnode;//
                newnode.prec = head;
                newnode.post = temhead;
                temhead.prec = newnode;
            }
        }
    }

    public void talilInsert(){
        System.out.println("请输入需要建立的结点个数：");
        Scanner scanner=new Scanner(System.in);
        int num=scanner.nextInt();
        node tem=head;
        for (int i = 0; i <num ; i++) {
            while(tem.post!=null){
                tem=tem.post;
            }
            System.out.println("建立一个新的结点，请输入结点元素");
            int x = scanner.nextInt();
            node newnode = new node(x);
            tem.post=newnode;
            newnode.prec=tem;
        }
    }



    public void PrintLink() {
        node tem=head;
        int i=0;
        while(tem.post!=null){
            node n=tem.post;
            System.out.println("第"+(++i)+"个结点元素："+n.data);
            //return "第一个结点元素："+n.data;
            tem=n;
        }

    }
}
class node{
    Object data;
    node prec;
    node post;

    public node(){}
    public node(Object data) {
        this.data = data;
        this.prec=null;
        this.post=null;
    }

    @Override
    public String toString() {
        return "node{" +
                "data=" + data +
                '}';
    }
}

main函数测试一下

public class CircularLink {
    public static void main(String[] args) {
        DoubleLink dl=new DoubleLink();
        dl.headInsert();
        dl.PrintLink();
        //System.out.println(dl.head.post.post.prec.data);//检验前驱后继是否形成
        dl.talilInsert();
        dl.PrintLink();
    }
}

分析单链表顺序结构和链表结构的优缺点：