删除链表倒数K节点与合并

---

自建链表实现删除链表倒数K节点

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <string>
#include <sstream>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode() :val(0), next(nullptr) {}
    ListNode(int _val) :val(_val), next(nullptr) {}
};

class Solution {
public:
    Solution(){
        vhead = new ListNode(0);
    }
    ListNode* mySol(int k) {
        ListNode* slow = vhead;
        ListNode* fast = vhead;
        while (k--) {
            fast = fast->next;
        }
        while (fast->next) {
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        return vhead->next;
    }
    void printList() {
        ListNode* v = vhead;
        v = v->next;
        while (v) {
            cout << v->val << " ";
            v = v->next;
        }
        cout << endl;
    }
    void insertList(int num) {
        ListNode* p = vhead;
        while (p->next) {
            p = p->next;
        }
        p->next = new ListNode(num);
    }
private:
    ListNode* vhead;
};

int main() {
    Solution s;
    s.insertList(1);
    s.insertList(2);
    s.insertList(3);
    s.insertList(4);
    s.printList();
    s.mySol(2);
    s.printList();
    return 0;
}

---

合并k个有序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        int n = lists.size();
        if (n == 0)
            return NULL;
        return merge_sort(lists, 0, n - 1);
    }

    ListNode * merge_sort(vector<ListNode*> & lists, int l, int r)
    {
        if (l == r)
            return lists[l];
        int mid = (l + r) / 2;
        ListNode * L = merge_sort(lists, l, mid);
        ListNode * R = merge_sort(lists, mid + 1, r);
        return merge(L, R);
    }

    ListNode * merge(ListNode * a, ListNode * b)
    {
        ListNode * dummy = new ListNode(-1);
        ListNode * x = dummy;
        while (a && b)
        {
            if (a->val < b->val)
            {
                x->next = a;
                a = a->next;
            }
            else
            {
                x->next = b;
                b = b->next;
            }
            x = x->next;
        }
        if (a)
            x->next = a;
        if (b)
            x->next = b;
        return dummy->next;
    }
};

---

合并K个有序数组

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;

vector<int> mergeTowArrays(vector<int>& A, vector<int>& B)
{
    int asize = A.size();
    int bsize = B.size();
    vector<int> temp;
    temp.resize(asize + bsize);
    int index = 0, j = 0, i = 0;
    while (i < asize && j < bsize)
    {
        if (A[i] < B[j])
            temp[index++] = A[i++];
        else
            temp[index++] = B[j++];
    }
    while (i < asize)
        temp[index++] = A[i++];
    while (j < bsize)
        temp[index++] = B[j++];
    return temp;
}
vector<int> kMergeSort(vector<vector<int>>& A, int start, int end)
{
    if (start >= end)
        return A[start];
    int mid = start + (end - start) / 2;
    vector<int> Left = kMergeSort(A, start, mid);
    vector<int> Right = kMergeSort(A, mid + 1 , end);
    return mergeTowArrays(Left, Right);
}
vector<int> mergeSortArrays(vector<vector<int>>& A)
{
    vector<int> temp;
    if (A.empty() || A.size() == 0 || A[0].size() == 0)
        return temp;
    temp = kMergeSort(A, 0, A.size() - 1);
    return temp;
}


int main() {
    vector<vector<int>> nums = { {2,4,6},{1,7,8},{3,9,10} };
    vector<int> res = mergeSortArrays(nums);
    for (auto n : res) {
        cout << n << " ";
    }
    return 0;
}

---

手撕链表

#pragma once
#include<iostream>
#include<vector>
#include<string>
#include<list>
using namespace std;

template<typename T>
struct LinkNode {
	T val;
	LinkNode<T>* next;
	LinkNode(T _val) :val(_val), next(nullptr) {}
};

template<typename T>
class LinkList {
public:
	LinkList():l_size(0) {
		this->vhead = new LinkNode<T>(0);
	}
	~LinkList();
	LinkList(const LinkList<T>& list);
	LinkList<T>& operator=(const LinkList<T>& list);
	void push_back(T val);
	void push_front(T val);
	void insert(T val, int index);
	void pop_back();
	void pop_front();
	void remove(int index);
	void print();
	int size();
private:
	LinkNode<T>* vhead;
	int l_size;
};

template<typename T>
LinkList<T>::LinkList(const LinkList<T>& list) {
	LinkNode<T>* list_v = list.vhead->next;
	this->vhead = new LinkNode<T>(0);
	while (list_v) {
		this->push_back(list_v->val);
		list_v = list_v->next;
	}
}
template<typename T>
LinkList<T>& LinkList<T>::operator=(const LinkList<T>& list) {
	LinkNode<T>* list_v = list.vhead->next;
	LinkNode<T>* v = this->vhead->next;
	while (v) {
		LinkNode* d = v;
		delete d;
		v = v->next;
	}
	while (list_v) {
		this->push_back(list_v->val);
		list_v = list_v->next;
	}
}

template<typename T>
void LinkList<T>::push_back(T val) {
	LinkNode<T>* v = vhead;
	while (v->next) {
		v = v->next;
	}
	v->next = new LinkNode<T>(val);
	this->l_size++;
}

template<typename T>
void LinkList<T>::push_front(T val) {
	LinkNode<T>* inode = new LinkNode<T>(val);
	LinkNode<T>* temp = vhead->next;
	vhead->next = inode;
	inode->next = temp;
	this->l_size++;
}

template<typename T>
void LinkList<T>::insert(T val, int index) {
	LinkNode<T>* inode = new LinkNode<T>(val);
	LinkNode<T>* v = vhead;
	if (index > this->l_size - 1) return;
	while (index--) {
		v = v->next;
	}
	LinkNode<T>* temp = v->next;
	v->next = inode;
	inode->next = temp;
	this->l_size++;
}

template<typename T>
void LinkList<T>::print() {
	LinkNode<T>* v = vhead->next;
	while (v) {
		cout << v->val << " ";
		v = v->next;
	}
	cout << endl;
}

template<typename T>
LinkList<T>::~LinkList() {
	LinkNode<T>* v = vhead;
	while (v) {
		LinkNode<T>* d = v;
		v = v->next;
		delete d;
	}
}

template<typename T>
int LinkList<T>::size() {
	return this->l_size;
}
template<typename T>
void LinkList<T>::pop_back() {
	LinkNode<T>* v = vhead;
	int nsize = this->l_size - 1;
	while (nsize--) {
		v = v->next;
	}
	LinkNode<T>* dnode = v->next;
	v->next = v->next->next;
	delete dnode;
	this->l_size--;
}
template<typename T>
void LinkList<T>::pop_front() {
	LinkNode<T>* v = vhead;
	LinkNode<T>* dnode = v->next;
	v->next = v->next->next;
	delete dnode;
	this->l_size--;
}
template<typename T>
void LinkList<T>::remove(int index) {
	LinkNode<T>* v = vhead;
	while (index--) {
		v = v->next;
	}
	LinkNode<T>* dnode = v->next;
	v->next = v->next->next;
	delete dnode;
	this->l_size--;
}

#include"hash1.h"

int main() {
	LinkList<int> h;
	h.push_back(3);
	h.push_back(7);
	h.push_back(8);
	h.push_front(1);
	h.push_front(4);
	h.push_front(9);
	h.insert(10, 0);
	h.insert(15, 5);
	h.print();
	h.pop_front();
	h.pop_back();
	h.remove(3);
	h.print();
	LinkList<int> h1(h);
	h1.print();
	LinkList<int> h2 = h;
	h2.print();
	return 0;
}