链表问题总结
- 链表
链表是一种基本的一维离散存储数据结构。相对于数组，它是离散内存的，不能如数组一样通过下标来查询相应地数据，每一个链表节点只能知道它的上一个（双端链表）和它的下一个（单链表，双端链表）节点。C语言通过malloc/free控制内存，C++里通过new/delete，Java则是只有new对象。
1.Java链表节点定义
class Node{
private Node next;
private int data;
public Node(){
}
public Node(int data){
this.data=data;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
2.链表操作类
class LinkedList{
private Node first;
public Node getfirst() {
return first;
}
public void setfirst(Node first) {
this.first = first;
}
//按值搜寻第一个等于目标的节点
public Node findNode(int target){
if(first==null){
System.out.println("initialise the first");
return null;
}
Node p=first;
while(p.getData()!=target && p!=null)
p=p.getNext();
return p;
}
public Node findPreNode(Node target){
if(first==null){
System.out.println("initialise the first");
return null;
}
Node p=first;
while(p.getNext()!=target)
p=p.getNext();
return p;
}
//返回链表下标查找
public int IndexOfNode(int target){
int index=1;
if(first==null){
System.out.println("initialise the first");
return -1;
}
Node p=first;
while(p.getData()!=target)
{
index++;
p=p.getNext();
if(p==null)
{
index=-1;
break;
}
}
return index;
}
//在末尾添加节点
public void addNode(Node add){
if(first==null){
first=add;
add.setNext(null);
return;
}
Node p=first;
while(p.getNext()!=null)
p=p.getNext();
p.setNext(add);
add.setNext(null);
}
//头插法生成链表
public void headAdd(Node node){
if(first == null){
first=node;
node.setNext(null);
}else{
node.setNext(first);
first=node;
}
}
//删除节点--须指定链表中的节点
public void deleteNode(Node toDel){
if(first==null){
System.out.println("initialise the first");
return ;
}
Node p=toDel.getNext();
if(p!=null)
{
toDel.setNext(p.getNext());
toDel.setData(p.getData());
p.setNext(null);
}else{
deleteEndNode(toDel);
}
}
//删除末尾
public void deleteEndNode(Node toDel){
Node p=first;
while(p.getNext()!=toDel && p!=null)
p=p.getNext();
p.setNext(null);
}
//常规删除
public void deleteNormal(Node toDel){
Node p=findPreNode(toDel);
p.setNext(toDel.getNext());
toDel.setNext(null);
}
//修改一个节点的值
public void update(Node target,int value){
if(first==null){
System.out.println("initialise the first");
return ;
}
target.setData(value);
}
public void printList(){
if(first==null){
System.out.println("initialise the first");
return ;
}
Node p=first;
while(p!=null){
System.out.print(p.getData()+" ");
p=p.getNext();
}
System.out.println();
}
}
小记：(1) 生成单链表可以有头插法和尾插法，尾插法的添加节点为O（n）复杂，删除也是O（n）；头插法添加则是O（1），删除还是O（n)。
(2) 删除方法有一个是O（1）复杂度的。方法：给定一个节点，删除它下一个节点并把下一个节点的值转移到给定节点。
- 问题1：删除链表内重复的节点。（数据重复）
因为使用的是那个O（1）删除的方法，所以写得有些奇怪。总体方法就是使用一个O（n）空间来存储节点，发现重复就删除，遍历时间复杂就只用O（n）。
//删除未排序链表重复节点1 缓冲区版
public void DelRepeated1(LinkedList list){
HashMap<Integer,Boolean> buffer=new HashMap<Integer,Boolean>();
Node p=list.getfirst();
while(p!=null){
System.out.println("data="+p.getData());
if(buffer.get(p.getData())==null){
buffer.put(p.getData(), true);
}
else
{
list.deleteNode(p);
while(true){
if(buffer.get(p.getData())!=null)
list.deleteNode(p);
else
break;
}
}
p=p.getNext();
}
}
若不使用缓冲区，则只能使用暴力遍历法，从当前节点开始到表尾“排除异己”，“步步为营”。复杂度O（n*n）。
并且删除方法是使用O（n）复杂度的。
//删除未排序俩表重复节点2 无缓冲区
public void DelRepeated2(LinkedList list) {
Node p = list.getfirst();
Node q = list.getfirst().getNext();
while(p!=null){
q = p.getNext();
while(q!=null){
if(p.getData()==q.getData())
list.deleteNormal(q);
q=q.getNext();
}
p = p.getNext();
}
}
- 问题2：寻找倒数低k个节点。
这个问题其实挺简单，如果链表是你自建的，那么添加个length或size属性记录那么解决这个问题就方便多了。如果仅给定一个单链表，则遍历一次找出length再以互补或互余的思维来求出倒k的下标。
//寻找倒数第k个节点
public Node findNK(LinkedList list,int k){
if(k<=0)
{
System.out.println("k should be upper than 0");
return null;
}
int n=0;
Node p=list.getfirst();
while(p!=null)
{
n++;
p=p.getNext();
}
int result=n-k;
if(n-k<0)
{
System.out.println("index out of range");
return null;
}
p=list.getfirst();
while(result!=0){
p=p.getNext();
result--;
}
return p;
}
- 问题3：给定一个值x，将链表分割成两部分，大于x部分和小与x部分。
接到这道题的时候，我马上蹦出一个想法：排序。排完序就解决了。最快的排序算法也是O（n*logn）。然后想到快速排序，快速排序的partition函数可以一次将数组的分割成以基准元素为分界点的序列。这么一想，这道题可以做成O（n）复杂度了。实现它需要的数据结构为双端链表。
//双端链表分割
public void DivideLink(DoubleLink dl,int element){
DoubleNode tail=dl.getEnd().getPre();
DoubleNode first=dl.getFirst();
first.setData(element);
int start=1;
int end=dl.getLength();
int x=element;
while(start<end){
while(start<end && tail.getData()>=x)
{
end--;
tail=tail.getPre();
}
if(start<end){
start++;
first.setData(tail.getData());
first=first.getNext();
}
while(start<end && first.getData()<=x)
{
start++;
first=first.getNext();
}
if(start<end){
tail.setData(first.getData());
end--;
tail=tail.getPre();
}
}
first.setData(x);
}
循环链表的实现：
class DoubleLink{
DoubleNode first;
DoubleNode end;
DoubleNode current;
int length=0;
//初始化空双端链表
public DoubleLink(){
first=new DoubleNode();
end=new DoubleNode();
first.setNext(end);
end.setNext(first);
first.setPre(end);
end.setPre(first);
current=first;
}
public int getLength(){
return length;
}
public DoubleNode getFirst() {
return first;
}
public void setFirst(DoubleNode first) {
this.first = first;
}
public DoubleNode getEnd() {
return end;
}
public void setEnd(DoubleNode end) {
this.end = end;
}
public void InsertNode(DoubleNode node){
current.setNext(node);
node.setPre(current);
current=node;
end.setPre(node);
node.setNext(end);
length++;
}
public void RemoveNode(DoubleNode toDel){
DoubleNode p = toDel.getPre();
DoubleNode q = toDel.getNext();
p.setNext(q);
q.setPre(p);
toDel.setPre(null);
toDel.setNext(null);
// if (toDel != first && toDel != end) {
// p.setNext(q);
// q.setPre(p);
// }else if(toDel == first){
// first=q;
// p.setNext(q);
// q.setPre(p);
// }else if(toDel == end){
// end=p;
// p.setNext(q);
// q.setPre(p);
// }
length--;
}
public void UpdateNode(DoubleNode toUpdate,int data){
toUpdate.setData(data);
}
public DoubleNode SearchNode(int data){
DoubleNode p=first.getNext();
while(p.getData()!=data && p!=end)
p=p.getNext();
if(p==end)
p=null;
return p;
}
public int IndexOfNode(DoubleNode search){
int index=0;
DoubleNode p=first;
while(p!=end && p!=search){
p=p.getNext();
index++;
}
if(p==end)
index=-1;
return index;
}
public void printLink(){
DoubleNode p=first.getNext();
while(true){
if(p==end)
break;
System.out.print(p.getData() + " ");
p = p.getNext();
}
System.out.println();
}
}
class DoubleNode{
private int data;
private DoubleNode pre;
private DoubleNode next;
public DoubleNode(){
}
public DoubleNode(int data){
this.data=data;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public DoubleNode getPre() {
return pre;
}
public void setPre(DoubleNode pre) {
this.pre = pre;
}
public DoubleNode getNext() {
return next;
}
public void setNext(DoubleNode next) {
this.next = next;
}
}
- 问题四：链表加法，每一个节点为一个数位，分别分两种方法来实现，高位到低位、低位到高位。
//链表加法
public LinkedList ListAdd1(LinkedList list1,LinkedList list2){
Node current1=list1.getfirst();
Node current2=list2.getfirst();
LinkedList result=new LinkedList();
int carry=0;
int count;
result.setfirst(new Node(-1));
while(current1 != null && current2 != null){
count=carry+current1.getData()+current2.getData();
carry=count/10;
count=count%10;
Node reNode=new Node(count);
result.addNode(reNode);
current1=current1.getNext();
current2=current2.getNext();
}
while(current1 != null){
Node reNode=new Node(current1.getData()+carry);
result.addNode(reNode);
current1=current1.getNext();
carry=0;
}
while(current2 != null){
Node reNode=new Node(current2.getData()+carry);
result.addNode(reNode);
current1=current2.getNext();
carry=0;
}
if(carry!=0){
Node reNode=new Node(carry);
result.addNode(reNode);
}
return result;
}
public LinkedList ListAdd2(LinkedList list1, LinkedList list2) {
int number1 = 0;
int number2 = 0;
Node f1 = list1.getfirst();
Node f2 = list2.getfirst();
LinkedList result = new LinkedList();
while (f1 != null) {
number1 = number1 * 10 + f1.getData();
f1 = f1.getNext();
}
while (f2 != null) {
number2 = number2 * 10 + f2.getData();
f2 = f2.getNext();
}
int count = number1 + number2;
int rank=1;
int temp=count;
while(temp>10)
{
temp=temp/10;
rank=rank*10;
}
temp=count;
while (rank != 0) {
result.addNode(new Node(temp/rank));
temp%=rank;
rank/=10;
}
return result;
}
- 问题五：链表查环，从哪个节点开始成环的，输出节点。
这个解法还是hashmap。
//链表查环
public Node findCircle(LinkedList list){
HashMap<Node,Boolean> map=new HashMap<Node,Boolean>();
Node p=list.getfirst();
while(true){
if(map.get(p)==null)
map.put(p, true);
else
break;
System.out.println(p.getData());
p=p.getNext();
}
return p;
}
- 问题六：链表回文检测。每个数据位存储字符，一个字符串是否回文。
关键点是使用栈来保存状态，到中点的时候开始pop，如果发现不是回文，则返回false。
//回文检测
public <T> boolean LinkedPalindrome(ArrayList<T> list){
boolean isPalindrome=true;
ArrayList<T> stack=new ArrayList<T>();
int i=-1;
int isEven=list.size()%2;
int mid=list.size()/2;
System.out.println("mid="+mid);
for(int j=0;j<list.size();j++){
T data=list.get(j);
if(j<mid)
{
stack.add(data);
i++;
}
else {
if (isEven == 0) {
if(data==stack.get(i))
{
i--;
continue;
}else
{
isPalindrome=false;
break;
}
}else if(isEven == 1){
if(j==mid)
continue;
else{
if(data==stack.get(i))
{
i--;
continue;
}else{
isPalindrome=false;
break;
}
}
}
}
System.out.println("j="+data+" i="+stack.get(i));
}
return isPalindrome;
}
- 问题七：链表找环
把我以前的代码复制过来了，追赶法。
bool IfCircle(LinkList *root) { /* 追赶式验证是否存在环 */ LinkList *fast=root; LinkList *slow=root; while(fast && slow) { fast=fast->p_next; fast=fast->p_next; if(fast==slow) return true; slow=slow->p_next; } return false; }
