資料結構連結串列題目2：交換位置、3：合併

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

利用查詢、提取資料、插入、刪除、輸出等函式，順利搞定第二題

#include<iostream>
#define ok 0
#define error -1
using namespace std;

class ListNode {
public:
	int data;
	ListNode*next;
	ListNode() {
		next = NULL;
	}
};

class LinkList {
public:
	ListNode * head;
	int len;
public:
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_display();
	int LL_get(int i);
	int swap(int pa, int pb);
};
LinkList::LinkList() {
	head = new ListNode();
	len = 0;
}
LinkList::~LinkList() {
	ListNode*p, *q;
	p = head;
	while (p != NULL) {
		q = p;
		p = p->next;
		delete q;
	}
	len = 0;
	head = NULL;
}
void LinkList::LL_display() {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
int LinkList::LL_insert(int i, int item) {
	if (i < 1 || i> len + 1)
		return error;
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		len++;
		return ok;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	len++;
	return ok;
}
ListNode* LinkList::LL_index(int i) {
	if (i > len || i < 0) {
		return NULL;
	}
	if (i == 0)
		return head;
	int j = 1;
	for (ListNode*pG = head->next; pG->next, j <= i; pG = pG->next, j++) {
		if (j == i) {
			return pG;
		}
	}
}



int LinkList::LL_del(int i) {
	if (i > len || i<1)
		return error;
	ListNode*pI = new ListNode;
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI = pG->next;
	pG->next = pI->next;
	delete pI;
	len--;
	return ok;
}
int LinkList::LL_get(int i) {
	if (i > len || i < 1) {
		return error;
	}
	ListNode*num = LL_index(i);
	if (num == NULL)
		return error;
	else
		return num->data;

}
int LinkList::swap(int pa, int pb) {
	if (pa<1 || pb<1 || pa>len || pb>len) {
		return error;
	}
	int m = LL_get(pa);
	int n = LL_get(pb);
	LL_insert(pa, n);
	LL_del(pa + 1);
	LL_insert(pb, m);
	LL_del(pb + 1);
	return ok;
}


int main() {
	LinkList sa;
	int num;
	cin >> num;
	int number;
	for (int i = 0; i < num; i++) {
		cin >> number;
		sa.LL_insert(i + 1, number);
	}
	sa.LL_display();
	int pa, pb, k;
	cin >> pa >> pb;
	k=sa.swap(pa, pb);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> pa >> pb;
	k=sa.swap(pa, pb);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	return 0;

}

第三題，有點問題存在

#include<iostream>
#define ok 0
#define error -1

using namespace std;

class ListNode {
public:
	int data;
	ListNode*next;
	ListNode() {
		next = NULL;
	}
};

ListNode* Lc;
int LL_merge(ListNode *La, ListNode *Lb);//要放在類宣告的後面

class LinkList {
public:
	ListNode * head;
	int len;
public:
	LinkList();
	~LinkList();
	int LL_insert(int i, int item);
	void LL_display();
};
LinkList::LinkList() {
	head = new ListNode();
	len = 0;
}
LinkList::~LinkList() {
	ListNode*p, *q;
	p = head;
	while (p != NULL) {
		q = p;
		p = p->next;
		delete q;
	}
	len = 0;
	head = NULL;
}
void LinkList::LL_display() {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
int LinkList::LL_insert(int i, int item) {
	if (i < 1 || i> len + 1)
		return error;
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		len++;
		return ok;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	len++;
	return ok;
}


int LL_merge(ListNode *La, ListNode *Lb) {
	ListNode* pa = La->next;
	ListNode* pb = Lb->next;
	Lc = La;
	ListNode* pc = Lc;
	while (pa&&pb) {
		if (pa->data <= pb->data) {
			pc->next = pb;
			pc = pa;
			pa = pa->next;
		}
		else {
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
		if (pa != NULL)
			pc->next = pa;
		else
			pc->next = pb;
	}
	La = Lc;
	return ok;
}

int main() {
	LinkList sa;
	int num1;
	cin >> num1;
	int number1;
	for (int i = 0; i < num1; i++) {
		cin >> number1;
		sa.LL_insert(i + 1, number1);
	}
	sa.LL_display();
	LinkList ta;
	int num2;
	cin >> num2;
	int number2;
	for (int i = 0; i < num2; i++) {
		cin >> number2;
		ta.LL_insert(i + 1, number2);
	}
	ta.LL_display();
	LL_merge(sa.head, ta.head);
	sa.LL_display();
	return 0;
}

最後終於順利解決問題：

#include<iostream>
#define ok 0
#define error -1

using namespace std;

class ListNode {
public:
	int data;
	ListNode*next;
	ListNode() {
		next = NULL;
	}
};

ListNode* Lc;

int LL_merge(ListNode *La, ListNode *Lb);

class LinkList {
public:
	ListNode * head;
	int len;
public:
	LinkList();
	~LinkList();
	int LL_insert(int i, int item);
	void LL_display();
};
LinkList::LinkList() {
	head = new ListNode();
	len = 0;
}
LinkList::~LinkList() {
	ListNode*p, *q;
	p = head;
	while (p != NULL) {
		q = p;
		p = p->next;
		delete q;
	}
	len = 0;
	head = NULL;
}
void LinkList::LL_display() {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
int LinkList::LL_insert(int i, int item) {
	if (i < 1 || i> len + 1)
		return error;
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		len++;
		return ok;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	len++;
	return ok;
}


int LL_merge(ListNode *La, ListNode *Lb) {
	ListNode* pa = La->next;
	ListNode* pb = Lb->next;
	ListNode* pc = La;
	Lc = pc;
	while (pa&&pb) {
		if (pa->data <= pb->data) {
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else {
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
		if (pa != NULL)
			pc->next = pa;
		else
			pc->next = pb;
	}
	return ok;
}

int main() {
	LinkList sa;
	int num1;
	cin >> num1;
	int number1;
	for (int i = 0; i < num1; i++) {
		cin >> number1;
		sa.LL_insert(i + 1, number1);
	}

	LinkList ta;
	int num2;
	cin >> num2;
	int number2;
	for (int i = 0; i < num2; i++) {
		cin >> number2;
		ta.LL_insert(i + 1, number2);
	}

	LL_merge(sa.head, ta.head);
	ListNode *p = Lc->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
	return 0;
}

只是編譯後不能順利結束，關閉編譯框時會無響應後關掉

資料結構連結串列題目2：交換位置、3：合併

利用查詢、提取資料、插入、刪除、輸出等函式，順利搞定第二題 #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data; List

資料結構連結串列題目1：查詢、插入、刪除基本操作解析

1.連結串列的查詢插入刪除有問題的程式碼： #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data; ListNode

資料結構連結串列題目解析

1.連結串列的查詢插入刪除有問題的程式碼： #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data;

資料結構--連結串列2

今天繼續介紹資料結構中的連結串列這塊這塊內容，前面介紹了建立資料鏈表採用頭插法，尾插法，今天主要介紹的是有序插法。在介紹有序插法前先進行頭插法與尾部插法的總結。新建連結串列主要有三種方法：頭插法，尾插法，有序插法頭插法的主要思路：連結串列為空的時候，新節點變為

演算法與資料結構（3）：基本資料結構——連結串列，棧，佇列，有根樹

原本今天是想要介紹堆排序的。雖然堆排序需要用到樹，但基本上也就只需要用一用樹的概念，而且還只需要完全二叉樹，實際的實現也是用陣列的，所以原本想先把主要的排序演算法講完，只簡單的說一下樹的概念。但在寫的過程中才發現，雖然是隻用了一下樹的概念，但要是樹的概念沒講明白的話，其實不太好理解。所以決定先介紹一下基本的資

js資料結構 -- 連結串列, 雙向連結串列，迴圈連結串列

陣列作為js常用的資料結構，存取元素都非常的方便，但是其內部的實現原理跟其他計算機語言對陣列的實現都是一樣的。由於陣列在記憶體中的儲存是連續的，所以當在陣列的開頭或者中間插入元素時，內部都需要去移動其他元素的位置，這個移動元素的成本很高。連結串列也是儲存有序的元素集合，但不同

Python資料結構-連結串列

1）概念：連結串列是一種物理儲存單元上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列結點（連結串列中每一個元素稱為結點）組成，結點可以在執行時動態生成。每個結點包括兩個部分：一個是儲存資料元素的資料域，另一個是儲存下一個結點地址的指標域。相比於線性表順序結

資料結構--連結串列

定義 n個節點離散分配彼此通過指標相連 &n

java中的資料結構——連結串列

連結串列連結串列也是線性資料結構，與陣列相比，在記憶體分配、內部結構及資料插入和刪除的操作上均有不同。連結串列用途廣泛，適用於許多通用的資料庫，也可以取代陣列，作為其他儲存結構的基礎。在連結串列中，每個資料項都被包含在鏈節點中，一個鏈節點是某個類的物件，這個類叫做Link。因為一個

Redis底層資料結構--連結串列

這是普通的連結串列實現, 連結串列結點不直接持有資料, 而是通過void *指標來間接的指向資料. 其實現位於 src/adlist.h與src/adlist.c中, 關鍵定義如下: typedef struct listNode { struct listNode *prev

資料結構 - 連結串列

連結串列　　之前講到的動態陣列、棧、佇列，底層都是依託靜態陣列，靠resize解決固定容量問題。而連結串列是一種真正的動態線性的資料結構。　　*最簡單的動態資料結構　　*更加深入理解引用　　*更深入的理解遞迴　　*輔組組成其他資料結構　　　　資料儲存在節點（Node

資料結構-連結串列-練習題1

題目 2.已知一個帶表頭結點的單鏈表，結點結構為data、link,假設該連結串列只給出了頭指標list。在不改變連結串列的前提下，請設計一個儘可能高效的演算法，查詢連結串列中倒數第k個位置上的結點（k正為整數）。若查詢成功，演算法輸出該結點的data域的值，並返回1

前端也需要了解的資料結構-連結串列

前言最近被小夥伴問到連結串列是什麼,連結串列作為一種常見的資料結構,但是很多前端coder對此並不瞭解,寫下這篇文章,介紹下連結串列的js實現,不瞭解連結串列的同學也可以做個參考單向連結串列和陣列區別，地址離散。它在記憶體地址中可以離散的分配，由於它是離散的分配，所以他可以

資料結構---------連結串列

一、連結串列為什麼存在？ 1）.陣列的缺陷無序列表：搜尋效能差，有序列表：插入效率低，並且兩個的刪除效率也很低，陣列在

資料結構-連結串列（java實現）

/** * 連結串列節點定義 * */ private class Node { private Object data; private Node next; public Node getNext() { return next;

資料結構—連結串列經典面試題

連結串列面試題：從尾到頭列印單鏈表刪除一個無頭單鏈表的非尾節點（不能遍歷連結串列）在無頭單鏈表的一個節點前插入一個節點（不能遍歷連結串列）單鏈表實現約瑟夫環(JosephCircle) 逆置/反轉單鏈表單鏈表排序（氣泡排序&快速排序）合併

演算法導論---資料結構----連結串列篇

資料結構----連結串列連結串列的每個元素都是一個物件x，x.key(鍵值),x.prev（上一個指標）, x.next（下一個指標）,x.head（表頭）雙向連結串列：x.prev, x.next,x.head 單向連結串列：x.next，x.head 迴圈連結

資料結構——連結串列求兩集合的交集

#include <stdio.h> #include <malloc.h> typedef struct Node { int data; struct Node *next; }LNode,*LinkList; LNode *C

資料結構——連結串列（幾個拓展的做法）

#include <stdio.h>//注意放在c++中 #include <stdlib.h> #include <string.h> typedef struct as{ int date; struct

資料結構-連結串列

本章將討論另一種列表: 連結串列 . 解釋為什麼有時連結串列優於陣列, 還會實現一個基於物件的連結串列. 陣列的缺點陣列不總是組織資料的最佳資料結構, 原因如下. 在很多程式語言中, 陣列的長度是固定的, 所以當陣列已被資料填滿時, 再要加入新的元素就會非常困難.

資料結構連結串列題目2：交換位置、3：合併

相關推薦