基础数据结构-链表
基本概念
链表定义:
链表通过指针将一组零散的内存块串联在一起,其中我们把内存块称为链表的“结点”。为了将所有结点串起来,每个链表的结点除了存储数据之外,还需要记录链上的下一个结点的地址
特点:
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;}
}