单链表OJ题
解题思想是创建两个头结点,分别对应两个单链表的首节点,再建立一个双重循环,判断两个节点是否存在重合,如果重合则相交,返回相交节点
代码如下
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
struct ListNode* first=headA;
struct ListNode* second=headB;
while(first){
second=headB;
while(second){
if(first==second){
return first;
}
second=second->next;
}
first=first->next;
}
return NULL;
}
解释思想是快慢指针,创建两个指针都指向头结点,在一个快指针存在且它的NEXT域存在的循环中,慢指针每次偏移一位,快指针每次偏移两位,判断是否重合,如果重合,则存在环,如果直至循环结束也不重合,则不存在环
代码如下
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
bool hasCycle(struct ListNode *head) {
struct ListNode* fast=head;
struct ListNode* slow=head;
while(fast&&fast->next){
fast=fast->next->next;
slow=slow->next;
if(fast==slow){
return true;
}
}
return false;
}
解释思想是快慢指针,创建两个指针都指向头结点,在一个快指针存在且它的NEXT域存在的循环中,慢指针每次偏移一位,快指针每次偏移两位,判断是否重合,如果重合,则存在环,如果直至循环结束也不重合,则不存在环，但存在环的时候,在建立一个循环,建立一个新的首节点,令首节点和慢指针每次都偏移一个单位,当两个节点重合的时候,则这个节点就是链表入环的第一个节点
代码如下
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode Node;
struct ListNode *detectCycle(struct ListNode *head) {
Node* fast=head;
Node* slow=head;
while(fast && fast->next){
fast=fast->next->next;
slow=slow->next;
if(fast==slow){
Node* first=head;
while(first != slow){
first=first->next;
slow=slow->next;
}
return first;
}
}
return NULL;
} 
解题思想是先建立一个指针指向链表的首元素,在在这个指针存在的循环中,依次申请新节点,将新节点依次放到 原链表的每个元素的后,将原链表的值也拷贝到新的当中,循环结束之后,在建立一个新的节点指向链表的首元素,再将链表的后一个元素拷贝前一个元素的random域,每次循环偏移两个单位,在建立一个循环,断开两个链表即可
代码如下
/**
* Definition for a Node.
* struct Node {
* int val;
* struct Node *next;
* struct Node *random;
* };
*/
typedef struct Node Node;
struct Node* copyRandomList(struct Node* head) {
if(head==NULL){
return NULL;
}
Node* cur=head;
while(cur){
Node* newNode=(Node*)malloc(sizeof(Node));
newNode->val=cur->val;
newNode->next=cur->next;
newNode->random=NULL;
cur->next=newNode;
cur=newNode->next;
}
cur=head;
while(cur){
Node* newNode=cur->next;
if(cur->random){
newNode->random=cur->random->next;
}
cur=newNode->next;
}
cur=head;
Node* newHead=head->next;
Node* first=NULL;
while(cur->next){
first=cur->next;
cur->next=first->next;
cur=first;
}
return newHead;
}
解题思想是先建立一个新的节点,新节点的next域指向连连的首元素,建立一个从首元素开始的,元素存在且它的NEXT域存在的循环,如果节点 的next域的值大于这个节点的值,则结束本次循环,如果不大于,则从这个链表的首元素开始遍历,知道寻找到适合他的位置结束,,最后返回新节点的next域
代码如下
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
/*
typedef struct ListNode Node;
struct ListNode* insertionSortList(struct ListNode* head){
while(head){
Node* newhead=(Node*)malloc(sizeof(Node));
Node*
head=head->next;
}
}
*/
typedef struct ListNode Node;
struct ListNode* insertionSortList(struct ListNode* head){
if(head==NULL){
return NULL;
}
Node* newhead=(Node*)malloc(sizeof(Node));
newhead->next=head;//newhead是首地址
while(head!=NULL && head->next!=NULL){
if(head->val<=head->next->val){
head=head->next;
continue;
}
Node* front=newhead;
while(head->next->val>=front->next->val){
front=front->next;
}
Node* s=head->next;
head->next=head->next->next;
s->next=front->next;
front->next=s;
}
return newhead->next;
}
代码如下
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*
* C语言声明定义全局变量请加上static，防止重复定义
*/
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param pHead ListNode类
* @return ListNode类
*/
typedef struct ListNode Node;
struct ListNode* deleteDuplication(struct ListNode* pHead ) {
// write code here
if(pHead==NULL){
return NULL;
}
Node* prev=NULL;
Node* head=pHead;
Node* head_=pHead->next;
while(head_!=NULL){
if(head->val!=head_->val){
prev=head;
head=head_;
head_=head_->next;
}
else{
if(prev==NULL){
while(head_!=NULL && head_->val==head->val){
head=head_;
head_=head_->next;
}
if(head_!=NULL){
head=head_;
head_=head_->next;
if(head_==NULL){
pHead=head;
return pHead;
}
else{
pHead=head;
}
}else{
return NULL;
}
}
else{
while(head_!=NULL && head_->val==head->val){
head=head_;
head_=head_->next;
}
prev->next=head_;
if(head_==NULL){
return pHead;
}
head=head_;
head_=head_->next;
}
}
}
/*ListNode* newhead=NULL;
while(head){}
while(1){
if(head->val=head->next->val){
head->next=head->next->next;
}
else{
}
}
newhead=head;
head=head->next;
}
*/
return pHead;
}