數據結構和算法（四）鏈表相關面試題
數據結構和算法（2）單向循環鏈表的建立插入刪除實現github
數據結構和算法（5）棧和隊列的操做和實現shell
數據結構和算法（6）隊列的操做和實現swift
@TOC數據結構
1. 數據結構和算法（四）鏈表相關面試題
- 本篇博客Demo下載： 點擊這裏下載Demo
1.1 鏈表算法題詳解
1.1.1 合併兩個有序鏈表
- 題目1： 將2個遞增的有序鏈表合併爲一個有序鏈表；要求結果鏈表仍然使用兩個鏈表的存儲空間，不另外佔用其餘的存儲空間。表中不容許有重複的數據。
例如：La{1,2,3}, Lb{3,6,9} 合併成 Lc {1,2,3,6,9}數據結構和算法
下面咱們來分析解決問題：post
- 先分析題目的
關鍵字，找出細節點： 關鍵詞:
- 遞增有序鏈表,不容許有重複數據,保留遞增關係(後插法)
- 不佔用額外的存儲空間指的是不能開闢新節點,賦值在連接到鏈表上;
- 分析問題，列出解題思路：
算法思想:
- (1)假設待合併的鏈表爲La和Lb,合併後的新表使用頭指針Lc(Lc的表頭結點設爲La的表頭結點)指向. Pa 和 Pb 分別是La,Lb的工做指針.初始化爲相應鏈表的首元結點
- (2)從首元結點開始比較, 當兩個鏈表La 和Lb 均未到達表尾結點時,依次摘取其中較小值從新鏈表在Lc表的最後.
- (3)若是兩個表中的元素相等,只摘取La表中的元素,刪除Lb表中的元素,這樣確保合併後表中無重複的元素;
- (4)當一個表達到表尾結點爲空時,非空表的剩餘元素直接連接在Lc表最後.
- (5)最後釋放鏈表Lb的頭結點;
- 問題求解，代碼實現：
//目標:將2個遞增的有序鏈表La,Lb 合併爲一個遞增的有序鏈表Lc
void mergeList(LinkList *La, LinkList *Lb, LinkList *Lc) {
LinkList pa, pb, pc, temp;
//pa 是鏈表La的工做指針,pb 是鏈表Lb的工做指針, 初始化爲首元結點;
pa = (*La)->next;
pb = (*Lb)->next;
*Lc = pc = *La;
while (pa && pb) {
if (pa->data < pb->data) {
//取較小者La中的元素,將pa連接在pc的後面,pa指針後移
pc->next = pa;
pc = pa;
pa = pa->next;
} else if (pa->data > pb->data) {
//取較小者Lb的元素,將pb連接在pc後面, pb指針後移
pc->next = pb;
pc = pb;
pb = pb->next;
} else {
//相等時取La中的元素,刪除Lb的元素;
pc->next = pa;
pc = pa;
pa = pa->next;
temp = pb->next;
free(pb);
pb = temp;
}
}
//將非空表的剩餘元素之間連接在Lc表的最後
pc->next = pa ? pa : pb;
//釋放Lb的頭結點
free(*Lb);
}
複製代碼
- 時間複雜度：
時間複雜度：O(n) 空間複雜度：O(1)
- 測試驗證：
void test1() {
printf("測試mergeList：\n");
KStatus iStatus;
LinkList La,Lb,Lc;
initList(&La);
initList(&Lb);
printf("******題目1:********\n");
//設計2個遞增鏈表La,Lb
for(int j = 10;j>=0;j-=2)
{
iStatus = insertElement(&La, 1, j);
}
printf("La:\n");
traverseList(La);
for(int j = 11;j>0;j-=2)
{
iStatus = insertElement(&Lb, 1, j);
}
printf("Lb:\n");
traverseList(Lb);
mergeList(&La, &Lb, &Lc);
printf("Lc:\n");
traverseList(Lc);
}
複製代碼
- 輸出結果：
測試mergeList：
******題目1:********
La:
0 2 4 6 8 10
Lb:
1 3 5 7 9 11
Lc:
0 1 2 3 4 5 6 7 8 9 10 11
複製代碼
1.1.2 求兩個有序鏈表的交集
- 題目2： 已知兩個鏈表A和B分別表示兩個集合，其元素地址排列。設計一個算法，用於求出A和B的交集，並存儲在A鏈表中。
例如：La{2,4,6,8}, Lb{4,6,8} 交集爲 Lc {4,6,8}
下面咱們來分析解決問題：
- 先分析題目的
關鍵字，找出細節點： 關鍵詞:
- 依次摘取2個表中相等的元素從新進行連接,刪除其餘不等的元素;
- 分析問題，列出解題思路：
算法思想:
- (1)假設待合併的鏈表爲La和Lb,合併後的新表使用頭指針Lc(Lc的表頭結點設爲La的表頭結點)指向. Pa 和 Pb 分別是La,Lb的工做指針.初始化爲相應鏈表的首元結點
- (2)從首元結點開始比較, 當兩個鏈表La 和Lb 均未到達表尾結點時.
- (3)若是兩個表中的元素相等,只摘取La表中的元素,刪除Lb表中的元素;
- (4)若是其中一個表中的元素較小,刪除此表中較小的元素. 此表的工做指針後移;
- (5)當鏈表La和Lb有一個先到達表尾結點爲空時,依次刪除另外一個非空表中的全部元素,最後釋放鏈表lb;
- 問題求解，代碼實現：
//目標: 求2個遞增的有序鏈表La,Lb的交集, 使用頭指針Lc指向帶回;
void intersection(LinkList *La, LinkList *Lb, LinkList *Lc) {
LinkList pa, pb , pc, temp;
//pa 是鏈表La的工做指針,pb 是鏈表Lb的工做指針, 初始化爲首元結點;La的頭結點做爲Lc的頭結點;
pa = (*La)->next;
pb = (*Lb)->next;
*Lc = pc = *La;
while (pa && pb) {
if (pa->data == pb->data) {
//相等,交集併入結果鏈表中;
//(1).取La中的元素,將pa連接到pc的後面,pa指針後移;
pc->next = pa;
pc = pa;
pa = pa->next;
//(2)刪除Lb中對應相等的元素
temp = pb;
pb = pb->next;
free(temp);
} else if (pa->data < pb->data){
//刪除較小值La的元素;
temp = pa;
pa = pa->next;
free(temp);
} else {
//刪除較小值Lb的元素;
temp = pb;
pb = pb->next;
free(temp);
}
}
//Lb爲空,刪除非空表La中的全部元素
while (pa) {
temp = pa;
pa = pa->next;
free(temp);
}
//La爲空,刪除非空表Lb中的全部元素
while (pb) {
temp = pb;
pb = pb->next;
free(temp);
}
//Lc尾結點置爲空
pc->next = NULL;
//釋放Lb的頭結點
free(*Lb);
}
複製代碼
- 時間複雜度：
時間複雜度：O(n) 空間複雜度：O(1)
- 測試驗證：
void test2() {
printf("測試intersection：\n");
LinkList La,Lb,Lc;
initList(&La);
initList(&Lb);
printf("******題目2:********\n");
insertElement(&La, 1, 8);
insertElement(&La, 1, 6);
insertElement(&La, 1, 4);
insertElement(&La, 1, 2);
printf("La:\n");
traverseList(La);
insertElement(&Lb, 1, 10);
insertElement(&Lb, 1, 8);
insertElement(&Lb, 1, 6);
insertElement(&Lb, 1, 4);
printf("Lb:\n");
traverseList(Lb);
intersection(&La, &Lb, &Lc);
printf("Lc:\n");
traverseList(Lc);
}
複製代碼
- 輸出結果：
測試intersection：
******題目2:********
La:
2 4 6 8
Lb:
4 6 8 10
Lc:
4 6 8
複製代碼
1.1.3 逆轉一個有序鏈表
- 題目3： 設計一個算法，將鏈表中全部節點的連接方向原地旋轉，即要求僅僅利用原表的存儲空間，換句話說，要求算法空間複雜度爲O(1)。
例如：La{0,2,4,6,8,10} , 逆轉後： Lc {10,8,6,4,2,0};
下面咱們來分析解決問題：
- 先分析題目的
關鍵字，找出細節點： 關鍵詞:
- 不能開闢新的空間,只能改變指針的指向;
- 能夠考慮逐個摘取結點,利用前插法建立鏈表的思想,將結點一次插入到頭結點的後面;
- 由於先插入的結點爲表尾,後插入的結點爲表頭,便可實現鏈表的逆轉;
- 分析問題，列出解題思路：
算法思想:
- (1)利用原有的頭結點*L,p爲工做指針, 初始時p指向首元結點. 由於摘取的結點依次向前插入,爲確保鏈表尾部爲空,初始時將頭結點的指針域置空;
- (2)從前向後遍歷鏈表,依次摘取結點,在摘取結點前須要用指針q記錄後繼結點,以防止連接後丟失後繼結點;
- (3)將摘取的結點插入到頭結點以後,最後p指向新的待處理節點q(p=q);
- 問題求解，代碼實現：
//目的: 逆轉帶頭結點單鏈表L;
void inverse(LinkList *L) {
LinkList p,q;
//p指向首元結點;
p = (*L)->next;
//頭結點的指針域置空
(*L)->next = NULL;
while (p) {
//q指向p的後繼,用來保存下一個下一個要插入的節點，否則鏈表會斷裂，找不到後續元素
q = p->next;
//*p 插入到頭結點以後;
p->next = (*L)->next;
(*L)->next = p;
//處理下一個結點
p = q;
}
}
複製代碼
- 時間複雜度：
時間複雜度：O(n) 空間複雜度：O(1)
- 測試驗證：
void test3() {
printf("測試intersection：\n");
KStatus iStatus;
LinkList La,Lb,L;
initList(&La);
initList(&Lb);
printf("******題目3:********\n");
initList(&L);
for(int j = 10;j>=0;j-=2)
{
iStatus = insertElement(&L, 1, j);
}
printf("L逆轉前:\n");
traverseList(L);
inverse(&L);
printf("L逆轉後:\n");
traverseList(L);
}
複製代碼
- 輸出結果：
測試intersection：
******題目3:********
L逆轉前:
0 2 4 6 8 10
L逆轉後:
10 8 6 4 2 0
複製代碼
1.1.4 刪除特定條件元素
- 題目4： 設計一個算法，刪除遞增有序鏈表中值大於等於minK且小於等於maxK（minK,maxK是給定的兩個參數，其值能夠和表中的元素相同，也能夠不一樣）的全部元素。
下面咱們來分析解決問題：
- 先分析題目的
關鍵字，找出細節點： 關鍵詞:
- 經過遍歷鏈表可以定位帶刪除元素的下邊界和上邊界, 便可找到第一個值大於mink的結點和第一個值大於等於maxk的結點;
- 分析問題，列出解題思路：
算法思想:
- (1)查找第一個值大於mink的結點,用q指向該結點,pre 指向該結點的前驅結點;
- (2)繼續向下遍歷鏈表, 查找第一個值大於等於maxk的結點,用p指向該結點;
- (3)修改下邊界前驅結點的指針域, 是其指向上邊界(pre->next = p);
- (4)依次釋放待刪除結點的空間(介於pre和p之間的全部結點);
- 問題求解，代碼實現：
//目標: 刪除遞增有序鏈表L中值大於等於mink 和小於等於maxk的全部元素
void deleteMinMax(LinkList *L, int mink, int maxk) {
LinkList p, q, pre,temp;
pre = *L;
//p指向首元結點
p = (*L)->next;
//1.查找第一值大於mink的結點
while (p && p->data < mink) {
//pre指向前驅結點
pre = p;
p = p->next;
}
//2.查找第一個值大於等於maxk的結點
while (p && p->data < maxk) {
p = p->next;
}
//3.修改待刪除的結點指針
q = pre->next;
pre->next = p;
//釋放q 到 p之間的全部結點
while (q != p) {
temp = q->next;
free(q);
q = temp;
}
}
複製代碼
- 時間複雜度：
時間複雜度：O(n) 空間複雜度：O(1)
- 測試驗證：
void test4() {
printf("測試deleteMinMax：\n");
KStatus iStatus;
LinkList La,Lb,L;
initList(&La);
initList(&Lb);
printf("******題目4:********\n");
initList(&L);
for(int j = 10;j>=0;j-=2)
{
iStatus = insertElement(&L, 1, j);
}
printf("L鏈表:\n");
traverseList(L);
deleteMinMax(&L, 4, 10);
printf("刪除鏈表mink與maxk之間結點的鏈表:\n");
traverseList(L);
}
複製代碼
- 輸出結果：
測試deleteMinMax：
******題目4:********
L鏈表:
0 2 4 6 8 10
刪除鏈表mink與maxk之間結點的鏈表:
0 2 10
複製代碼
1.1.5 循環左移
- 題目5： 設將n(n>1)個整數存放到一維數組R中，試設計一個在時間和空間兩個方面都儘量高效的算法；將R中保存的序列循環左移p個位置（0<p<n）個位置，即將R中的數據由(x0,x1,......,xn-1)轉變爲(xp,xp+1,...,xn-1,x0,x1,...,xp-1)。
例如: pre[10] = {0,1,2,3,4,5,6,7,8,9}, n = 10,p = 3; pre[10] = {3,4,5,6,7,8,9,0,1,2}
下面咱們來分析解決問題：
-
先分析題目的
關鍵字，找出細節點： -
分析問題，列出解題思路：
算法思路:
- 先將n個數據原地逆置 9,8,7,6,5,4,3,2,1,0;
- 將n個數據拆解成[9,8,7,6,5,4,3] [2,1,0]
- 將前n-p個數據和後p個數據分別原地逆置; [3,4,5,6,7,8,9] [0,1,2]
- 問題求解，代碼實現：
//將數組R中的數據原地逆置
void reverseList(int *pre, int left, int right) {
//i等於左邊界left,j等於右邊界right;
int i = left, j = right;
int temp;
//交換pre[i] 和 pre[j] 的值
while (i < j) {
//交互值
temp = pre[i];
pre[i] = pre[j];
pre[j] = temp;
//i右移,j左移
i++;
j--;
}
}
void leftShift(int *pre, int n, int p) {
//將長度爲n的數組pre 中的數據循環左移p個位置
if (p > 0 && p < n) {
//1. 將數組中全部的元素所有逆置
reverseList(pre, 0, n-1);
//2. 將前n-p個數據逆置
reverseList(pre, 0, n-p-1);
//3. 將後p個數據逆置
reverseList(pre, n-p, n-1);
}
}
複製代碼
- 時間複雜度：
複雜度分析: 時間複雜度: O(n); 時間複雜度:O(1);
- 測試驗證：
void test5() {
printf("測試deleteMinMax：\n");
LinkList La,Lb;
initList(&La);
initList(&Lb);
printf("******題目5:********\n");
int pre[10] = {0,1,2,3,4,5,6,7,8,9};
leftShift(pre, 10, 3);
for (int i=0; i < 10; i++) {
printf("%d ",pre[i]);
}
printf("\n");
}
複製代碼
- 輸出結果：
測試deleteMinMax：
******題目5:********
3 4 5 6 7 8 9 0 1 2
複製代碼
1.1.6 找出主元素
- 題目6： 已知一個整數序列A= （a0,a1,a2,...,an-1）,其中(0<=ai <= n), (0<= i <= n). 若存在ap1=ap2=...= apm = x, 且m>n/2(0<=pk<n,1<=k<=m),則稱x爲A的主元素。例如，A=0,5,,5,3,5,7,5,5), 則5是主元素；若B = （0，5，5，3，5，1，5，7），則A中沒有主元素，假設A中的n個元素保存的一個一維數組中，請設計一個儘量高效的算法，找出數組元素中的主元素，若存在主元素則輸出該元素，不然輸出-1。
下面咱們來分析解決問題：
- 先分析題目的
關鍵字，找出細節點：
- 主元素,是數組中的出現次數超過一半的元素;
- 當數組中存在主元素時,全部非主元素的個數和必少於一半.
- 若是讓主元素和一個非主元素配對, 則最後多出來的元素(沒有元素與之匹配就是主元素.
- 分析問題，列出解題思路：
算法思路:
- 選取候選主元素, 從前向後依次掃描數組中的每一個整數, 假定第一個整數爲主元素,將其保存在Key中,計數爲1. 若遇到下一個整數仍然等於key,則計數加1. 不然計數減1. 當計數減到0時, 將遇到的下一個整數保存到key中, 計數從新記爲1. 開始新一輪計數. 便可從當前位置開始重上述過程,直到將所有數組元素掃描一遍;
- 判斷key中的元素是不是真正的主元素, 再次掃描數組, 統計key中元素出現的次數,若大於n/2,則爲主元素,不然,序列中不存在主元素;
- 問題求解，代碼實現：
//目標: 求整數序列A中的主元素;
int findMainElement(int *A, int n) {
//count 用來計數
int count = 1;
//key 用來保存候選主元素, 初始A[0]
int key = A[0];
//(1) 掃描數組,選取候選主元素
for (int i = 1; i < n; i++) {
//(2) 若是A[i]元素值 == key ,則候選主元素計數加1;
if (A[i] == key) {
count++;
} else {
//(3) 當前元素A[i] 非候選主元素,計數減1;
if (count > 0) {
count--;
}else {
//(4) 若是count 等於0,則更換候選主元素,從新計數
key = A[i];
count = 1;
}
}
}
//若是count > 0,說明有候選元素，則統計候選元素元素出現的次數，不然說明沒有候選元素。
if (count > 0) {
//(5) 統計候選元素的實際出現次數
for (int i = count = 0; i < n; i++) {
if(A[i] == key) count++;
}
}
//(6) 判斷候選元素 是否知足主元素的條件，即出現次數大於數組長度的一半
if (count > n/2) return key;
//(7) 沒有找到主元素，返回-1
return -1;
}
複製代碼
- 時間複雜度：
算法分析: 時間複雜度: O(n) 空間複雜度: O(1)
- 測試驗證：
void test6() {
printf("測試findMainElement：\n");
printf("******題目6:********\n");
int A[] = {0,5,5,3,5,7,5,5};
int B[] = {0,5,5,3,5,1,5,7};
int C[] = {0,1,2,3,4,5,6,7};
int value = findMainElement(A, 8);
printf("數組A 主元素爲: %d\n",value);
value = findMainElement(B, 8);
printf("數組B 主元素爲(-1表示數組沒有主元素): %d\n",value);
value = findMainElement(C, 8);
printf("數組C 主元素爲(-1表示數組沒有主元素): %d\n",value);
}
複製代碼
- 輸出結果：
測試findMainElement：
******題目6:********
數組A 主元素爲: 5
數組B 主元素爲(-1表示數組沒有主元素): -1
數組C 主元素爲(-1表示數組沒有主元素): -1
複製代碼
1.1.7 保留第一次出現的結點
- 題目7： 用單鏈表保存m個整數，結點的結構爲(data,link)，且|data|<=n(n爲正整數)。如今要去設計一個時間複雜度儘量高效的算法。對於鏈表中的data絕對值相對的結點，僅保留第一個出現的結點，而刪除其他絕對值相等的結點。例如，鏈表A= {21,-15,15, -7,15}, 刪除後的鏈表A= {21,-15,-7};。
下面咱們來分析解決問題：
- 先分析題目的
關鍵字，找出細節點：
- 要求設計一個時間複雜度儘可能高效的算法,而已知|data|<=n, 因此能夠考慮用空間換時間的方法.
- 申請一個空間大小爲n+1(0號單元不使用)的輔助數組. 保存鏈表中已出現的數值,經過對鏈表進行一趟掃描來完成刪除.
- 分析問題，列出解題思路：
算法思路:
- 申請大小爲n+1的輔助數組t並賦值初值爲0;
- 從首元結點開始遍歷鏈表,依次檢查t[|data|]的值, 若[|data|]爲0,即結點首次出現,則保留該結點,並置t[|data|] = 1,若t[|data|]不爲0,則將該結點從鏈表中刪除.
- 問題求解，代碼實現：
//目標: 刪除單鏈表中絕對值相等的結點;
void deleteSameNode(LinkList *L, int n) {
//1. 開闢輔助數組p.
int *p = malloc(sizeof(int) * n);
LinkList r = *L;
//2.數組元素初始值置空
for (int i = 0; i < n; i++) {
*(p+1) = 0;
}
//3.指針temp 指向首元結點
LinkList temp = (*L)->next;
//4.遍歷鏈表,直到temp = NULL;
while (temp) {
//5.若是該絕對值已經在結點上出現過,則刪除該結點
if (p[abs(temp->data)] == 1) {
//刪除結點
//5.1 臨時指針r指向temp->next
r->next = temp->next;
//5.2 刪除temp指向的結點
free(temp);
//5.3 temp 指向刪除結點下一個結點
temp = r->next;
} else {
//6. 未出現過的結點,則將數組中對應位置置爲1;
p[abs(temp->data)] = 1;
r = temp;
//繼續遍歷
temp = temp->next;
}
}
}
複製代碼
- 時間複雜度：
複雜度分析: 時間複雜度: O(m),對長度爲m的鏈表進行一趟遍歷,則算法時間複雜度爲O(m); 空間複雜度: O(n)
- 測試驗證：
void test7() {
printf("刪除單鏈表中絕對值相等的結點：\n");
LinkList L;
//21,-15,15,-7,15
printf("******題目7:********\n");
initList(&L);
insertElement(&L, 1, 21);
insertElement(&L, 1, -15);
insertElement(&L, 1, 15);
insertElement(&L, 1, -7);
insertElement(&L, 1, 15);
deleteSameNode(&L, 21);
traverseList(L);
}
複製代碼
- 輸出結果：
刪除單鏈表中絕對值相等的結點：
******題目7:********
15 -7 21
複製代碼
相關文章
- 1. 數據結構和算法面試題系列—鏈表
- 2. 【數據結構】鏈表面試題
- 3. 數據結構之鏈表面試題
- 4. 大廠面試題（四）數據結構和算法
- 5. Java數據結構和算法——鏈表
- 6. 數據結構和算法5——鏈表
- 7. 數據結構和算法：鏈表（下）
- 8. 數據結構和算法：鏈表（上）
- 9. 數據結構和算法-鏈表
- 10. Java數據結構和算法 - 鏈表
- 更多相關文章...
- • Redis鏈表（linked-list）數據結構和常用命令 - Redis教程
- • XML 相關技術 - XML 教程
- • NewSQL-TiDB相關
- • 算法總結-回溯法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 外部其他進程嵌入到qt FindWindow獲得窗口句柄 報錯無法鏈接的外部符號 [email protected] 無法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的應用-TOPK問題
- 6. 實例演示ElasticSearch索引查詢term,match,match_phase,query_string之間的區別
- 7. 數學基礎知識 集合
- 8. amazeUI 復擇框問題解決
- 9. 揹包問題理解
- 10. 算數平均-幾何平均不等式的證明,從麥克勞林到柯西
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 數據結構和算法面試題系列—鏈表
- 2. 【數據結構】鏈表面試題
- 3. 數據結構之鏈表面試題
- 4. 大廠面試題（四）數據結構和算法
- 5. Java數據結構和算法——鏈表
- 6. 數據結構和算法5——鏈表
- 7. 數據結構和算法：鏈表（下）
- 8. 數據結構和算法：鏈表（上）
- 9. 數據結構和算法-鏈表
- 10. Java數據結構和算法 - 鏈表