数据结构-单链表相关操作

一:单链表的相关操作

 1.1:单链表增加一个元素

 1.2:单链表删除指定位置的元素(删除某个元素)

 1.3:单链表打印

 1.4:单链表的反转

 1.5:单链表找出倒数第k个节点的元素

 1.6:从尾到头打印一个单链表

 1.7:找出单链表中中间节点的值

二:代码(java实现)

2.1:构造一个节点,相当于Java中的结构体

	/**
	 * 相当于结构体类
	 */
	class ChainNode {
		int data;
		ChainNode next;

		public ChainNode(int data) {
			this.data = data;
		}
	}

2.2:向单链表中增加一个元素

/**
	 * 向链表中增加添加数据
	 * 步骤:
	 * 1:判断头结点是否为空,空的话直接插到头节点上
	 * 2:不插头部的话 
	 *    2.1:我们使用未插法  
	 *    2.2:一个指针从头部向后移,移动尾部,数据添加链尾
	 */
	public void addNode(int data) {
		ChainNode node = new ChainNode(data);
		if (head == null) {
			head = node;
			return;
		}
		ChainNode temp = head;
		// 移动指针到尾节点
		while (temp.next != null) {
			temp = temp.next;
		}
		// 从尾节点插入
		temp.next = node;
	}

2.3:从头到尾输出链表内容

	/**
	 * 输出链表数据
	 * 步骤:
	 *   1:节点不为空,输出数据域
	 *   2:节点后移
	 */
	public void printList() {
		ChainNode node = head;
		while (node != null) {
			System.out.print(node.data + "，");
			node = node.next;
		}
	}

2.4:从尾到头输出链表内容

	/**
	 * 从尾到头打印节点
	 * 
	 * @param head2
	 *步骤: 1:使用递归的方式,在C语言中我们一般使用栈来解决 
	 * 2:把链表从头到尾遍历一遍放到栈中,在从栈中去读
	 */
	private void printReverseList(ChainNode headNode) {
		if (headNode != null) {
			printReverseList(headNode.next);
			System.out.print(headNode.data + ",");
		}

	}

2.5:获得链表长度

	/**
	 * 得到链表的长度
	 * 步骤: 
	 * 1:初始length=0,temp指针指向头结点
	 * 2:temp不为空,指针后移,length++
	 */
	public Integer length() {
		int length = 0;
		if (head != null) {
			ChainNode temp = head;
			while (temp != null) {
				temp = temp.next;
				length++;
			}
		}
		return length;
	}

2.5:删除指定位置的节点

/**
	 * 链表删除一个某个指定节点的数据
	 * 步骤:
	 * 1:判断给的位置是否合理(<0获得大于链表长度)
	 * 2:删除节点为头节点 
	 *   2.1:删除头节点
	 *   2.2:不是头结点
	 *      2.2.1:初始化两个节点（我们删除某个节点的时候需要记住这个节点的前一个位置）
	 *      2.2.2：当前节点不为空,两个指针后移count++(初始化为2),知道index==conut
	 * 
	 */
	private boolean deleteNode(int index) {
		// 数组下表小于0或者大于数组长度
		if (head == null || index < 0 || index > length()) {
			return false;
		}
		if (index == 1) {
			// 删除头节点
			head = head.next;
		}
		// 删除非头节点
		int count = 2;
		ChainNode preNode = head;
		ChainNode curNode = preNode.next;
		while (curNode != null) {
			if (count == index) {
				preNode.next = curNode.next;
				curNode.next = null;
				return true;
			}
			// 坐标后移
			preNode = curNode;
			curNode = curNode.next;
			count++;
		}
		return false;
	}

2.6:实现链表的反转

/**
	 * 实现链表的反转 
	 * 步骤 1:
	 *  1: 用三个指针 preNode,currentNode,nextNode, nextNode暂存下一个节点
	 *  2:当前节点不为空
	 *     2.1:nextNode暂存下一个节点
	 *     2.2:当前节点指向上一个节点
	 *     2.3:preNode curNode后移
	 *
	 */
	private void reverserNode() {
		if (head == null) {
			return;
		}
		ChainNode preNode = head;
		ChainNode curNode = head.next;
		ChainNode nextNode = null;
		while (curNode != null) {
			// 暂存下一节点
			nextNode = curNode.next;
			// 当前节点指向上一个节点
			curNode.next = preNode;
			// 指针后移
			preNode = curNode;
			curNode = nextNode;
		}
	//不为空会出现环
		head.next = null;
		this.head = preNode;
	}

2.7: 找出单链表中倒数第k个节点

	 * 找出单链表中倒数第K个位置 
	 * 步骤:
	 *  1:设置两个指针,第一个指针比第二个指针早走K步, 
	 *  2:第一个指针到达末尾.第二个指针刚好在第K的位置
	 * 
	 */
	private ChainNode findInverseNode(int k) {
		if (head == null || k < 0 || k > length()) {
			return null;
		}
		ChainNode frontNode = head;
		ChainNode rearNode = head;
		for (int i = 0; i < k; i++) {
			rearNode = rearNode.next;
		}
		while (rearNode.next != null) {
			frontNode = frontNode.next;
			rearNode = rearNode.next;
		}
		return frontNode;
	}

2.8:找出链表中的中间节点的值

 /**
     * 寻找单链表的中间节点
     * 思路：
     *  设置两个工作指针，frontNode一次走一步、rearNode一次走两步
     *  当rearNode到达链表尾部时，frontNode指向的就是单链表的中间节点
     *  注：
     *      当链表的个数为奇数时，frontNode指向的就是中间的节点
     *      当链表的个数为偶数时，frontNode指向的节点和frontNode。next都是链表的中间节点
     */
	private ChainNode findMidNode() {
		ChainNode frontNode = head;
        ChainNode rearNode = head;
        while(rearNode != null && rearNode.next != null && rearNode.next.next != null){
            frontNode = frontNode.next;
            rearNode = rearNode.next.next;
        }
        return frontNode;
	}

三:源代码下载