2. 程式人生 > >連結串列面試題C++

連結串列面試題C++

阿新 • • 發佈：2018-11-09

注意頭結點的處理，如果倒敘記得將新的尾節點指向空。

示例一

給定一個整數num，如何在節點值有序的連結串列中插入一個節點值為num的節點，並且保證這個單鏈表依然有序。

#include<iostream>
#include<thread>
using std::endl;
using std::cout;

template<typename T> struct Node{
	T data;
	Node<T> *next;
};

template<typename T> class listStruct {
public:
	listStruct() = default;
	listStruct(Node<T> *h) : head(h) {}
	~listStruct() {
		Node<T> *temNext;
		while (head){
			temNext = head;
			head = head->next;
			delete temNext;
		}
	}
	void buildList(const int *sortArray, const int &length);
	void displayList();
	void addNode(const int &data);
private:
	Node<T> *head;
};
template<typename T> void listStruct<T>::addNode(const int &data) {
	Node<T> *newNode = new Node<T>;
	newNode->data = data;
	newNode->next = NULL;
	if (head == NULL) {
		head = newNode;
	}
	if (head->data > data) {
		newNode->next = head;
		head = newNode;
		return;
	}
	Node<T> *tem = head;
	Node<T> *last = NULL;
	while (tem) {
		if (tem->data > data){
			newNode->next = tem;
			last->next = newNode;
			return;
		}
		last = tem;
		tem = tem->next;
	}
	last->next = newNode;
}
template<typename T> void listStruct<T>::displayList() {
	Node<T> *tem = head;
	cout << "start:" << endl;
	while (tem){
		cout << tem->data << endl;
		tem = tem->next;
	}
	cout << "end!" << endl;
}
template<typename T> void listStruct<T>::buildList(const int *sortArray, const int &length) {
	if (length < 0) {
		return;
	}
	head = new Node<T>;
	head->data = sortArray[0];
	Node<T> *current = head;
	for (int i = 1; i < length; ++i) {
		Node<T> *tem = new Node<T>;
		tem->data = sortArray[i];
		tem->next = NULL;
		current->next = tem;
		current = tem;
	}
}



int main() {
	int sortArray[9] = { 0,1,2,4,5,6,7,8,9 };
	listStruct<int> sortList;
	sortList.buildList(sortArray, 9);
	sortList.addNode(-1);
	sortList.addNode(10);
	sortList.displayList();
	while (1){
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
	}


	return 0;
}

示例二

給定一個連結串列的頭結點head，再給定一個數num，請把連結串列調整成節點值都小於num的節點都放在連結串列的左邊，值等於num的節點都放在連結串列的中間，值大於num的節點，都放在剪標的右邊。
分析：將原連結串列分為三個連結串列，大於num，等於num，小於num。然後再將三個連結串列串起來。

#include<iostream>
#include<thread>
using std::endl;
using std::cout;

template<typename T> struct Node{
	T data;
	Node<T> *next;
};

template<typename T> class listStruct {
public:
	listStruct() = default;
	listStruct(Node<T> *h) : head(h) {}
	~listStruct() {
		Node<T> *temNext;
		while (head){
			temNext = head;
			head = head->next;
			delete temNext;
		}
	}
	void buildList(const int *sortArray, const int &length);
	void displayList();
	void addNode(const int &data);
	void sortList(const int &data);
	void outputNode(Node<T> *node);
private:
	Node<T> *head;
};
template<typename T> void listStruct<T>::outputNode(Node<T> *node) {
	cout << "open" << endl;
	while (node){
		cout << node->data << endl;
		node = node->next;
	}
	cout << "close" << endl;
}
template<typename T> void listStruct<T>::sortList(const int &data) {
	Node<T> *temLess = new Node<T>;
	Node<T> *temGreater = new Node<T>;
	Node<T> *temEqual = new Node<T>;
	Node<T> *lessList = temLess;
	Node<T> *greaterList = temGreater;
	Node<T> *equalList = temEqual;

	Node<T> *tem = head;
	while (tem){
		if (tem->data < data) {
			lessList->next = tem;
			lessList = lessList->next;
			tem = tem->next;
		}
		else if (tem->data == data) {
			equalList->next = tem;
			equalList = equalList->next;
			tem = tem->next;
		}
		else {
			greaterList->next = tem;
			greaterList = greaterList->next;
			tem = tem->next;
		}
	}
	lessList->next = NULL;
	greaterList->next = NULL;
	equalList->next = NULL;

	if (temLess->next) {
		head = temLess->next;
		tem = head;
		while (tem->next){
			tem = tem->next;
		}
	}
	if (temEqual->next) {
		tem->next = temEqual->next;
		while (tem->next){
			tem = tem->next;
		}
	}
	if (temGreater->next) {
		tem->next = temGreater->next;
	}
	delete temLess;
	delete temGreater;
	delete temEqual;
	
}
template<typename T> void listStruct<T>::addNode(const int &data) {
	Node<T> *newNode = new Node<T>;
	newNode->data = data;
	newNode->next = NULL;
	if (head == NULL) {
		head = newNode;
	}
	if (head->data > data) {
		newNode->next = head;
		head = newNode;
		return;
	}
	Node<T> *tem = head;
	Node<T> *last = NULL;
	while (tem) {
		if (tem->data > data){
			newNode->next = tem;
			last->next = newNode;
			return;
		}
		last = tem;
		tem = tem->next;
	}
	last->next = newNode;
}
template<typename T> void listStruct<T>::displayList() {
	Node<T> *tem = head;
	cout << "start:" << endl;
	while (tem){
		cout << tem->data << endl;
		tem = tem->next;
	}
	cout << "end!" << endl;
}
template<typename T> void listStruct<T>::buildList(const int *sortArray, const int &length) {
	if (length < 0) {
		return;
	}
	head = new Node<T>;
	head->data = sortArray[0];
	Node<T> *current = head;
	for (int i = 1; i < length; ++i) {
		Node<T> *tem = new Node<T>;
		tem->data = sortArray[i];
		tem->next = NULL;
		current->next = tem;
		current = tem;
	}
}



int main() {
	int sortArray[9] = { 9,1,2,6,5,7,4,8,0 };
	listStruct<int> sortList;
	sortList.buildList(sortArray, 9);
	sortList.sortList(5);
	sortList.displayList();
	while (1){
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
	}


	return 0;
}

示例三

給定兩個有序連結串列的頭結點，列印公共部分。

template<typename T> void printSameElement(Node<T> *head1, Node<T> *head2) {
	if (!head1 || !head2){
		return;
	}
	cout << "in" << endl;
	while (head1&&head2){
		if (head1->data == head2->data) {
			cout << head1->data << endl;
			head1 = head1->next;
			head2 = head2->next;
		}
		else if (head1->data > head2->data) {
			head2 = head2->next;
		}
		else {
			head1 = head1->next;
		}
	}
}

示例四

給定一個單鏈表的頭結點head，實現一個調整單鏈表的函式，使得每K個節點之間逆序，如果最後不夠k個節點一組，則不調整最後幾個節點。

template<typename T> Node<T> *reverseK(Node<T> *head,const int &k) {
	if (!head) {
		return head;
	}
	int i = 0;
	Node<T> *tem = head;
	Node<T> *start = head;
	Node<T> *end = head;
	bool firstFlag = true;
	while (tem) {
		++i;
		if (i == 1) {
			start = end;
		}
		if (i == k) {
			i = 0;
			end = tem;
			if (firstFlag) {

				Node<T> *temFront = head;
				Node<T> *temEnd;
				head = head->next;
				temFront->next = end->next;
				while (head != end) {
					temEnd = head->next;
					head->next = temFront;
					temFront = head;
					head = temEnd;
				}
				temEnd = head->next;
				head->next = temFront;
				firstFlag = false;
				tem = start;
				end = tem;
			}
			else {
				Node<T> *temFront = start->next;
				Node<T> *temEnd;
				Node<T> *temCurrent = temFront->next;
				tem = temFront;
				if (end->next) {
					temFront->next = end->next;
				}
				else {
					temFront->next = NULL;
				}
				while (temCurrent != end) {
					temEnd = temCurrent->next;
					temCurrent->next = temFront;
					temFront = temCurrent;
					temCurrent = temEnd;
				}
				temCurrent->next = temFront;
				start->next = temCurrent;
				end = tem;
			}
		}
		tem = tem->next;
	}
	return head;
}

示例五

給定一個單鏈表的頭節點head，連結串列中每個節點儲存一個整數，再給定一個值val，把所有等於val的節點刪掉。
分析：重新構建一個連結串列，不等於val就接到新連結串列後，如果等於就拋棄。注意邊界條件。

template<typename T> Node<T> *eliminateValue(Node<T> *head, const T &value) {
	Node<T> *newHead = NULL;
	Node<T> *temNode = new Node<T>;
	temNode->next = NULL;
	newHead = temNode;
	while (head) {
		if (head->data != value) {
			newHead->next = head;
			newHead = newHead->next;
		}
		head = head->next;
	}
	if (temNode->next) {
		newHead = temNode->next;
	}
	else {
		newHead = NULL;
	}
	delete temNode;
	return newHead;
}

示例六

判斷一個連結串列是否為迴文結構。
分析：
方法一：空間複雜度為 O ( N ) O(N) 。採用一個棧儲存前半段的資料，然後跟後半段的資料依次對比。
採用一個慢指標一次走一步與一個快指標一次走兩步的方法可以確定連結串列中點位置。

template<typename T> bool plalindrome(Node<T> *head) {
	std::stack<T> temStack;
	if ((!head) || (!head->next)) {
		return false;
	}
	Node<T> *fast = head;
	Node<T> *slow = head;
	bool middleFlag = false;
	while (slow){
		if (!middleFlag) {
			if (!fast) {
				middleFlag = true;
				continue;
			}
			if (!fast->next) {
				middleFlag = true;
				slow = slow->next;
				continue;
			}
			fast = fast->next;
			fast = fast->next;
			temStack.push(slow->data);
			//cout << "stack push: " << temStack.top() << endl;
			slow = slow->next;
		}
		else {
			//cout << "slow data: " << slow->data << endl;
			if (slow->data != temStack.top()) {
				return false;
			}
			else{
				//cout << "stack pop: " << temStack.top() << endl;
				temStack.pop();
				slow = slow->next;
			}
		}
	}
	return true;
}

方法二：空間複雜度為 O ( 1 ) O(1) 。將後半部分倒敘指向，然後從兩端開始遍歷是非相等。最後要恢復連結串列原序。

template<typename T> bool plalindromeNoSpace(Node<T> *head) {
	std::stack<T> temStack;
	if ((!head) || (!head->next)) {
		return false;
	}
	Node<T> *fast = head;
	Node<T> *slow = head;
	Node<T> *middleNode = head;
	Node<T> *endNode;
	bool middleFlag = false;
	bool evenFlag = false;
	while (slow) {
		if (!middleFlag) {
			if (!fast) { //偶
				middleFlag = true;
				middleNode = slow;
				evenFlag = true;
				break;
			}
			if (!fast->next) {  //奇
				middleFlag = true;
				slow = slow->next;
				middleNode = slow;
				evenFlag = false;
				break;
			}
			fast = fast->next;
			fast = fast->next;
			if (!fast) {
				middleFlag = true;
				middleNode = slow;
				evenFlag = true;
				break;
			}
			if (!fast->next) {
				middleFlag = true;
				slow = slow->next;
				middleNode = slow;
				evenFlag = false;
				break;
			}
			slow = slow->next;
		}
	}

	slow = middleNode;
	Node<T> *newEnd = slow;
	Node<T> *newHead;
	slow = slow->next;
	while (slow->next) {
		newHead = slow->next;
		slow->next = newEnd;
		newEnd = slow;
		slow = newHead;
		newHead = slow->next;
	}
	bool result = true;

	endNode = slow;
	slow->next = newEnd;
	middleNode->next = NULL;
	listStruct<T>::outputNode(head);
	listStruct<T>::outputNode(endNode);
	Node<T> *left = head;
	Node<T> *right = endNode;

	while (right!=middleNode){
		if (right->data != left->data){
			result = false;
		}
		right = right->next;
		left = left->next;
	}


	Node<T> *temCurrent = endNode->next;
	newEnd = endNode;
	while (temCurrent != middleNode) {
		newHead = temCurrent->next;
		temCurrent->next = newEnd;
		newEnd = temCurrent;
		temCurrent = newHead;
	}
	middleNode->next = newEnd;
	endNode->next = NULL;
	listStruct<T>::outputNode(newEnd);
	return result;
}

示例七

如何判斷一個連結串列是否有環，如果有環的話返回進入環的第一個節點，無環的話返回空，如果連結串列的長度為N，請做到時間複雜度為 O ( N ) O(N) ，空間複雜度為 O ( 1 ) O(1) .
分析：使用快慢指標，慢指標一次走一步，快指標一次走兩步。如果相遇則為有環，如果快指標指向NULL則無環。若有環，讓快指標從頭結點開始重新一次一步走，快慢指標再次相遇的位置為環的第一個節點。

示例八

如何判斷兩個無環單鏈表是否相交，如果相交的話返回第一個相交的節點，不相交的話返回空，如果兩個連結串列的長度分別為N與M，請做到時間複雜度為 O ( N + M ) O(N+M) ，額外空間複雜度為 O ( 1 ) O(1) 。
分析：遍歷一遍兩個連結串列，如果N>M，則第一個連結串列從N-M處，第二個連結串列從頭節點開始遍歷，對比兩個節點是否相同。
這裡寫圖片描述

示例九

如何判斷兩個有環單鏈表是否相交，如果相交的話返回第一個相交的節點，不相交的話返回空，如果兩個連結串列的長度分別為N與M，請做到時間複雜度為 O ( N + M ) O(N+M) ，額外空間複雜度為 O ( 1 ) O(1) 。
分析：首先找到兩個連結串列的入環節點，如果入環節點相同，則按照無環連結串列找第一個相交節點的方法找到第一個相交點。如果入環節點不同可分為如下兩種型別。
這裡寫圖片描述
遍歷第一個環，若找不到第二個環的入環節點，則為情況一，若找到第二個環的入環節點則為情況二，情況二隨便返回任意一個入環節點均可。

相關推薦

連結串列面試題C++

注意頭結點的處理，如果倒敘記得將新的尾節點指向空。 示例一 給定一個整數num，如何在節點值有序的連結串列中插入一個節點值為num的節點，並且保證這個單鏈表依然有序。 #include<iostream> #include<thread> using

連結串列面試題總結 C/C++

資料結構和演算法，是我們程式設計最重要的兩大元素，可以說，我們的程式設計，都是在選擇和設計合適的資料結構來存放資料，然後再用合適的演算法來處理這些資料。       在面試中，最經常被提及的就是連結串列，因為它簡單，但又因為需要對指標進行操作，凡是涉及到指標的，都需要我

連結串列面試題集合

  連結串列面試題： 1. 比較順序表和連結串列的優缺點,說說它們分別在什麼場景下使用? 順序表一般用於查詢，可隨機訪問； 連結串列一般用於增刪改，不可隨機訪問； 如果資料元素不多，兩種方式沒有太大的差別 如果資料元素不定，建議使用連結串列 順序表

單鏈表的基本操作及連結串列面試題

單鏈表的基本操作及連結串列面試題 程式程式碼如下： LinkList.h #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include <stdio.h> #include <stdlib.

連結串列面試題----約瑟夫環相關

約瑟夫環相關連結串列面試題 繼上篇部落格之------------ 什麼是約瑟夫環 約瑟夫環 判斷是否成環 求環的長度 環的入口點

一文搞定連結串列面試題系列之二 —— Leetcode234. Palindrome Linked List迴文連結串列\

連結串列薈萃二： 迴文連結串列 列表解法 迴文連結串列 題目：迴文連結串列給定一個連結串列，判斷該連結串列是否是迴文連結串列，要求O(n)時間複雜度，O(1)空間複雜度。 Given a singly linked

連結串列面試題

關於連結串列已經學了有一段時間了，今天抽空進行了整理，列出來常見的有關連結串列的面試題，以下想法如有瑕疵望批評指出，希望能給初學者帶來一點參考和價值 從尾到頭列印單鏈表 遞迴列印 // 1、從尾到頭列印單鏈表 遞迴 void ListReversePrint(ListN

【連結串列面試題】【進階】

1、查詢倒數第 k 個連結串列 題目描述：給定一個單向連結串列 List ，要你設計演算法找出倒數第 K 個結點並列印 struct ListNode { DataType m_Value; ListNode* m_pNext; }; ListNode* FindKt

【資料結構】連結串列面試題升級版

1、複雜連結串列的複製 複雜連結串列 一個連結串列的每個結點，有一個next指標指向下一個結點，還有一個random指標指向這個連結串列中的隨機一個結點或者NULL。 現在要求複製這個連結串列，並返回複製後的新連結串列。 思路如下： 複雜連結串列的資料型別： typedef str

【資料結構】連結串列面試題

1、倒序列印連結串列 （1）非遞迴方式 程式碼如下： void ReversePrint(ListNode **pFirst) { ListNode *last = NULL; ListNode *cur = NULL; assert(*pFirst != NULL); w

連結串列面試題程式碼總結（java）

這是原文連結：http://www.jianshu.com/p/a64d1ef95980 最近總結了一下資料結構和演算法的題目，這是第二篇文章，關於連結串列的，第一篇文章關於二叉樹的參見 廢話少說，上鍊表的資料結構 class ListNode { ListNode ne

連結串列面試題：返回倒數第k個節點

題目來源：劍指offer 方法一： 首先我們先得出連結串列一共有多少個節點標記為count個，然後正數第count-k+1個就是倒數第k個節點，迴圈得到就可以。 程式碼： class Solution { public: ListNode*

【連結串列面試題】合併兩個有序連結串列, 合併後依然有序

程式碼 // 合併兩個有序連結串列 SListNode * MergeOrderedList(SListNode *p1First, SListNode *p2First) { SListNode*

連結串列面試題之合併兩個有序連結串列

關於合併兩個有序的連結串列，假定該連結串列為升序排列，排列後的新表依舊升序。以下提供兩種方法進行排列。 建立新節點為空，依次後續插入法 Node* MergeTwoList1(N

連結串列面試題小結（待完成）

以下程式碼使用的公共結構： 連結串列節點： struct ListNode { int data; ListNode *next; }; 輔助函式： //make a list ListNode *makeList(int *arr, int n) { if(a

連結串列面試題 ---- 複雜連結串列的複製

一個連結串列的每個結點，有一個next指標指向下一個結點，還有一個random指標指向這個連結串列中的一個隨機結點或者NULL，題目要求實現複製這個連結串列，返回複製後的新連結串列 如圖所示： 1.先將單鏈表複製，如下圖 2.找複雜指標，對新節點複

java連結串列面試題

本文包含連結串列的以下內容：　　1、單鏈表的建立和遍歷　　2、求單鏈表中節點的個數　　3、查詢單鏈表中的倒數第k個結點（劍指offer，題15）　　4、查詢單鏈表中的中間結點　　5、合併兩個有序的單鏈表，合併之後的連結串列依然有序【出現頻率高】（劍指offer，題17）　　6

關於連結串列面試題的一些理解

    面試題一.刪除無頭單鏈表的非尾結點     Del_Nottail(pLinkNode pos);        顧名思義刪除非尾結點就是刪除的結點不是最後一個結點，之前在實現連結串列功能的時

連結串列面試題之快慢指標問題（一） 查詢連結串列中間節點

查詢連結串列中間節點 一.問題描述         給點一個連結串列，返回該連結串列的中間節點。 二.問題分析         假定一個連結串列中節點資料依次為(單數):1->2->3-&

阿裏、網易和騰訊面試題 C/C++

不同的 三次握手 進程組 HR 是什麽 ret 區分 point 兩個 一、線程、鎖 1、Posix Thread互斥鎖 線程鎖創建 a.靜態創建 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; b.動態創建 pt