数据结构与算法-链表

　　通过指针将一组零散的内存块串联在一起。

 

一：有趣的问题

1.LRU算法

　　按照时间有序的链表

　　如果存在链表中，删除，然后插入到头部

　　如果不存在，插入尾部

　　如果没有空间了，删除最后一个位置。

 

2.约瑟夫问题

　　这里的逻辑是，先形成一个环。

　　然后，p开始数数，之后1,2保留，3进行删除。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

package com.jun.algorithm.foundation.main;   import com.jun.algorithm.common.Node; import org.junit.Test;   /**  * 约瑟夫环的问题  *  * @author caojun  */ public class JosefCircle {     public void loop(int n) {         int k = 3;         // 1.先产生约瑟夫环         // 产生一个空的头结点         Node head = new Node();         Node current = head;           for (int i = 1; i <= n; i++) {             Node node = new Node(i);             current.setNext(node);             current = node;         }         current.setNext(head.getNext());           // 2.进行出局         Node p = head.getNext();         while (p.getNext() != p) {             // 进行k-1循环，到要删除的那个点的前一个点             for (int i = 1; i < k - 1; i++) {                 p = p.getNext();             }             // 删除后一个节点             System.out.println("删除的节点是=>" + p.getNext().getVal());             p.setNext(p.getNext().getNext());             p=p.getNext();         }         System.out.println("最后剩下的点是=>"+p.getVal());     }       /**      * 测试      */     @Test     public void test() {         loop(4);     } }

　　

 

二：链表

1.单链表增删改查

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

package com.jun.algorithm.foundation.main;   import com.jun.algorithm.common.Node;   /**  * 单链表程序  *  * @author caojun  */ public class SingleLinkedList {     private Node head;     private int size = 0;         /**      * 将节点插入头节点      *      * @param data 插入的数据      */     private void insertHead(int data) {         Node node = new Node(data);         node.setNext(head);         head = node;     }       /**      * 在某个位置插入数据      *      * @param data     要插入的数据      * @param position 插入的位置      */     private void insertNth(int data, int position) {         if (position == 0) {             insertHead(data);         } else {             Node current = head;             // 遍历             for (int i = 1; i < position; i++) {                 current = current.getNext();             }             // 先让后面的链保证不断，然后让当前的点关联上             Node node = new Node();             node.setNext(current.getNext());             current.setNext(node);         }     }       /**      * 删除头节点      */     private void deleteHead() {         head = head.getNext();     }       /**      * 删除第几个节点      */     private void deleteNth(int position) {         if (position == 0) {             deleteHead();         } else {             Node current = head;             for (int i = 1; i < position; i++) {                 current = current.getNext();             }             current.setNext(current.getNext().getNext());         }     }       /**      * 打印链表      */     public void print() {         Node current = head;         while (current != null) {             System.out.println(current.getVal() + "");             current = current.getNext();         }         System.out.println();     } }

　　

2.双向链表

package com.jun.algorithm.foundation.main;

import com.jun.algorithm.common.DoubleNode;
import org.junit.Test;

/**
 * 双向链表
 *
 * @author caojun
 */
public class DoubleLinkedList {
    private DoubleNode head;
    private DoubleNode tail;

    /**
     * 插入头结点
     *
     * @param data 将要插入的数据
     */
    public void insertHead(int data) {
        DoubleNode doubleNode = new DoubleNode(data);
        if (head == null) {
            tail = doubleNode;
        } else {
            head.setPre(doubleNode);
            doubleNode.setNext(head);
        }
        // 新的点赋值给头结点
        head = doubleNode;
    }

    /**
     * 将数据插入到链表的某个位置
     *
     * @param data     数据
     * @param position 位置
     */
    public void insertNth(int data, int position) {
        if (position == 0) {
            insertHead(data);
        } else {
            DoubleNode current = head;
            for (int i = 1; i < position; i++) {
                current = current.getNext();
            }
            // 开始创建新的节点，然后连接
            DoubleNode node = new DoubleNode(data);
            current.getNext().setPre(node);
            node.setNext(current.getNext());
            node.setPre(current);
            current.setNext(node);
        }
    }

    /**
     * 从头部往后进行遍历
     */
    public void printNext() {
        System.out.println("进行头部遍历");
        DoubleNode current = head;
        while (current != null) {
            System.out.print(current.getVal()+ " ");
            current = current.getNext();
        }
        System.out.println();
    }

    /**
     * 从尾部开始往前进行遍历
     */
    public void printPre() {
        System.out.println("进行尾部遍历");
        DoubleNode current = tail;
        while (current != null) {
            System.out.print(current.getVal() + " ");
            current = current.getPre();
        }
        System.out.println();
    }

    @Test
    public void test() {
        // 组装链表
        DoubleNode node1 = new DoubleNode(2);
        DoubleNode node2 = new DoubleNode(3);
        node1.setNext(node2);
        node2.setPre(node1);
        head = node1;
        tail = node2;

        // 插入头节点测试
        insertHead(8);
//        print();

        // 将数据插入到某个位置
        insertNth(89, 2);
        printNext();

        printPre();

    }


}