07、数据结构与算法 - 实战：单向环形链表

单向环形链表 - 无头指针

测试类

class Student2 {
   
     
	private int id;
	private String name;

	public Student2(int id, String name) {
   
     
		this.id = id;
		this.name = name;
	}

	@Override
	public String toString() {
   
     
		return "Student2 [id=" + id + ", name=" + name + "]";
	}

}

增加元素、遍历链表

代码实现 - 增加元素

class SingleCircularLinkedList<T> {
   
     

	private Node<T> firstNode = null;
	
	// 向尾部增加一个节点
	public void add(T t) {
   
     
		
		// 1.将添加的元素封装成节点
		Node<T> newNode = new Node<T>(t);
		
		// 2.1 如果链表为空则直接单元素环形链表
		if (firstNode == null) {
   
     
			firstNode = newNode;
			firstNode.next = firstNode;
			return;
			// 2.2 如果链表中有一个元素
		} else if (firstNode == firstNode.next) {
   
     

			firstNode.next = newNode;
			newNode.next = firstNode;
			return;
			// 2.3 链表中存在2个或以上的元素
		} else {
   
     
			
			// 当前遍历到的节点
			Node<T> temp = firstNode;
			
			
			// 遍历获取到最后一个节点
			while (temp.next != firstNode) {
   
     
				temp = temp.next;
			}
			
			temp.next = newNode;
			newNode.next = firstNode;
		}

	}
    
	private class Node<T> {
   
     

		T date;
		Node<T> next;

		Node(T date) {
   
     
			this.date = date;
		}

		@Override
		public String toString() {
   
     
			return date.toString();
		}
	}

	
}

代码实现 - 遍历节点

@Override
public String toString() {
   
     

    // 头节点为null
    if (firstNode == null) {
   
     
        return null;
    }

    StringBuilder sb = new StringBuilder();

    // 遍历到的当前节点
    Node<T> temp = firstNode;

    while (true) {
   
     
        sb.append(temp.toString() + "\n");
        if (temp.next == firstNode) {
   
     
            break;
        }
        temp = temp.next;
    }
    sb.delete(sb.lastIndexOf("\n"), sb.length());

    return sb.toString();
}

测试代码

public static void main(String[] args) {
   
     

    Student2 stu1 = new Student2(1, "lrc");
    Student2 stu2 = new Student2(2, "glw");
    Student2 stu3 = new Student2(3, "yte");

    SingleCircularLinkedList<Student2> scll = new SingleCircularLinkedList<Student2>();

    scll.add(stu1);
    scll.add(stu2);
    scll.add(stu3);

    System.out.println(scll);
}

测试结果

约瑟夫出队 – 需改变链表结构

---

---

代码实现

/**
 * 
 * @Description
 * @param k 开始从第几个节点开始报数
 * @param m 每次报数起，数多少次
 */
public void JosephOut(int k, int m) {
   
     

    // 1. 链表必须有元素
    if(length() == 0) {
   
     
        System.out.println("链表中无元素");
        return;
        // 2. 开始从第几个节点数，必须小于 链表的长度
    }else if(length() < k || k < 0 ) {
   
     
        System.out.println("参数K不符合输入要求");
        return;
    }else {
   
     
        // 3.1 需要两个指针， -个是准备出队的那个节点指针，另一个是firstPointer节点后面那个节点
        Node<T> firstPointer = firstNode;
        Node<T> secondPointer = firstNode; 

        // 3.2 需要到从第K个节点开始遍历出队的指针
        for(int i = 1; i < k; i++) {
   
     
            firstPointer = firstPointer.next;
            if(i >= 2) {
   
     
                secondPointer = secondPointer.next;
            }
        }

        // 3.3 需要一个标志位来判断 firstPointer.secondPointer节点是否是前后关系
        boolean flag = false;

        // 3.4 开始遍历出队
        while(true) {
   
     

            // 3.4.1 有元素出队后，需要重新遍历查找下一个出队的节点 - 移动m-1次
            for(int i = 0; i<m-1; i++) {
   
     
                if(k == 1 && i == 0 && flag == false) {
   
     
                    firstPointer = firstPointer.next;
                    flag = true;
                    continue;
                }else {
   
     
                    firstPointer = firstPointer.next;
                    secondPointer = secondPointer.next;
                }

            }

            // 3.4.2 打印出队元素，并且调整链表中的节点
            System.out.println(firstPointer);
            firstPointer = firstPointer.next;
            secondPointer.next = firstPointer;

            // 如果最后整个单向环形链表只有一个元素，则直接退出循环
            if(secondPointer.next == secondPointer) {
   
     
                break;
            }

        }

        // 4. 打印链表最后一个节点
        System.out.println(secondPointer);
        
        // 5. 将链表置空
        firstNode = null;
    }
}	

约瑟夫问题

代码测试

public static void main(String[] args) {
   
     
    // 1. 定义、初始化6个人
    Student2 stu1 = new Student2(1, "lrc");
    Student2 stu2 = new Student2(2, "glw");
    Student2 stu3 = new Student2(3, "yte");
    Student2 stu4 = new Student2(4, "erw");
    Student2 stu5 = new Student2(5, "ghb");
    Student2 stu6 = new Student2(6, "fgh");
    SingleCircularLinkedList<Student2> scll = new SingleCircularLinkedList<Student2>();
    // 2. 将6个人添加到链表里面
    scll.add(stu1);
    scll.add(stu2);
    scll.add(stu3);
    scll.add(stu4);
    scll.add(stu5);
    scll.add(stu6);

    
    System.out.println("人数N = " + scll.length());
    int M = 5; int K = 1;
    
    // 3. 约瑟夫出列
    scll.JosephOut(K, M);
}

运行结果