数据结构——链表

链表

定义:

由结点构成,开始于头结点,止于指向NULL的指针。

分类:

1.单向链表;
2.双向链表;
3.循环链表;

详解:

1.单向链表:

(1)图解:

在这里插入图片描述

(2)头结点概述:
			①数据域无意义(可存放链表长度);
			②可操作在第一个结点前的插入与删除;
			③非必要元素;
(3)单链表的创建:

在这里插入图片描述

(4)代码实现:
<1>LinkList属性及构造方法:
//头结点:
    private Node head;
    //长度:
    private int length;
    
    //构造方法(链表初始化):
    public _LinkList(){
        head = new Node(null,null);
        length = 0;
    }
<2>结点的内部类Node:
//内部结点类Node:
    private class Node{
        //数据域:
        public T item;
        //指针域:
        public Node next;

        //构造方法:
        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
    }
<3>清空列表方法:
//清空链表:
    public void clear(){
        head.next = null;
        length = 0;
    }
<4>判断是否为空:
//判断是否为空:
    public boolean isEmpty(){
        if (length == 0)  return true;
        return false;
    }
<5>获取链表长度:
//获取链表长度:
    public int getLength(){
        return length;
    }
<6>获取第j个位置的元素:
//获取第j个位置的元素:
    public T getElement(int j){
        Node n = head;
        for (int i = 0;i < j;i++){
            n = n.next;
        }
        return n.item;
    }
<7>在位置j插入元素:
//向j处添加元素:
    public void insert(int j,T insertElement){
        Node n = head;
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        n.next = new Node(insertElement,null);
        length++;
    }
<8>删除位置j处的元素并返回删除元素:
//删除j处的元素:
    public T delete(int j){
        Node n = head;
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        T deleteElement = n.next.item;
        n.next = n.next.next;
        length--;
        return deleteElement;
    }
<9>查找元素第一次出现的位置:
//查找元素第一次出现的位置
    public int selectIndex(T selectElement){
        int j = 0;
        Node n = head;
        while(n.next!=null){
            n = n.next;
            j++;
            if (n.item.equals(selectElement)){
                return j;
            }
        }
        return -1;
    }
<10>遍历链表:
//遍历链表:
    public void Iteration(){
        Node n = head;
        while(n.next!=null){
            n = n.next;
            System.out.println(n.item);
        }
    }

2.双向链表:

(1)图解:

在这里插入图片描述

(2)双向链表的创建:

在这里插入图片描述

(3)代码实现:
<1>LinkList属性与构造方法:
//头结点:
    private Node head;
    //尾结点:
    private Node last;
    //链表长度:
    private int length;
    
    //构造方法:
    public DoubleLinkList(){
        head = null;
        last = null;
        length = 0;
        }
<2>结点内部类Node:
//内部类Node
    private class Node{
        //数据域:
        public T item;
		//前一个结点:
        public Node pre;
		//后一个结点:
        public Node next;
        
        //构造方法:
        public Node(T item,Node pre,Node next){
            this.item = item;
            this.pre = pre;
            this.next = next;
        }
    }
<3>向位置j处插入元素:
//向位置j处添加元素:
    public void insert(int j,T insertValue){
        Node n = head;
        //得到前一个元素:
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        //创建处新结点:
        Node newNode = new Node(insertValue,n,n.next);
        //修改后一个元素的前置位:
        n.next.pre = newNode;
        //修改前一个元素的后置位:
        n.next = newNode;
        //长度+1:
        length++;
    }
<4>删除位置j处的元素:
//删除位置j的元素:
    public void remove(int j){
        Node n = head;
        //找到前一个元素:
        for (int i = 0;i < j-1;i++){
            n = n.next;
        }
        //修改后一个的pre属性:
        n.next.next.pre = n;
        //修改前一个的next属性:
        n.next = n.next.next;
        //链表长度-1:
        length--;
    }
<5>获取首位元素与末尾元素:
	//获取首个元素:
    public T firstElement(){
        if (isEmply()==true) return null;
        return head.next.item;
    }
    //----------------------------------------------------------------
	//获取末尾元素:
    public T lastElement(){
        if (isEmply()==true)  return null;
        return last.item;
        }

3.链表的应用:

(1)单向链表的反转:

方法递归思想
类比盗梦空间的多层梦境:

当链表中有三个元素时:
第一层:(该层中,curr是原第一个元素)
{
reserve()传入第一个元素head.next;
第二层:(该层中,curr是原第二个元素)
{
reserve()传入第二个元素curr.next;
第三层:(该层中,curr是原第三个元素)
{
reserve()传入第三个元素curr.next;
进入if条件语句块(第三个元素是最后一个元素),将第三个元素赋值给头 结点的下一个(即第一个元素位置),返回第三个元素结点(即为新的第一个结点)给第二层;
第三层结束
}
新的首结点newHead的下一个改为第二个元素。(本例中第二个不变)
第二个元素的下一个(新的第三个元素)为null;
返回第二个元素给第一层;
第二层结束
}
将第二个结点的下一个(新的尾结点)赋值为原第一个结点;
尾结点的下一个赋值为null;
第一层结束
得到新的链表为反转链表。
}

	//反转整个链表:
    public void reverse(){
        if (isEmpty())   return;
        reverse(head.next);
    }
    //反转一对结点:
    public Node reverse(Node curr){
        //如果判断是最后一个:
        if (curr.next == null){
            head.next = curr;
            return curr;
        }
        //返回值是反转后当前结点的上一个结点;
        Node newHead = reserve(curr.next);
        newHead.next = curr;
        curr.next = null;
        return curr;
    }
(2)快慢指针:

概述:快指针一次移动两个或者多格,慢指针一次移动一格。

<1>中间值问题:
		//得到中间值的方法:
        public static String getMid(Node <String> first){
            //设置快慢指针:
            Node<String> fast = first;
            Node<String> slow = first;
            //遍历循环链表,当快指针到链表尾部的时候,慢指针所指为中间值:
            while (fast.next!=null){
                fast = fast.next.next;
                slow = slow.next;
            }
            //返回中间值:
            return slow.item;
        }
<2>是否有环问题:

解法思路:设置快慢指针,当快慢指针相遇,证明链表有环。

	//判断是否存在闭环的方法:
    public static boolean isCircle(Node<Integer> first){
        //定义快慢指针:
        Node<Integer> fast = first;
        Node<Integer> slow = first;
        //循环遍历链表,当快慢指针指在相同位置时说明存在闭环:
        while(fast != null&&fast.next!=null){
           fast = fast.next.next;
           slow = slow.next;
           if (slow.equals(fast)){
               return true;
           }
        }
        return false;

    }
<3>求解有环链表入口问题:

解法思路:设置快慢指针,当快慢指针相遇时,引入新指针,移动速度与慢指针相同,当慢指针与新指针相遇时,该位置即为换的入口。

	//找闭环入口的方法:
    public static Node getEntrance(Node<Integer> first){
        //创建快慢指针与临时判断指针:
        Node<Integer> fast = first;
        Node<Integer> slow = first;
        Node<Integer> flag = null;
        //遍历链表,当闭环存在时,
        while (fast != null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast.equals(slow)){
                //当存在闭环的时候,引入临时指针flag
                flag = first;
                continue;
            }
            if (flag != null){
                flag = flag.next;
                if (flag.equals(slow)){
                    break;
                }
            }
        }
        return slow;
    }

完!

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈希表是一种高效的数据结构,可以用来存储和查找键值对。其中,哈希函数将键映射到一个特定的桶中,每个桶中存储一组键值对。在哈希表中,如果两个键被映射到同一个桶中,就会发生碰撞。为了解决这个问题,可以使用链表法。 链表法是一种解决哈希表碰撞问题的方法。具体来说,对于哈希表中的每个桶,可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞,只需要将新的键值对添加到链表的末尾即可。 下面是一个使用链表法实现哈希表的示例代码: ```python class Node: def __init__(self, key, value): self.key = key self.value = value self.next = None class HashTable: def __init__(self, capacity): self.capacity = capacity self.buckets = [None] * capacity def hash_function(self, key): return hash(key) % self.capacity def put(self, key, value): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: node.value = value return node = node.next new_node = Node(key, value) new_node.next = self.buckets[index] self.buckets[index] = new_node def get(self, key): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: return node.value node = node.next return None def remove(self, key): index = self.hash_function(key) node = self.buckets[index] prev = None while node: if node.key == key: if prev: prev.next = node.next else: self.buckets[index] = node.next return prev = node node = node.next ``` 在这个示例中,我们定义了一个Node类来表示哈希表中的每个节点,每个节点包含一个键、一个值和一个指向下一个节点的指针。我们还定义了一个HashTable类来实现哈希表,其中包含一个桶数组和一些基本的操作方法,如put、get和remove。 在put方法中,我们首先使用哈希函数计算出键的索引,然后遍历桶中的链表,查找该键是否已经存在于哈希表中。如果找到了该键,我们只需要更新其对应的值即可。否则,我们创建一个新的节点,并将其添加到链表的开头。 在get方法中,我们同样使用哈希函数计算出键的索引,然后遍历桶中的链表,查找该键的值。如果找到了该键,我们返回其对应的值。否则,返回None。 在remove方法中,我们首先使用哈希函数计算出键的索引,然后遍历桶中的链表,查找该键。如果找到了该键,我们将其从链表中删除即可。 总的来说,链表法是一种简单且常用的哈希表解决碰撞问题的方法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值