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

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

1.連結串列的查詢插入刪除

有問題的程式碼：

#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;
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_Create();
	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_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = NULL;
	pEnd = pS;
	while (pS->data) {
		if (head->next == NULL)
			head->next = pS;
		else
			pEnd->next = pS;
		pEnd = pS;
		pS = new ListNode;
		cin >> pS->data;
		cout << head->next<<" ";
	}
	pEnd->next = NULL;
	delete pS;
	cout << head->next << " "<<endl;//沒有出去
	//return;
}
void LinkList::LL_display() {
	cout << len << " ";
	ListNode *p;
	p = head->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* LinkList::LL_index(int i) {
	int j=1;
	for (ListNode*pG = head->next; pG->next,j<=i; pG = pG->next,j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LinkList::LL_get(int i) {
	ListNode*num = LL_index(i);
	return num->data;
	return error;
}

int LinkList::LL_insert(int i,int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i==1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return ok;
	}
	int j = 0;
	ListNode*pG = head->next;
	while (pG&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI->next = pG->next;
	pG->next = pI;
	pI->data = item;
	len++;
	return ok;
}
int LinkList::LL_del(int i) {
	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 main() {
	LinkList sa;
	sa.LL_Create();
	sa.LL_display();
	int i, item, k;

	cin >> i >> item;
	k=sa.LL_insert(i,item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	k = sa.LL_insert(i, item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k = sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	return 0;
}

在輸入資料後沒反應，判斷是while迴圈沒有走出來，以至於在 LL_Create() 函式中沒有出去

修改：用 --len 來作為 while 的判斷條件，更加簡潔清晰：

#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;
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_Create();
	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_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = NULL;
	pEnd = pS;
	while (--len) {
		if (head->next == NULL)
			head->next = pS;
		else
			pEnd->next = pS;
		pEnd = pS;
		pS = new ListNode;
		cin >> pS->data;
		cout << head->next<<" ";
	}
	pEnd->next = NULL;
	delete pS;
	cout << head->next << " "<<endl;//沒有出去
	//return;
}
void LinkList::LL_display() {
	cout << len << " ";
	ListNode *p;
	p = head->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* LinkList::LL_index(int i) {
	int j=1;
	for (ListNode*pG = head->next; pG->next,j<=i; pG = pG->next,j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LinkList::LL_get(int i) {
	ListNode*num = LL_index(i);
	return num->data;
	return error;
}

int LinkList::LL_insert(int i,int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i==1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return ok;
	}
	int j = 0;
	ListNode*pG = head->next;
	while (pG&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI->next = pG->next;
	pG->next = pI;
	pI->data = item;
	len++;
	return ok;
}
int LinkList::LL_del(int i) {
	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 main() {
	LinkList sa;
	sa.LL_Create();
	sa.LL_display();
	int i, item, k;

	cin >> i >> item;
	k=sa.LL_insert(i,item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	k = sa.LL_insert(i, item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k = sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	return 0;
}

此時發現輸出語句出了問題

其實還是賦值語句的while迴圈出了問題，為什麼認為這道題和課本上結構部分的連結串列是一樣的呢？一定要吸取教訓

#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;
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_Create();
	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_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = pS;
	pEnd = pS;
	int q = len;
	while (--q) {
		pEnd = pS;
		pS = new ListNode;
		cin >> pS->data;
		pEnd->next = pS;
	}
	
	cout <<"++++"<< head->next->next->next->data<<endl;
	pEnd->next = NULL;
	delete pS;
	return;
}
void LinkList::LL_display() {
	cout << len << " ";
	ListNode *p;
	p = head->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
		cout << " &*(*& ";
	}
	cout << endl;
}
ListNode* LinkList::LL_index(int i) {
	int j=1;
	for (ListNode*pG = head->next; pG->next,j<=i; pG = pG->next,j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LinkList::LL_get(int i) {
	ListNode*num = LL_index(i);
	return num->data;
	return error;
}

int LinkList::LL_insert(int i,int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i==1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return ok;
	}
	int j = 0;
	ListNode*pG = head->next;
	while (pG&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI->next = pG->next;
	pG->next = pI;
	pI->data = item;
	len++;
	return ok;
}
int LinkList::LL_del(int i) {
	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 main() {
	LinkList sa;
	sa.LL_Create();
	sa.LL_display();
	int i, item, k;

	cin >> i >> item;
	k=sa.LL_insert(i,item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	k = sa.LL_insert(i, item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k = sa.LL_get(i);
	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;
	}
};

class LinkList {
public:
	ListNode * head;
	int len;
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_Create();
	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_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = pS;
	pEnd = pS;
	int q = len;
	while (--q) {
		pEnd = pS;
		pS = new ListNode;
		cin >> pS->data;
		pEnd->next = pS;
	}
	pS->next = NULL;
	pEnd = pS;
	delete pS;
	return;
}
void LinkList::LL_display() {
	cout << len << " ";
	int q = len;
	ListNode *p;
	p = head->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* LinkList::LL_index(int i) {
	int j=1;
	for (ListNode*pG = head->next; pG->next,j<=i; pG = pG->next,j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LinkList::LL_get(int i) {
	ListNode*num = LL_index(i);
	return num->data;
	return error;
}

int LinkList::LL_insert(int i,int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i==1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return ok;
	}
	int j = 0;
	ListNode*pG = head->next;
	while (pG&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI->next = pG->next;
	pG->next = pI;
	pI->data = item;
	len++;
	return ok;
}
int LinkList::LL_del(int i) {
	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 main() {
	LinkList sa;
	sa.LL_Create();
	sa.LL_display();
	int i, item, k;

	cin >> i >> item;
	k=sa.LL_insert(i,item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	k = sa.LL_insert(i, item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k = sa.LL_get(i);
	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;
	}
};

class LinkList {
public:
	ListNode * head;
	int len;
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_Create();
	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_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = pS;
	pEnd = pS;
	int q = len;
	while (--q) {
		pEnd = pS;
		pS = new ListNode;
		cin >> pS->data;
		pEnd->next = pS;
	}
	pS->next = NULL;
	pEnd = pS;
	delete pS;
	return;
}
void LinkList::LL_display() {
	cout << len << " ";
	int q = len;
	ListNode *p;
	p = head->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* LinkList::LL_index(int i) {
	int j=1;
	for (ListNode*pG = head->next; pG->next,j<=i; pG = pG->next,j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LinkList::LL_get(int i) {
	ListNode*num = LL_index(i);
	return num->data;
	return error;
}

int LinkList::LL_insert(int i,int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i==1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return ok;
	}
	int j = 0;
	ListNode*pG = head->next;
	while (pG&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI->next = pG->next;
	pG->next = pI;
	pI->data = item;
	len++;
	return ok;
}
int LinkList::LL_del(int i) {
	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 main() {
	LinkList sa;
	sa.LL_Create();
	sa.LL_display();
	int i, item, k;

	cin >> i >> item;
	k=sa.LL_insert(i,item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	k = sa.LL_insert(i, item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k = sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	return 0;
}

發現在輸入的時候最後一個沒有成功輸入資料

void LinkList::LL_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = pS;
	pEnd = pS;
	int q = len;
	while (--q) {
		pEnd = pS;
		pS = new ListNode;
		cin >> pS->data;
		pEnd->next = pS;
	}
	pS->next = NULL;
	pEnd = pS;
	delete pS;
	cout << endl << pEnd->data << endl;
	return;
}

改了好久還是有問題，太煩了

#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;
	LinkList();
	~LinkList();
	ListNode*LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_Create();
	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_Create() {
	ListNode*pS;
	ListNode*pEnd;
	pS = new ListNode;
	cin >> len;
	cin >> pS->data;
	head->next = pS;
	pEnd = pS;
	//delete pS;
	int q = len;
	while (--q) {
		pS = new ListNode;
		cin >> pS->data;
		pEnd->next = pS;
		pEnd = pS;
	}
	pEnd->next = NULL;
	cout << head->next->data<<endl;
	cout << head->next->next->data << endl;
	cout << head->next->next->next->data << endl;
	cout << pEnd->data;
	delete pS;
	return;
}
void LinkList::LL_display() {
	cout << len << " ";
	ListNode *p;
	p = head->next;
	while (p->next!=NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* LinkList::LL_index(int i) {
	int j=1;
	for (ListNode*pG = head->next; pG->next,j<=i; pG = pG->next,j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LinkList::LL_get(int i) {
	ListNode*num = LL_index(i);
	return num->data;
	return error;
}

int LinkList::LL_insert(int i,int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i==1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return ok;
	}
	int j = 0;
	ListNode*pG = head->next;
	while (pG&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return error;
	pI->next = pG->next;
	pG->next = pI;
	pI->data = item;
	len++;
	return ok;
}
int LinkList::LL_del(int i) {
	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 main() {
	LinkList sa;
	sa.LL_Create();
	sa.LL_display();
	int i, item, k;

	cin >> i >> item;
	k=sa.LL_insert(i,item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	k = sa.LL_insert(i, item);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k=sa.LL_del(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	cin >> i;
	k=sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;
	cin >> i;
	k = sa.LL_get(i);
	if (k == 0)
		sa.LL_display();
	else
		cout << "error" << endl;

	return 0;
}

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

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

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

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

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

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

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

資料結構-連結串列

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

java資料結構連結串列

package 演算法.連結串列; class Data { String key; String name; int age; } class CLType { //定義連結串列結構 Data nodedat

資料結構---連結串列示意圖

1、單鏈表： 2、單迴圈連結串列 typedef int ElemType;//使用一般定義，做一般解釋 struct Node { ElemType data; struct Node *next; }; typedef struct Node LN

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

相關推薦