# 1.链表的倒数第K个结点

## 代码如下：

//倒数第k个结点

int i=0;
while(cur!=null&i++<k){
cur=cur->next;
}

while(cur!=null){
now=now->next;
cur=cur->next;
}

}



## 代码如下：

//非递归

//利用一个栈
Stack stack;

//将链表的结点压入
while(node!=null){
stack.push(node);
node=node->next;
}
ListNode *popNode;
while(stack.isEmpty()){
//获得最上面的元素
popNode=stack.top();
//打印
printf("%d\t",popNode->value);
//弹出元素
stack.pop();
}

/递归

}
}

}


# 3.如何判断一个链表有环

## 算法思路：

### 方法二、快慢指针

/**
* 判断单链表是否存在环
* @return
*/
public static <T> boolean isLoopList(ListNode<T> head){
ListNode<T> slowPointer, fastPointer;

//使用快慢指针，慢指针每次向前一步，快指针每次两步
while(fastPointer != null && fastPointer.next != null){
slowPointer = slowPointer.next;
fastPointer = fastPointer.next.next;

//两指针相遇则有环
if(slowPointer == fastPointer){
return true;
}
}
return false;
}


# 4.链表中环的大小

## 代码如下

    //求环中相遇结点
//链表为空则返回null
return null;

while(first != null && first.next != null){

first = first.next.next;
second = second.next;
//两指针相遇，则返回相遇的结点
if(first == second)
return first;
}
//链表无环，则返回null
return null;
}

//node为空则代表链表无环
if(node == null)
return 0;
int length=1;
Node current = node.next;
//再次相遇则循环结束
while(current != node){
length++;
current = current.next;
}

return length;

}


# 5.链表中环的入口结点

## 代码如下

public class Solution {
{
return null;
while(fast != null){
if(fast == slow){
while(fast != slow){
fast = fast.next;
slow = slow.next;
}
return fast;
}
slow = slow.next;
fast = fast.next.next;
}
return null;
}
}



# 6.单链表在时间复杂度为O(1)删除链表结点

## 代码如下

/* Delete a node in a list with O(1)
*            pToBeDeleted - the node to be deleted
*/

struct  ListNode
{
int            m_nKey;
ListNode*    m_pNext;
};

{
return;

if (pToBeDeleted->m_pNext != NULL) {
ListNode *pNext = pToBeDeleted->m_pNext;
pToBeDeleted->m_pNext = pNext->m_pNext;
pToBeDeleted->m_nKey = pNext->m_nKey;

delete pNext;
pNext = NULL;
}
else { //待删除节点为尾节点
while(pTemp->m_pNext != pToBeDeleted)
pTemp = pTemp->m_pNext;
pTemp->m_pNext = NULL;

delete pToBeDeleted;
pToBeDeleted = NULL;
}
}


# 7.两个链表的第一个公共结点

## 代码如下


/*
public class ListNode {
int val;
ListNode next = null;

ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
return null;
}
int count1 = 0;
while (p1!=null){
p1 = p1.next;
count1++;
}
int count2 = 0;
while (p2!=null){
p2 = p2.next;
count2++;
}
int flag = count1 - count2;
if (flag > 0){
while (flag>0){
flag --;
}
}
}
if (flag <= 0){
while (flag<0){
flag ++;
}
}
}
return null;
}
}



# 8.合并两个排序的链表

## 代码如下

/*
public class ListNode {
int val;
ListNode next = null;

ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {

while (list1 != null && list2 != null) {
if (list1.val <= list2.val) {
cur.next = list1;
list1 = list1.next;
} else {
cur.next = list2;
list2 = list2.next;
}
cur = cur.next;
}
if (list1 != null)
cur.next = list1;
if (list2 != null)
cur.next = list2;
}

}


# 9.复杂的链表复制

## 问题描述

下图是一个含有5个结点的复杂链表。图中实线箭头表示m_pNext指针，虚线箭头表示m_pSibling指针。为简单起见，指向NULL的指针没有画出。

## 算法思路

### 第一种：O(n2)的普通解法

第一步是复制原始链表上的每一个结点，并用Next节点链接起来；
第二步是设置每个结点的Sibling节点指针。

### 第二种 ：借助辅助空间的O(n)解法

第一步仍然是复制原始链表上的每个结点N创建N'，然后把这些创建出来的结点用Next链接起来。同时我们把<N,N'>的配对信息放到一个哈希表中。
第二步还是设置复制链表上每个结点的m_pSibling。由于有了哈希表，我们可以用O(1)的时间根据S找到S'。

### 第三种：不借助辅助空间的O(n)解法

第一步仍然是根据原始链表的每个结点N创建对应的N'。（把N'链接在N的后面）

第二步设置复制出来的结点的Sibling。（把N'的Sibling指向N的Sibling）

第三步把这个长链表拆分成两个链表：把奇数位置的结点用Next链接起来就是原始链表，偶数数值的则是复制链表。

## 代码如下

public class Solution {

return null;
}

//1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
while(currentNode != null){
RandomListNode cloneNode = new RandomListNode(currentNode.label);
RandomListNode nextNode = currentNode.next;
currentNode.next = cloneNode;
cloneNode.next = nextNode;
currentNode = nextNode;
}

//2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
while(currentNode != null) {
currentNode.next.random = currentNode.random==null?null:currentNode.random.next;
currentNode = currentNode.next.next;
}

//3、拆分链表，将链表拆分为原链表和复制后的链表
while(currentNode != null) {
RandomListNode cloneNode = currentNode.next;
currentNode.next = cloneNode.next;
cloneNode.next = cloneNode.next==null?null:cloneNode.next.next;
currentNode = currentNode.next;
}

}
}


# 10.反转链表

## 代码如下

public class ReverseList_16 {

}
}

ListNode newList = new ListNode(-1);
}
return newList.nextNode;
}
}



https://blog.csdn.net/u010983881/article/details/78896293

https://blog.csdn.net/inspiredbh/article/details/54915091

https://www.jianshu.com/p/092d14d13216

https://www.cnblogs.com/bakari/p/4013812.html

http://www.cnblogs.com/edisonchou/p/4790090.html

https://blog.csdn.net/u013132035/article/details/80589657

posted @ 2018-12-02 20:23  辰砂tj  阅读(7040)  评论(0编辑  收藏