基础数据结构-链表

基础数据结构-链表

基本概念

链表定义：

链表通过指针将一组零散的内存块串联在一起，其中我们把内存块称为链表的“结点”。为了将所有结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址

特点：

1.不需要连续的内存空间。
2.有指针引用。
3.三种常见的链表结构：单链表、双向链表和循环链表。

单链表：

单链表中有两个结点是比较特殊的，它们分别是第一个结点和最后一个结点，我们一般把第一个结点叫作头结点，最后一个结点叫作尾结点
其中，头结点用来记录链表的基地址。有了它我们可以遍历到整条链表。尾结点特殊的是：指针不是指向下一个结点，而是指向一个空地址NULL，表示链表的最后一个结点。

单链表的增删查代码实现：

package 数据结构与算法;

import java.nio.file.spi.FileSystemProvider;

import javax.swing.text.StyledEditorKit.ForegroundAction;

import org.omg.CORBA.PRIVATE_MEMBER;

public class MyLinkedList {
	private listNode head;
	private int size = 0;
	
	//插入到链表头部
	public void inserthead(int data){
		listNode  newNode = new listNode(data);
		//注意：如果原来就有数据？
		newNode.next = head;//不用加判断是不是原来有数据，用此行代码就行，可以用链表的图来解释代码
		head = newNode;
	}
	//插入到链表中间
	public void insertmid(int data,int position){//在position位置插入data
		if (position ==0){//判断是否插入到头部
			inserthead(data);
		}
		else{
			listNode cur = head;
			for(int i=1;i<position;i++){
				cur = cur.next;      //一直往后遍历   p=p->next
			}
			listNode newNode = new listNode(data);
			newNode.next = cur.next;  //先将新数据的next指向cur的next防止cur的next丢失（保证链表不断裂）
			cur.next = newNode;       
		}
	}
	//删除头部
	public void deletehead(){
		//head = null;//千万不可以
		head = head.next;
	}
	//删除尾部
	public void deletemid(int position){
		if (position==0){
			deletehead();
		}
		else{
			listNode cur = head;
			for (int i=1;i<position;i++){
				cur = cur.next;
			}
			cur.next= cur.next.next;//cue.next是要删除的点，后一个next就是要指向的。
		}
	}
	//遍历
	public void  print() {
		listNode cur = head;
		while (cur!=null){
			System.out.print(cur.value+"  ");
			cur=cur.next;
		}
		System.out.println();
	}
	
	public void find (int data){
		listNode cur = head;
		while (cur!=null){
			if (cur.value==data)break;
			cur=cur.next;
		}	
	}
	public static void main(String[] args) {	
		
 	}
}



class listNode{
	int value;    //值
	listNode next;//下一个的指针
	public listNode(int value) {
		this.value=value;
		this.next=null;
		// TODO Auto-generated constructor stub
	}
	
}

循环列表

循环链表是特殊的单链表，循环链表的尾结点指针不指向空地址，而是指向链表的头结点。

循环链表的增删查代码实现与单链表的类似

双向链表

双向链表支持两个方向，每个结点不止有一个后继指针指向后边结点，还有一个前驱指针指向前边结点。双向链表需要两个额外的空间来存储前驱结点和后继结点。所以比较浪费存储空间。但支持双向遍历，带来了双向链表操作的灵活性。

双向 链表的增删查代码实现：

package 数据结构与算法;
//双向链表
public class DoubleLinkList {
	private DNode head;//头
	private DNode tail;//尾
	
	DoubleLinkList() {
		head = null;
		tail = null;
		// TODO Auto-generated constructor stub
	}
	
	//根据双向链表的图判断指针更改的前后顺序
	public void inserthead(int data){
		DNode newNode = new DNode(data);
		if (head==null){
			tail = newNode;
			head = newNode;
		}else{
			head.pre = newNode;
			newNode.next = head;
			head = newNode;
		}
		
	}
	
	public void deletehead(){
		if (head ==null)  return ;//没有数据
		if (head.next==null){     //就一个点
			tail=null;
		}else{
			head.next.pre=null;
		}
		head.next =head;
	}
	
	public void deletekey(int data){
		DNode cur= head;
		while (cur.value!=data){  //要删除的是cur，在双向链表中遍历寻找与data相同的点cur
			if (cur.next==null){
				System.out.println("没有找到结点");
				return;
			}
			cur=cur.next;
		}
		if (cur==head){           //删除的是头部
			deletehead();
		}else{
				cur.pre.next = cur.next;
				if (cur==tail){   //删除的事尾部
					tail=cur.pre;
					cur.pre=null;
				}else{
					cur.next.pre=cur.pre;
				}
				
		}
		
		
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	
	}

}

class DNode{
	int value;    //值
	DNode next;//下一个的指针
	DNode pre;  //指向前一个指针
	public DNode(int value) {
		this.value=value;
		this.next=null;
		// TODO Auto-generated constructor stub
	}
	
}

数组VS链表

时间复杂度

插入删除：数组：O(n) 链表O(1)
随机访问：数组：O(1) 链表O(n)

重要区别

1.数组简单易用，在实现上使用的事连续的内存空间，可以借助CPU的缓存机制，预读数组中的数据，所以访问效率更高
2.链表在内存中并不是连续存储的，所以对CPU缓存不友好，没有办法进行有效的预读。
3.数组的缺点是大小固定，已经声明就要占用整块的连续的内存空间，如果数组声明过大，系统可能没有足够的连续内存空间分配给它。导致内存不足，如果声明过小，则可能出现不够用的情况
4.动态扩容：数组需要在申请一个更大的内存空间，把原数据拷贝进去，非常费时。链表本身没有大小的限制，天然的支持动态扩容

面试经典
1.如何设计一个LRU缓存淘汰算法？
2.约瑟夫问题

1.最近使用，只需要维护一个有序的单链表就可以了。有序的指的就是加入的实践排序
LRU算法就是新加的点来了，现在链表里遍历，如果找到了，删掉然后插入的头部，头部就是最新的，如果不在原来的链表里，如果有空间就插入到头部，如果没有空间就删除最后一个，完成这个算法
2.约瑟夫问题
约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。
分析：
（1）由于对于每个人只有死和活两种状态，因此可以用布尔型数组标记每个人的状态，可用true表示死，false表示活。
（2）开始时每个人都是活的，所以数组初值全部赋为false。
（3）模拟杀人过程，直到所有人都被杀死为止。

package 数据结构与算法;
//约瑟夫环java实现
//约瑟夫环问题的起源来自犹太历史学家约瑟夫和他的朋友以及39其余的犹太人，总共41人为了躲避敌人，藏在一个山洞中，
//39个犹太人决定宁愿死也不被敌人抓到，于是决定自杀，所有人排成一个圈，由第一个人开始报数，每当数到3，就自杀。
//这个游戏接着从自杀的位置开始，还是从1数到3。依次类推，约瑟夫将朋友和自己安排在了16和31的位置，最后顺利逃过了
//自杀这一劫，因为最后就剩他一个人了。
public class YSFQuestion {
	
	public static void count(int n){
		//数到3出局，中间间隔两个人
		int k = 3;
		//头结点不存储数据
		Node head = new Node();//此处定义的头结点是没有数据的
		Node cur = head;
		//循环构造这个链表
		for(int i=1;i<=n;i++){
			Node node = new Node(i);
			cur.next = node;
			cur = node;
		}
		//链表有数据的部分首尾相连形成一个环。
		cur.next = head.next;
		//统计开始的时候，刨去头结点，然后从第一个有数据的结点开始报数
		Node p = head.next;
		//循环退出的条件是最后只剩一个结点，也就是这个结点的下一个结点是它本身
		while(p.next!=p){
			//正常报数的遍历逻辑
			for(int i=1;i<k-1;i++){
				p = p.next;
			}
			//当数到3的时候，出局
			System.out.print(p.next.data+"->");
			p.next = p.next.next;
			p = p.next;
		}
		//最后剩下的一个结点
		System.out.println("(left:"+p.data+")");
	}
 
	public static void main(String[] args) {
		//以4个人为例，1234 : 最先出局的是3，然后剩下412,接着2出局，剩下41，这时候就是4出局，最后剩下1.
		count(1);
		//41个人为例，就是约瑟夫环的本身了，最后剩下的是31
		count(41);
	}
 
}
 
class Node{
	int data;
	Node next;
	public Node(){}
	public Node(int data){this.data = data;}
}