数据结构——链表

链表

线性链表
链式存储结构特点：一组随机的存储单元存储线性表的数据元素。（物理地址随机，不连续）

地址不连续，无法像数组一样，通过下标查找访问。因此，每个链表节点需存储直接后继的信息。

插入时间复杂度O（n）

#define int database
C++：
class Node
{
database data;
Node* next;
}
节点包含两部分：数据域与指针域；

Java:
Java中不存在指针的概念，因此每个节点中包含下一个节点的引用

//定义节点类型
#define database int
class Node
{
	private database data;
	private Node next;
}

java中数据域与“指针域”数据类型相同
链表抽象数据类型

满足增删改查等基本功能

import java.util*.

class Node
{
	private databasess data;
	private Node next;

	public Node()//默认构造函数
	{
		data=NULL;
		next=NULL;
	}
	//带形参构造函数
	public Node(database m)
	{
		this.data=m;
		next=NULL;
	}
	

	//初始化链表
	public Node InitialNode()
	{
		Node HeadNode=new Node();
		return HeadNode;//头结点,不包含任何信息;
	}
	//创建链表,长度为n;
	public void CreatList(Node HeadNode,int n)
	{
		Scanner in=new Scanner(System.in);
		for(int i=n;i>0;i--)
		{
			Node p=new Node();
			p.data=in.nextInt();
			//采用表头插入方法
			p.next=HeadNode.next;
			HeadNode.next=p;
		}
	}
	
	//遍历链表
	public void display(Node HeadNode)
	{
		for(Node i=Head->next;i!=NULL;i=i.next)//java传入除基础类型外，均为地址;
		{
			System.out.print(i.data+" ");
		}
	}

	//节点插入,插入位置为i之前,插入数据为e
	public boolean InsertNode(Node HeadNode,int i,database e)
	{
		//带头结点;
		Node Head=HeadNode;
		int j=0;
		while(Head&&j<i-1)//遍历至i-1个节点
		{
			Head=Head.next;
			++j;//j为i之前一个元素位置;
		}
		if(!Head||j>i-1)//i小于1或大于表长+1,当前i错误;
		{
			return false;
		}
		Node p=new Node(e);
		p.next=Head.next;
		Head.next=p;
		return true;
	}

	//节点删除,返回删除节点信息
	public boolean DeleteNode(Node HeadNode,int i,Node e)
	{
		Node Head=HeadNode;
		int j=0;
		//删除第i节点,遍历至i-1节点,并判断直接后继是否为空;
		while(Head->next&&j<i-1)
		{
			Head=Head.next;
			++j;
		}
		if(!(Head.next)||j>i-1)//i为表长+1时,无法删除,不存在;
		{
			return false;
		}
		e=Head.next;
		Head.next=e.next;
		return true;
	}

	//查找
	public boolean SearchNode(Node HeadNode,int i,Node p)
	{
		Node Head=HeadNode;
		int j=0;//j为计数器;
		while(Head&&j<i)
		{
			Head=Head.next;
			++j;
		}
		if(!Head||j>i-1)
		{
			return false;
		}
		p=Head;
		return true;
	}

	//修改第i个位置元素
	public boolean Update(Node HeadNode,int i,Node p)
	{
		Node Head=HeadNode;
		int j=0;
		while(Head&&j<i)
		{
			Head=Head.next;
			++j;
		}
		if(!Head||j>i-1)//i<1或者i大于链表长度，修改位置错误;
		{
			return false;
		}
		Head.data=e.data;//更新数据域
		return true;
	}

	//两个排序的单链表合并为一个
	public Node Merge(Node La,Node Lb)
	{
		Node pa=La->next;
		Node pb=Lb->next;
		Node Lc=La;Node pc=La;
		while(pa&&pb)
		{
			if(pa.data<pb.data)
			{
				pc.next=pa;
				pc=pa;
				pa=pa.next;
			}
			else
			{
				pc.next=pb;
				pc=pb;
				pb=pb.next;
			}
		}
		pc->next=pa?pa:pb;//剩余链表全部链接至当前链表
		return Lc;
	}
}