# 单链表

package com.lxk.linkedList.oneWay;

/**
* Created by lxk on 2017/8/1
*/
public class Node<K, V> {
private final K key;
private V value;
private Node<K, V> next;

public Node(K key, V value, Node<K, V> next) {
this.key = key;
this.value = value;
this.next = next;
}

public K getKey() {
return key;
}

public V getValue() {
return value;
}

public void setValue(V value) {
this.value = value;
}

public Node<K, V> getNext() {
return next;
}

public void setNext(Node<K, V> next) {
this.next = next;
}
}

package com.lxk.linkedList.oneWay;

/**
* 单向链表
* <p>
* Created by lxk on 2017/8/1
*/

/**
* 获得单向链表（头插法生成的单向链表--后来的在链表头部）
*/
public static Node<Integer, Integer> getOneWayLinkedList() {
Node<Integer, Integer> temp = null;
for (int i = 1; i <= 6; i++) {
temp = new Node<>(i, i, temp);//头插法：先来的在链尾
}
return temp;
}

/**
* 获得单向链表（尾插法生成的单向链表--后来的链在链表尾部）
*/
public static Node<Integer, Integer> getOneWayLinkedListTail() {
Node<Integer, Integer> headWillMove = new Node<>(1, 1, null);
for (int i = 2; i <= 6; i++) {
}
}

/**
* 输出单向链表
*/
StringBuilder sb = new StringBuilder();
sb.append("{");
}
sb.append("}");
System.out.println(sb.toString());
}

/**
* 获得单向链表的最后一个节点
*/
public static Node<Integer, Integer> getLastNode(Node<Integer, Integer> linkedList) {
}
}

/**
* 获得链表的长度
*/
int size = 0;
size++;
}
return size;
}

/**
* 在链表指定位置之后插入元素
*/
public static void insertInLinkedList(int index, int key, int value, Node<Integer, Integer> linkedList) {
if (index < 0 || index >= size) {
System.out.println("out of index bounds");
return;
}
for (int i = 0; i < size; i++) {
if (index == i) {
break;
}
}
}

/**
* 在链表指定位置之后删除节点
*/
if (index < 0 || index >= size) {
System.out.println("out of index bounds");
return;
}
for (int i = 0; i < size; i++) {
if (index == i) {
System.out.println("out of index bounds");
break;
}
break;
}
}
}

}


# 单向循环链表

package com.lxk.linkedList.circularList;

/**
* 循环链表
* <p>
* Created by lxk on 2017/8/1
*/
public class CircularOneWayList {

/**
* 获得单向循环链表
*
* @return 获得单向循环链表，默认返回的就链表头。
*/
public static Node<Integer, Integer> getCircularOneWayList() {
//获得的单向链表的头
//找到这个链表的尾
//首尾相连，就成环了。
}

/**
* 获得循环链表的长度(要想获得长度，得设置个停止标记。)
*
*/
//注意：前提条件-->假设所有的值不重复，才能这么干。
int size = 1;//默认从1开始，循环到1时结束，
size++;
}
return size;
}

}


# 最后，看主测试代码

package com.lxk.linkedList;

/**
* 链表测试
* <p>
* Created by lxk on 2017/8/1
*/
public class Main {
public static void main(String[] args) {
testCircularOneWayList();//循环链表
}

/**
* 测试循环链表
*/
private static void testCircularOneWayList() {
}

/**
* 测试单向链表
*/
}

}


©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客