連結串列，不用類

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

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


struct ListNode {
	int data;
	ListNode*next;
};

void LL_display(ListNode*head) {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* LL_index(ListNode*head,int i) {
	if (i > num || i < 1) {
		return NULL;
	}
	int j = 1;
	for (ListNode*pG = head->next; pG->next, j <= i; pG = pG->next, j++) {
		if (j == i) {
			return pG;
		}
	}
}

int LL_get(ListNode*head,int i) {
	if (i > num || i < 1) {
		return error;
	}
	ListNode*num = LL_index(head,i);
	if (num == NULL)
		return error;
	else
		return num->data;
}

int LL_insert(ListNode*head,int i, int item) {
	if (i < 1 || i> num + 1)
		return error;
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		num++;
		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;
	num++;
	return ok;
}
int LL_del(ListNode*head,int i) {
	if (i > num || 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;
	num--;
	return ok;
}

int main() {
	ListNode*sa = new ListNode;//不 new 的話不會分配記憶體
	sa->data = -1;
	sa->next=NULL;
	num = 0;
	int len;
	cin >> len;
	int number;
	for (int i = 0; i < len; i++) {
		cin >> number;
		LL_insert(sa,i + 1, number);
	}
	LL_display(sa);

	int i, item, k;

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

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

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

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

	cin >> i;
	k = LL_get(sa,i);
	if (k == -1)
		cout << "error" << endl;
	else
		cout << k << endl;

	cin >> i;
	k = LL_get(sa, i);
	if (k == -1)
		cout << "error" << endl;
	else
		cout << k << endl;

	return 0;
}

迴圈連結串列：

#include<iostream>
using namespace std;
int num;


struct ListNode {
	int data;
	ListNode*next;
};

void display(ListNode*head) {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* index(ListNode*head, int i) {
	int j = 1;
	for (ListNode*pG = head->next; pG->next, j <= i; pG = pG->next, j++) {
		if (j == i) {
			return pG;
		}
	}
}

int get(ListNode*head, int i) {
	ListNode*n = index(head, i);
	if (n == NULL)
		return 0;
	else
		return n->data;
}

int insert(ListNode*head, int i, int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		num++;
		return 1;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return 0;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	num++;
	return 1;
}
int del(ListNode*head, 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 0;
	pI = pG->next;
	pG->next = pI->next;
	delete pI;
	num--;
	return 1;
}

int onlyOne(ListNode*head) {
	if (head->next == head) {
		return 1;
	}
	else {
		return 0;
	}
}

int main() {
	int len;//人數
	while (scanf("%d", &len) == 1) {
		ListNode*sa = new ListNode;//不 new 的話不會分配記憶體
		sa->data = -1;
		sa->next = NULL;
		num = 0;
		int number;
		for (int i = 0; i < len; i++) {
			scanf("%d", &number);//輸入每個人持有的密碼
			insert(sa, i + 1, number);
		}//通過for迴圈一個一個連入連結串列
		ListNode* p1 = index(sa, len);
		ListNode* p2 = index(sa, len - 1);
		sa->data = p1->data;
		p2->next = sa;//首尾連線構成環鏈
		int m;
		int key;
		scanf("%d", &m);
		ListNode*start = sa;
		while (!onlyOne(start)) {
			ListNode*p = index(start, m);
			key = p->data;
			ListNode*q = index(start, m - 1);
			del(start, m);
			start = q;
			//迴圈連結串列可能轉幾圈遍歷所有，這樣刪掉的元素被 跳過，造成混亂 
			m = key;
			printf("%d ", key);
		}
		printf("%d\n", start->data);
	}
	return 0;
}

現在的問題是，迴圈終止條件，只有單個元素的環形連結串列的判斷

#include<iostream>
using namespace std;
int num;


struct ListNode {
	int data;
	ListNode*next;
};

void display(ListNode*head) {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
ListNode* index(ListNode*head, int i) {
	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 get(ListNode*head, int i) {
	ListNode*n = index(head, i);
	if (n == NULL)
		return 0;
	else
		return n->data;
}

int insert(ListNode*head, int i, int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		num++;
		return 1;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return 0;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	num++;
	return 1;
}
int del(ListNode*head, 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 0;
	pI = pG->next;
	pG->next = pI->next;
	delete pI;
	num--;
	return 1;
}

int onlyOne(ListNode*head) {
	if (head->next == head) {
		return 1;
	}
	else {
		return 0;
	}
}

int main() {
	int len;//人數
	while (scanf("%d", &len) == 1) {
		ListNode*sa = new ListNode;//不 new 的話不會分配記憶體
		sa->data = -1;
		sa->next = NULL;
		num = 0;
		int number;
		for (int i = 0; i < len; i++) {
			scanf("%d", &number);//輸入每個人持有的密碼
			insert(sa, i + 1, number);
		}//通過for迴圈一個一個連入連結串列
		ListNode* p1 = index(sa, len);
		ListNode* p2 = index(sa, len - 1);
		sa->data = p1->data;
		p2->next = sa;//首尾連線構成環鏈
		int m;
		int key;
		scanf("%d", &m);
		ListNode*start = sa;
		while (!onlyOne(start)) {
			ListNode*p = index(start, m);
			key = p->data;
			ListNode*q = index(start, m - 1);
			del(start, m);
			start = q;
			//迴圈連結串列可能轉幾圈遍歷所有，這樣刪掉的元素被 跳過，造成混亂 
			m = key;
			printf("%d ", key);
		}
		printf("%d\n", start->data);
	}
	return 0;
}

成功，對 i = 0 ，的查詢沒有修改。屬於細節地方出問題，要善於運用debug。

精簡和註釋

#include<stdio.h>

//定義結構體
struct ListNode {
	int data;
	ListNode*next;
};

//查詢：返回連結串列中第i個元素的地址
ListNode* index(ListNode*head, int i) {
	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;
		}
	}
}

//插入：在i位置插入元素
int insert(ListNode*head, int i, int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		return 1;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return 0;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	return 1;
}


//刪除：刪除i處元素
int del(ListNode*head, 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 0;
	pI = pG->next;
	pG->next = pI->next;
	delete pI;
	return 1;
}

//判斷環連結串列是否只剩一下一個元素
int onlyOne(ListNode*head) {
	if (head->next == head) {
		return 1;
	}
	else {
		return 0;
	}
}

int main() {
	int len;//人數

	//用while() 實現多組輸入
	while (scanf("%d", &len) == 1) {
		//建立單向連結串列
		ListNode*sa = new ListNode;
		sa->data = -1;
		sa->next = NULL;
		int number;
		for (int i = 0; i < len; i++) {
			scanf("%d", &number);
			insert(sa, i + 1, number);
		}
		//構成環連結串列
		ListNode* p1 = index(sa, len);
		ListNode* p2 = index(sa, len - 1);
		sa->data = p1->data;
		p2->next = sa;
		//輸入第一個報數值
		int m;
		int key;
		scanf("%d", &m);
		ListNode*start = sa;
		//依次報數並出列
		while (!onlyOne(start)) {
			ListNode*p = index(start, m);
			key = p->data;
			ListNode*q = index(start, m - 1);
			del(start, m);
			start = q;
			m = key;
			printf("%d ", key);
		}
		printf("%d\n", start->data);
	}
	return 0;
}

多項式：

#include<stdio.h>

struct list{
	int coef;
	int power;
	list* next;
};


/*void display(ListNode*head) {
	ListNode *p = head->next;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}*/
ListNode* index(ListNode*head, int i) {
	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 get(ListNode*head, int i) {
	ListNode*n = index(head, i);
	if (n == NULL)
		return 0;
	else
		return n->data;
}
 
int insert(ListNode*head, int i, int item) {
	ListNode*pI = new ListNode;
	if (!head->next&&i == 1) {
		head->next = pI;
		pI->data = item;
		pI->next = NULL;
		num++;
		return 1;
	}
	int j = 0;
	ListNode*pG = head;
	while (pG->next&&j < i - 1) {
		pG = pG->next;
		j++;
	}
	if (!pG || j > i - 1)
		return 0;
	ListNode*pU = new ListNode;
	pU->next = pG->next;
	pG->next = pU;
	pU->data = item;
	num++;
	return 1;
}
int del(ListNode*head, 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 0;
	pI = pG->next;
	pG->next = pI->next;
	delete pI;
	num--;
	return 1;
}



int main(){
	int t;
	scanf("%d",&t);
	while(t--){
		int n;
		scanf("%d",&n);
	}
	
	
}

連結串列，不用類

#include<iostream> #define ok 0 #define error -1 using namespace std; int num ; struct ListNode { int data; ListNode*next; }; void LL_displ

c++實現雙向連結串列，類模板雙向連結串列

#include<iostream> #include<assert.h> using namespace std; typedef int Datatype; typedef struct Node//連結串列是由一個個節點組成所以這裡單獨定義這一型別方便在連結串列類中使用 {

C 將一個單鏈表拆成3個迴圈連結串列，其中一個是純數字，一個純字母，一個其他字元

前面相關操作在這呢，這個函式依託於此 //結構體 typedef struct Node { ElementType data; struct Node * next; } LNode, * LinkNode; //將一個單鏈表拆成3個迴圈連結串列，其中一個是純數字

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

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

劍指offer系列（十一）二叉搜尋樹與雙向連結串列，字串的排序

二叉搜尋樹與雙向連結串列題目描述輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。解題思路：由於輸入的一個二叉搜尋樹，其左子樹小於右子樹的值，這位後面的排序做了準備，因為只需要中序遍歷即可，將所有的節點儲存

Python 資料結構與演算法——列表（連結串列，linked list）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

純c語言實現連結串列，實現連結串列增刪改查

#include <stdio.h> #include <string.h> #include <stdlib.h> struct selflist{ int num; selflist* next; }; struct selflist* hea

連結串列實現大數類階乘

連結串列實現大數階乘題目大數運算——計算n的階乘 (n≥20)。基本要求（1）資料的表示和儲存： ①累積運算的中間結果和最終的計算結果的資料型別要求是整型——這是問題本身的要求。 ②試設計合適的儲存結構，要求每個元素或結點最多儲存資料的3位數值。（2）資料的操作及其實現：基於設計的儲

合併兩個有序連結串列，合併之後仍有序

合併兩個有序連結串列，合併之後仍有序。標頭檔案引用連結串列的一些基本操作 ListNode * MergeOrderedList(ListNode *List1,ListNode *List2) { ListNode *cur1 = List1; ListNode *cur2

單鏈表，雙向連結串列，迴圈連結串列

資料結構：定義：特定的資料型別(個體)和特定的儲存結構(個體的關係) 資料如何儲存在記憶體中分類：線性結構：資料元素之間存在一對一的線性關

題目14 歸併連結串列，遞減排列。兩連結串列遞增排列，要求利用原來節點存放歸併後的單鏈表

題目14：歸併連結串列，遞減排列。兩連結串列遞增排列，要求利用原來節點存放歸併後的單鏈表 void merge_ByDesc(Node *&a, Node *&b, Node *&n){ //新連結串列遞減排列，故可以採用頭插法-假設均帶頭節點 N

UVA - 12657(雙向連結串列，左插入，右插入，交換，翻轉)

Boxes in a Line ACM彙總學習:https://blog.csdn.net/weixin_39778570/article/details/83187443 題目：https://vjudge.net/problem/UVA-12657 題目：模擬連結串列4中操作，x左插

演算法題007 -- [對給定的排好序的連結串列，刪除重複的元素，只留下出現一次的元素] by java

對給定的排好序的連結串列，刪除重複的元素，只留下出現一次的元素舉例： 1->1->2, return 1->2. 1->1->2->3->3, return 1->2->3. 程式碼 package algori

演算法題006 -- [將兩個排序的連結串列合併，返回一個新連結串列，返回的新連結串列也是排好序的] by java

題目將兩個排序的連結串列合併，返回一個新連結串列，返回的新連結串列也是排好序的程式碼 package algorithm6; public class Algorithm6 { public static void main(String[] args) {

基於連結串列的容器類bag實現

連結串列類標頭檔案： #ifndef MAIN_WTF_NODE1_H #define MAIN_WTF_NODE1_H #include <cstdlib> namespace main_wtf_5 { class node { publi

【劍指offer】輸入一個連結串列，按連結串列值從尾到頭的順序返回一個ArrayList

劍指offer第三題題目如下輸入一個連結串列，按連結串列值從尾到頭的順序返回一個ArrayList 具體程式碼實現如下：下面展示兩種程式碼實現，思想都是基於遞迴，遍歷到連結串列末尾，由低向上儲存資料。 1.相互呼叫遞迴 import java.util.Arra

洛谷P1160——佇列安排【連結串列，模擬】

一個學校里老師要將班上NN個同學排成一列，同學被編號為$1～N$，他採取如下的方法：先將11號同學安排進佇列，這時佇列中只有他一個人； 2-N2−N號同學依次入列，編號為i的同學入列方式為：老師指定編號為i的同學站在編號為1-(i -1)1−(i−1)中某位同學（即之前已經入

劍指Offer15：輸入一個連結串列，反轉連結串列後，輸出新連結串列的表頭

思路：先將當前節點數對應的下一個節點數儲存下來tmp=pHead.next，然後將上個節點數last賦值給pHead.next（初始last為None）。當前節點pHead賦值給last（成為上一個節點），最後將下一個節點tmp賦值給pHead（成為當前結點）。 # -*- c

(CSDN遷移) 輸入一個連結串列，從尾到頭列印連結串列每個節點的值

題目描述輸入一個連結串列，從尾到頭列印連結串列每個節點的值。思路1. 翻轉連結串列，使用java自帶的翻轉函式或者從頭到尾依次改變連結串列的節點指標 /** * public class ListNode { * int val; * ListNode next =

輸入一個連結串列，按連結串列值從尾到頭的順序返回一個ArrayList。php

思路：定義一個數組，將原連結串列迴圈一次封裝到陣列，運用陣列函式倒序輸出。 function printListFromTailToHead($head) { // write code here //定義一個連結串列 $lists = []; //迴圈連結串

連結串列，不用類

相關推薦