数据结构 03-链表Linked List

带头结点单链表逆置

方法一：头插法

void Reverse(ListNode* root) {
	ListNode* p = root->next;
	root->next = NULL;
	while (p != NULL) {
		ListNode* temp = p->next;
		p->next = root->next;
		root->next = p;
		p = temp;
	}
}

方法二：双指针法（迭代法）

void Reverse(ListNode* root) {
	ListNode* p1 = root->next, * p2 = NULL;
	while (p1 != NULL) {
		ListNode* temp = p1->next;
		p1->next = p2;
		p2 = p1;
		p1 = temp;
	}
	root->next = p2;
}

方法三：递归法

ListNode* Reverse(ListNode* root) {
	if (root->next == NULL) {
		return root;
	}
	ListNode* ans = Reverse(root->next);
	root->next->next = root;
	root->next = NULL;
	return ans;
}

合并K个有序链表

问题描述

现有K个升序整型链表，要求将这K个链表合并为一个升序链表。

解题思路及代码

设置一条主链表，将该主链表与链表数组中的每一个元素进行双有序链表合并。

ListNode* merge2Lists(ListNode* a, ListNode* b) {
    if (a == nullptr) {
        return b;
    }
    ListNode* root = nullptr, * p = nullptr;
    while (a != nullptr && b != nullptr) {
        if (a->val <= b->val) {
            if (root == nullptr) {
                root = a;
                p = root;
            }
            else {
                p->next = a;
                p = p->next;
            }
            a = a->next;
        }
        else if (a->val > b->val) {
            if (root == nullptr) {
                root = b;
                p = root;
            }
            else {
                p->next = b;
                p = p->next;
            }
            b = b->next;
        }
    }
    if (a != nullptr) {
        p->next = a;
    }
    else if (b != nullptr) {
        p->next = b;
    }
    return root;
}

ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode* ans = nullptr;
    for (int i = 0; i < (int)lists.size(); i++) {
        ans = merge2Lists(ans, lists[i]);
    }
    return ans;
}

约瑟夫问题

解法一：标记数组

vector<int>* Josephus(int n, int m) {
	vector<int>* ans = new vector<int>;
	int loc = -1, count = 0;
	vector<int> v(n, 0);
	while (count < n - 1) {
		for (int i = 0; i < m; i++) {
			loc = (loc + 1) % n;
			while (v[loc]) {
				loc = (loc + 1) % n;
			}
		}
		ans->push_back(loc);
		v[loc] = 1;
		count++;
	}
}

解法二：循环链表

vector<int>* Josephus(ListNode* root, int x) {
	vector<int>* ans = new vector<int>;
	ListNode* p = root, * pre = root;
	do {
		for (int i = 0; i < x - 1; i++) {
			pre = p;
			p = p->next;
		}
		ans->push_back(p->val);
		pre->next = p->next;
		delete p;
		p = pre->next;
	} while (p != pre);
	ans->push_back(p->val);
	delete p;
	return ans;
}