牛客網演算法學習筆記-連結串列
對於一個連結串列，我們需要用一個特定閾值完成對它的分化，使得小於等於這個值的結點移到前面，大於該值的結點在後面，同時保證兩類結點內部的位置關係不變。
給定一個連結串列的頭結點head，同時給定閾值val，請返回一個連結串列，使小於等於它的結點在前，大於等於它的在後，保證結點值不重複。
測試樣例：{1,4,2,5},3
{1,2,4,5}
單獨建立兩個頭結點，並且建立兩個尾結點，保證有頭指標指向兩個分塊的頭結點，尾結點進行元素的拓展，然後在最後進行拼接，注意返回只得是頭結點的下一個結點
/*
struct ListNode {int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};*/
class Divide {
public:
ListNode* listDivide(ListNode* head, int val) {
// write code here
ListNode* le=new ListNode(0);
ListNode* gr=new ListNode(0);
ListNode *cur_le=le,*cur_gr=gr;
for(;head!=NULL;head=head->next){
if(head->val<=val){
cur_le->next=head;
cur_le=cur_le->next;
}
else{
cur_gr->next=head;
cur_gr=cur_gr->next;
}
}
cur_le->next=gr->next;
cur_gr->next=NULL;
return le->next;
}
};
現有兩個升序連結串列，且連結串列中均無重複元素。請設計一個高效的演算法，列印兩個連結串列的公共值部分。
給定兩個連結串列的頭指標headA和headB，請返回一個vector，元素為兩個連結串列的公共部分。請保證返回陣列的升序。兩個連結串列的元素個數均小於等於500。保證一定有公共值
測試樣例：{1,2,3,4,5,6,7},{2,4,6,8,10}
返回：[2.4.6]
兩個頭指標，小的先後移，一樣的話則同時後移並且儲存結點值，直到一個鏈為NULL；
/*struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};*/
class Common {
public:
vector<int> findCommonParts(ListNode* headA, ListNode* headB) {
// write code here
vector<int> result;
if(headA == NULL ||headB == NULL){
return result;
}
while(headA != NULL&&headB!=NULL){
if(headA->val<headB->val){
headA = headA ->next;
}
else if (headA ->val == headB ->val){
result.push_back(headA->val);
headA = headA ->next;
headB = headB ->next;
}
else{
headB = headB ->next;
}
}
return result;
}
};
5.7
有一個單鏈表，請設計一個演算法，使得每K個節點之間逆序，如果最後不夠K個節點一組，則不調整最後幾個節點。例如連結串列1->2->3->4->5->6->7->8->null，K=3這個例子。調整後為，3->2->1->6->5->4->7->8->null。因為K==3，所以每三個節點之間逆序，但其中的7，8不調整，因為只有兩個節點不夠一組。
給定一個單鏈表的頭指標head,同時給定K值，返回逆序後的連結串列的頭指標
我的程式碼(說執行超時，沒找到原因).
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};*/
class KInverse {
public:
ListNode* inverse(ListNode* head, int k) {
// write code here
if(head == NULL || k ==1 ){
return head;
}
ListNode *resultHead = new ListNode(0) ;
ListNode * tempHead = resultHead;
stack<ListNode*> kStack;
bool first = false;
int count = 0;
while(head!=NULL){
kStack.push(head);
count++;
if(count>=k){
while(count>0){//倒序
ListNode* t = kStack.top();
kStack.pop();
tempHead->next = t;
tempHead = tempHead->next ;
count--;
}
}
head = head ->next;
}
tempHead ->next = NULL;
if(count>0&&count<k){
while(count>0){
ListNode* t = kStack.top();
kStack.pop();
t ->next = tempHead ->next;//頭插法。對不滿K的 保持原續
tempHead->next = t;
count--;
}
}
return resultHead->next ;
}
};
別人家的程式碼：
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};*/
class KInverse {
public:
ListNode* inverse(ListNode* head, int k) {
stack<ListNode *> mystack;
ListNode *Pre=NULL;
ListNode *Behind=head;
while(Behind!=NULL){
int count=0;
while(Behind!=NULL&&count<k){ //入棧，倒序
mystack.push(Behind);
Behind=Behind->next;
count++;
}
if(count<k)
break;
while(!mystack.empty()){
ListNode *temp=mystack.top();
if(Pre==NULL){
Pre=temp;
head=Pre;
}
else{
Pre->next=temp;
Pre=Pre->next;
}
mystack.pop();
}
Pre->next=Behind; //pre拼接剩餘的原連結串列的內容
}
return head;
}
};
現在有一個單鏈表。連結串列中每個節點儲存一個整數，再給定一個值val，把所有等於val的節點刪掉。
給定一個單鏈表的頭結點head，同時給定一個值val，請返回清除後的連結串列的頭結點，保證連結串列中有不等於該值的其它值。請保證其他元素的相對順序。
測試樣例：{1,2,3,4,3,2,1},2
{1,3,4,3,1}
傳遞的NODE是沒有頭結點的，head直接指向第一個結點。所以可以增加頭結點使得所有結點的操作方式相同
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};*/
class ClearValue {
public:
ListNode* clear(ListNode* head, int val) {
// write code here
ListNode* listHead = (ListNode*)malloc(sizeof(ListNode));
listHead->next = head;
ListNode *pre = listHead;
while(head!=NULL){
if(head->val==val){
ListNode *t = head;
head = head ->next;
pre ->next = head;
free(t);
}
else{
head = head->next;
pre = pre ->next;
}
}
return listHead->next;
}
};
請編寫一個函式，檢查連結串列是否為迴文。
給定一個連結串列ListNode* pHead，請返回一個bool，代表連結串列是否為迴文。
測試樣例：{1,2,3,2,1}
返回：true
{1,2,3,2,3}
返回：false將連結串列存入一個棧中，然後從棧頭開始一個一個彈出和原來的連結串列進行比較，如果比較過程中有不想同的則返回false
否則返回true
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};*/
class Palindrome {
public:
bool isPalindrome(ListNode* pHead) {
// write code here
stack<ListNode*> reStack;
ListNode* temp = pHead;
while(temp!=NULL){
reStack.push(temp);
temp = temp->next;
}
while(pHead!=NULL){
ListNode *t = reStack.top();
reStack.pop();
if(t->val != pHead->val){
return false;
}
pHead = pHead ->next;
}
return true;
}
};
5.11
輸入一個複雜連結串列（每個節點中有節點值，以及兩個指標，一個指向下一個節點，另一個特殊指標指向任意一個節點）。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
/*
struct
RandomListNode {
int
label;
struct
RandomListNode *next, *random;
RandomListNode(int
x) :
label(x),
next(NULL), random(NULL) {
}
};
*/
class
Solution {
public:
RandomListNode*
Clone(RandomListNode* pHead)
{
if(pHead==NULL)
return
pHead;
RandomListNode
* tmp=pHead;
while(tmp)
{
RandomListNode*
pNode=new RandomListNode(tmp->label);
pNode->next=tmp->next;
tmp->next=pNode;
tmp=pNode->next;
}
tmp=pHead;
RandomListNode
* newtmp=NULL;
while(tmp)
{
newtmp=tmp->next;
if(tmp->random==NULL)//要區分random是否為NULL，因為random並不是像next一樣
newtmp->random=NULL;
else
newtmp->random=tmp->random->next;
tmp=newtmp->next;
}
RandomListNode*next=NULL;
RandomListNode*curCopy=NULL;
RandomListNode*cur
= pHead;
RandomListNode*
res = pHead->next;
while(cur!=NULL)
{
next
= cur->next->next;
curCopy
= cur->next;
cur->next
= next;
curCopy->next
= next!=NULL ? next->next : NULL;
cur
= next;
}
return
res;
}
};
|