链表的基本操作

原创 2016年06月01日 23:37:48
package com.zyf.data;

import java.util.Hashtable;

import org.junit.Test;

/**
 *链表的基本操作 
 * @author zyf
 *
 */
public class MyLinkedList{
	Node head = null;//链表头引用
	public void addNode(int d){
		Node newNode = new Node(d);
		if(head == null){
			head = newNode;
			return;
		}
		Node tmp = head;
		while(tmp.next != null){
			tmp = tmp.next;
		}
		//add node to end
		tmp.next = newNode;
	}
	/**
	 * @param index:删除第index个结点
	 * @return 成功返回true, 失败返回false
	 */
	public Boolean deleteNode(int index){
		if(index <1 || index > length()){
			return false;
		}
		//删除链表第一个元素
		if(index == 1){
			head = head.next;
			return true;
		}
		int i = 1;
		Node preNode = head;
		Node curNode = preNode.next;
		while(curNode != null){
			if(i == index){
				preNode.next = curNode.next;
				return true;
			}
			preNode = curNode;
			curNode = curNode.next;
			i++;
		}
		return true;
	}
	/**
	 * @return 返回结点的长度
	 */
	public int length(){
		int length = 0;
		Node tmp = head;
		while(tmp != null){
			length ++;
			tmp = tmp.next;
		}
		return length;
	}
	/**
	 * 对链表进行排序
	 * 返回排序后的头结点
	 */
	public Node orderList(){
		Node nextNode = null;
		int temp = 0;
		Node curNode = head;
		while(curNode.next != null){
			nextNode = curNode.next;
			while(nextNode != null){
				if(curNode.data > nextNode.data){
					temp = curNode.data;
					curNode.data = nextNode.data;
					nextNode.data = temp;
				}
				nextNode = nextNode.next;
			}
			curNode = curNode.next;
		}
		return head;
	}
	public void printList(){
		Node tmp = head;
		while(tmp != null){
			System.out.println(tmp.data);
			tmp = tmp.next;
		}
	}
	@Test
	public static void main(String[] args){
		MyLinkedList list = new MyLinkedList();
		list.addNode(5);
		list.addNode(3);
		list.addNode(1);
		list.addNode(3);
		System.out.println("listLen = " + list.length());
		System.out.println("before order:");
		list.printList();
		list.orderList();
		System.out.println("after order:");
		list.printList();
		//findElem(1,2);
	}
	//从链表中删除重复的数据
	public void deleteDuplecate(Node head){
		Hashtable<Integer,Integer> table = new Hashtable<Integer,Integer>();
		Node tmp = head;
		Node pre = null;
		while(tmp!=null){
			if(table.containsKey(tmp.data))
				pre.next = tmp.next;
			else{
				table.put(tmp.data, 1);
				pre=tmp;
			}
			tmp = tmp.next;
	}
	}
	
	public void deleteDuplecate_1(Node head){
		Node p = head;
		while(p != null){
			Node q = p;
			while(q.next != null){
				if(p.data == q.next.data){
					q.next = q.next.next;
				}else
					q = q.next;
			}
			p = p.next;
		}
	}
	//如何找出单链表中的倒数第k个元素
	@Test
	public Node findElem(Node head,int k){
		if(k<1 || k >this.length())
			return null;
		Node p1 = head;
		Node p2 = head;
		for(int i =0 ;i < k-1;i++)
			p1 = p1.next;
		while(p1 != null){
			p1 = p1.next;
			p2 = p2.next;
		}
		return p2;
	}
	//如何实现链表的反转
	public void ReverseIteratively(Node head){
		Node pReversedHead = head;
		Node pNode = head;
		Node pPrev = null;
		while(pNode != null){
			Node pNext = pNode.next;
			if(pNext == null)
				pReversedHead = pNode;
			pNode.next = pPrev;
			pPrev = pNode;
			pNode = pNext;
		}
		this.head = pReversedHead;
	}
	//如何从尾到头输出单链表
	public void printListReversely(Node pListHead){
		if(pListHead != null){
			printListReversely(pListHead.next);
			System.out.println(pListHead.data);
		}
	}
	//如何寻找单链表的中间结点
	public Node SearchMid(Node head){
		Node p = this.head;
		Node q = this.head;
		while(p != null && p.next != null && p.next.next != null){
			p = p.next.next;
			q = q.next;
		}
		return q;
	}
	//如何检测一个链表是否有环
	 public boolean IsLoop(Node head){
		 Node fast = head;
		 Node slow = head;
		 if(fast == null){
			 return false;
		 }
		 while(fast!=null && fast.next != null){
			 fast = fast.next.next;
			 slow = slow.next;
			 if(fast == slow){
				 return true;
			 }
		 }
		 return !(fast == null || fast.next == null);
	 }
	 public Node FindLoopPort(Node head){
		 Node slow = head,fast = head;
		 while(fast != null && fast.next != null){
			 slow = slow.next;
			 fast = fast.next.next;
			 if(slow == fast) break;
		 }
		 if(fast == null || fast.next == null)
			 return null;
		 slow = head;
		 while(slow != fast){
			 slow = slow.next;
			 fast = fast.next;
		 }
		 return slow;
	 }
	 //如何在不知道头指针的情况下删除指定结点
	 public boolean deleteNode(Node n){
		 if(n == null || n.next == null)
			 return false;
		 int tmp = n.data;
		 n.data = n.next.data;
		 n.next.data = tmp;
		 n.next = n.next.next;
		 return true;
	 }
	 //如何判断两个链表是否相交
	 public boolean isIntersect(Node h1,Node h2){
		 if(h1 == null || h2 == null)
			 return false;
		 Node tail1 = h1;
		 while(tail1.next != null)
			 tail1 = tail1.next;
		 Node tail2 = h2;
		 while(tail2.next != null){
			 tail2 = tail2.next;
		 }
		 return tail1 == tail2;
	 }
	 
	 public static Node getFirstMeetNode(Node h1,Node h2){
		 if(h1 == null || h2 == null)
			 return null;
		 Node tail = h1;
		 int len1 = 1;
		 //找到链表h1的最后一个结点
		 while(tail.next != null){
			 tail = tail.next;
			 len1 ++;
		 }
		 Node tail2 = h2;
		 int len2 = 1;
		 while(tail2.next != null){
			 tail2 = tail2.next;
			 len2 ++;
		 }
		 
		 if(tail != tail2){
			 return null;
		 }
		 Node t1 = h1;
		 Node t2 = h2;
		 //找出较长的链表,先遍历
		 if(len1 > len2){
			 int d = len1 = len2;
			 while(d != 0){
				 t1 = t1.next;
				 d--;
			 }
		 }
		 else{
			 int d = len2 - len1;
			 while(d != 0){
				 t2 = t2.next;
				 d--;
			 }
		 }
		 while(t1 != t2){
			 t1 = t1.next;
			 t2 = t2.next;
		 }
		 return t1;
	 }
	 //.
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

【数据结构】 链表的19种基本操作(完整版)

基于这篇文章: http://www.cnblogs.com/lifuqing/archive/2011/08/20/List.html 作者最后只给出了前面12中操作的代码,这里我帮他补全 链表...
  • fanxingzju
  • fanxingzju
  • 2014年04月03日 17:11
  • 1496

c++实现单链表基本操作

程序媛决定好好学习写代码 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时...
  • u011200403
  • u011200403
  • 2017年02月13日 19:33
  • 1094

c++ 单链表基本操作

#include #include #include #include #include /*c++实现简单的单链表操作*/ using namespace std; typedef str...
  • cfan0801
  • cfan0801
  • 2012年03月13日 21:01
  • 24591

链表基本操作及其过程详细叙述

链表概述:链表是一种常见的数据结构。数组可以存放数据,但是使用数组时要先指定数组中包含元素的个数,即数组长度。根据对链表的描述,可以想象到链表就像一个铁链,一环扣一环。然后通过头指针寻找链表中的元素,...
  • dezhihuang
  • dezhihuang
  • 2014年09月07日 10:15
  • 8073

入门:链表的基本操作

入门:链表的基本操作标签:C语言 链表By 小威威1.写这篇博文的原因C语言有三大重要部分:流程控制、函数、指针。 对于指针,单单了解它的简单应用是不够的,最重要的还是学习链表。许多参考书对链表的...
  • linwh8
  • linwh8
  • 2015年11月05日 00:15
  • 2414

数据结构之链表基本操作总结

数组与链表的区别  数组(顺序存储)和链表(链式存储)是两种不同的数据存储方式。 数组是一组具有相同类型和名称的变量的集合,这些变量称为数组的元素,每个数组元素都有一个编号,这个编号称...
  • Lily_whl
  • Lily_whl
  • 2017年05月11日 18:22
  • 1309

实例讲解C++ 双链表基本操作

1.概念   双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。一般我...
  • whChina
  • whChina
  • 2016年04月26日 08:09
  • 1982

C++实现链表基本操作

前几天找实习的时候,一个面试官给我留了一个题,做一个链表demo,要求实现创建、插入、删除等操作。 链表是一种常见的数据结构,它是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链...
  • Kevin_zhai
  • Kevin_zhai
  • 2016年01月10日 21:56
  • 37049

关于链表操作编程实现的一些总结

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:...
  • zmajun
  • zmajun
  • 2015年07月28日 16:25
  • 415

用java简单的实现单链表的基本操作

此代码仅供参考,如有疑问欢迎评论: package com.tyxh.link; //节点类 public class Node { protected Node next; //指针域 ...
  • tayanxunhua
  • tayanxunhua
  • 2013年09月04日 23:41
  • 88953
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:链表的基本操作
举报原因:
原因补充:

(最多只允许输入30个字)