2. 程式人生 > 其它 >連結串列操作總結

連結串列操作總結

阿新 • • 發佈：2020-12-25

技術標籤：資料結構

宣告

一年前閒著無聊時，研究研究了連結串列，當時寫的時候也花了不少時間，當時我的思路如下

動態連結串列帶頭結點

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
}

	head->id =-1;
	head-
 
>next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout <<"請輸入資料";
		cin>>data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
			if (pNew == NULL) {
				continue;
			}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
 

		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout <<pCur->id<<
 
"->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;
}

結點的插入

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
//在值為x的結點前，插入值為y的結點，若x結點不存在，則插在表尾
int increasenode(node* head, int x, int y)
{
	if (head == NULL)
	{
		return -1;
	}
	node* Pre = head;
	node* Cur = head->next;
	while (Cur != NULL)
	{
		if (Cur->id == x)
		{
			break;
		}
		Pre = Cur;
		Cur = Cur->next;
	}
	node* pNew = (node*)malloc(sizeof(node));
	if (pNew == NULL) {
		return -2;
	}
	pNew->id = y;
	pNew->next = NULL;

	Pre->next = pNew;
	pNew->next = Cur;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	int x; int y;
	cout << "分別輸入x和y，在x的前面插入y" << endl;
	cin >> x >> y;
	increasenode(head, x, y);
	cout << "在x的前面插入y:";
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;

}

靜態連結串列

#include <iostream>
using namespace std;
class node {
public:
	int id;
	char name[100];
	node* next;

};
int  main() {

	node s1 = { 1,"biaobiao",NULL };
	node s2 = { 2,"aha",NULL };
	node s3 = { 3,"leilei",NULL };
	s1.next = &s2;
	s2.next = &s3;
	s3.next = NULL;
	node* p = &s1;
	while (p != NULL) {
		cout << p->id << "   " << p->name << "   " << endl;
		p = p->next;
	}
}

連結串列反轉

#include<iostream>
using namespace std;
 class node {
public:
	int id;
	node* next;
};
int noderexerse(node* head) {
	if (head == NULL || head->next == NULL || head->next->next == NULL)
	{
		return -1;
	}
	node* pre = head->next;
	node* cur = pre->next;
	node* temp=NULL;
	while (cur != NULL)
	{
		temp=cur->next;
		cur->next = pre;

		pre = cur;
		cur = temp;
	}
	head->next->next = NULL;
	head->next = pre;
	return 0;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}

		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	noderexerse(head);
	cout << "反轉後為：" << endl;
	ListPrint(head);
}

清空動態建立的連結串列

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
//清空連結串列
int destroynode(node* head) {
	if (head == NULL) {
		return -1;
	}
	node* temp = NULL;
	int i = 0;
	while (head != NULL)
	{
		temp = head->next;
		free(head);
		head = NULL;
		head = temp;
		i++;
	}
	cout << "釋放次數為：" << i<<endl;
	return 0;
}
node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	destroynode(head);
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;
}

刪除第一個為x的結點

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
int freecode(node*head,int x)
{
	if (head == NULL)
	{
		return -1;
	}
	node* Pre = head;
	node* Cur = head->next;
	int flag = 0;//0沒有找到，1找到了
	while (Cur != NULL)
	{
		if (Cur->id == x)
		{
			Pre->next = Cur->next;
			free(Cur);
			Cur = NULL;
			flag = 1;
			break;
		}
		Pre = Cur;
		Cur = Cur->next;
	}
	if (flag == 0)
	{
		cout << "沒有值為" << x << "的結點" << endl;
		return -2;
	}


}
node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	int x;
	cout << "請輸入需要刪除的結點" << endl;
	cin >> x;
	freecode(head, x);
	cout << "刪除後結果為:" << endl;
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;

}

刪除所有為x的結點

#include <iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
int freecode(node* head, int x)
{
	if (head == NULL)
	{
		return -1;
	}
	node* Pre = head;
	node* Cur = head->next;
	int flag = 0;//0沒有找到，1找到了
	while (Cur != NULL)
	{
		if (Cur->id == x)
		{
			Pre->next = Cur->next;
			free(Cur);
			Cur = NULL;
			flag = 1;
			Cur = Pre->next;
			continue;
			//break;
		}
		Pre = Cur;
		Cur = Cur->next;
	}
	if (flag == 0)
	{
		cout << "沒有值為" << x << "的結點" << endl;
		return -2;
	}


}
node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	int x;
	cout << "請輸入需要刪除的結點" << endl;
	cin >> x;
	freecode(head, x);
	cout << "刪除後結果為:" << endl;
	ListPrint(head);
	cout << " ";
	system("pause");
	return 0;

}

升序連結串列插入

#include<iostream>
using namespace std;
 struct node {

	int id;
	node* next;
};
//假如原來連結串列是升序 的，升序後插入新節點
//不能插入結點後再排序，是升序插入新節點x
int  insertnode(node* head, int x) {
	
	 if (head == NULL)
	 {
		 return -1;
	 }
	 node* Pre = head;
	 node* Cur = head->next;
	 while (Cur != NULL)
	 {
		 if (Cur->id > x)
		 {
			 break;
		 }
		 Pre = Cur;
		 Cur = Cur->next;
	 }
	 node* pNew = (node*)malloc(sizeof(node));
	 if (pNew == NULL) {
		 return -2;
	 }
	 pNew->id = x;
	 pNew->next = NULL;

	 Pre->next = pNew;
	 pNew->next = Cur;

  }
int  nodesort(node* head)
{
	if (head == NULL || head->next == NULL)
	{
		return 0;
	}
	node* pre = NULL;
	node* cur = NULL;
	node temp;
	for (pre = head->next; pre->next != NULL; pre = pre->next)
	{
		for (cur = pre->next; cur != NULL; cur = cur->next)
		{
			if (pre->id > cur->id)
			{
				temp.id = cur->id;
				cur->id = pre->id;
				pre->id = temp.id;
				/*
				temp = *cur;
				*cur = *pre;
				*pre = temp;
				temp.next = cur->next;
				cur->next = pre->next;
				pre->next = temp.next;*/
			}
		}
	}
	return 0;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	nodesort(head);
	int x;
	cout << "輸入想要升序插入的數：" << endl;
	cin >> x;
	cout << "升序插入" << x << "後:" << endl;
	insertnode(head, x);
	ListPrint(head);
}

用連結串列進行排序

#include<iostream>
using namespace std;
class node {
public:
	int id;
	node* next;
};
int  nodesort(node* head) {
	if (head == NULL || head->next == NULL)
	{
		return 0;
	}
	node* pre = NULL;
	node* cur = NULL;
	node temp;
	for (pre = head->next; pre->next != NULL; pre = pre->next)
	{
		for (cur = pre->next; cur != NULL; cur = cur->next)
		{
			if (pre->id > cur->id)
			{
				temp.id = cur->id;
				cur->id = pre->id;
				pre->id = temp.id;
				/*
				temp = *cur;
				*cur = *pre;
				*pre = temp;
				temp.next = cur->next;
				cur->next = pre->next;
				pre->next = temp.next;*/
			}
		}
	}
	return 0;
}

node* ListCreat() {
	node* head = NULL;

	head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		return NULL;
	}

	head->id = -1;
	head->next = NULL;

	node* pCur = head;
	node* pNew = NULL;

	int data;
	while (1) {
		cout << "請輸入資料";
		cin >> data;
		if (data == -1) {
			break;
		}


		pNew = (node*)malloc(sizeof(node));
		if (pNew == NULL) {
			continue;
		}

		pNew->id = data;
		pNew->next = NULL;
		//連結串列建立關係
		pCur->next = pNew;

		pNew->next = NULL;

		pCur = pNew;
	}
	return head;
}
int  ListPrint(node* head) {

	if (head == NULL)
	{
		return -1;
	}
	//取出第一個有效結點，head的下一次結點
	node* pCur = head->next;
	cout << "head->";
	while (pCur != NULL)
	{
		cout << pCur->id << "->";
		pCur = pCur->next;
	}
	cout << "NULL\n";
	return 0;
}
int  main() {
	node* head = NULL;
	head = ListCreat();
	ListPrint(head);
	nodesort(head);
	cout << "排序後為：";
	ListPrint(head);
}

相關推薦

連結串列操作總結

技術標籤：資料結構 宣告 一年前閒著無聊時，研究研究了連結串列，當時寫的時候也花了不少時間，當時我的思路如下

連結串列操作基礎

連結串列的基礎操作我們都很熟悉，與此同時更流暢，完整，正確的解決，也是必不可少的基本功。因此我對它們做了一個總結，千萬不要小看這些基礎操作，熟悉它們以後你解決連結串列的問題將會得心應手，那麼，開始吧！

JavaScript 雙向連結串列操作例項分析【建立、增加、查詢、刪除等】

本文例項講述了JavaScript 雙向連結串列操作。分享給大家供大家參考，具體如下：

linux核心裡的字串轉換 ,連結串列操作常用函式(轉)

1.對雙向連結串列的具體操作如下: list_add———向連結串列新增一個條目

【C語言教程】“雙向迴圈連結串列”學習總結和C語言程式碼實現！

雙向迴圈連結串列 定義 雙向迴圈連結串列和它名字的表意一樣，就是把雙向連結串列的兩頭連線，使其成為了一個環狀連結串列。只需要將表中最後一個節點的next指標指向頭節點，頭節點的prior指標指向尾節點，連結串列就

php版本連結串列操作

單鏈表 <?php class Node{ public $data = \'\'; public $next = null; function __construct($data) { $this->data = $data;

應用案例——多連結串列共享同一套連結串列操作

Linux 核心“共享”雙向連結串列在 linux 核心中，有大量的資料結構需要用到雙向連結串列，例如程序、檔案、模組、頁面等。若採用雙向連結串列的傳統實現方式，需要為這些資料結構維護各自的連結串列，並且

計算機基礎資料結構講解第七篇-連結串列操作

  本篇文章我們學習線性表的鏈式表示，也就是連結串列。我們知道，順序表可以隨機存取，查詢方便，但是插入和刪除需要移動大量元素。鏈式儲存線性表的時候，不需要使用地址連續的儲存單元，而是通過"鏈"

python實現資料結構中雙向迴圈連結串列操作的示例

看此部落格之前建議先看看B站的視訊python資料結構與算法系列課程，該課程中未實現雙向迴圈連結串列的操作，所以我按照該視訊的連結串列思路實現了雙向迴圈連結串列的操作，歡迎大家閱讀與交流，如有侵權，請聯絡博主

python如何對連結串列操作

連結串列 連結串列(linked list)是由一組被稱為結點的資料元素組成的資料結構，每個結點都包含結點本身的資訊和指向下一個結點的地址。

單鏈表的基本運算②：插入操作、刪除操作、求表長操作、銷燬連結串列操作以及刪除實驗

本實驗的過程： 建立AB兩個連結串列，通過讀取兩個陣列中的不同元素往裡面存入資料，並刪除A中AB重合的資料，僅此而已：

連結串列演算法總結

針對考研王道上的連結串列題目，總結出幾個經典的連結串列演算法，更新中。。。

01-連結串列操作整理

//連結串列操作整理 #include<vector> #include<iostream> #include<stack> using namespace std;

leetcode 常用連結串列操作

/** * Definition for singly-linked list. * struct ListNode { *int val; *ListNode *next; *ListNode() : val(0), next(nullptr) {}

LeetCode 連結串列題總結

最近花了幾天時間，將連結串列題除帶鎖外的題目做完了，下面對連結串列題部分題目進行總結和分析。

連結串列反轉總結

1. 反轉整個連結串列 遞迴反轉連結串列 比如現在有這樣一個連結串列： \\(K_1\\rightarrow K_2\\rightarrow ... \\rightarrow K_{i}\\rightarrow K_{i+1}\\rightarrow ... \\rightarrow K_{n}\\)

連結串列操作（改）--學生管理

#include <stdio.h> #include <stdlib.h> #include<string.h> #define N 100 void tillinsert(int id,char *name,float score);//尾部插入結點

SCAU程式設計線上實訓平臺_實驗_高階語言程式設計_實驗11_連結串列操作_堂前習題

技術標籤：程式設計學習SCAU 1099 [填空題]連結串列的合併 Description 下面程式建立兩個連結串列，然後將第二個連結串列合併到第一個連結串列未尾，但合併部分的程式碼未完成，請你完成這部分程式碼。

Java 無頭雙向迴圈連結串列操作方法

技術標籤：java資料結構雙向連結串列 無頭雙向迴圈連結串列 結點物件具有三個域 data next prev，其中data放數值，next指向下一個結點物件，prev指向前一個結點物件。

力扣刷題筆記：86.分隔連結串列（思路簡單、主要鍛鍊連結串列操作、完整題解程式碼及註釋）

技術標籤：刷題筆記leetcodepython 題目： 86、分隔連結串列 給你一個連結串列和一個特定值 x ，請你對連結串列進行分隔，使得所有小於 x 的節點都出現在大於或等於 x 的節點之前。