如果您对PHP实现单链表翻转操作示例和php实现单链表翻转操作示例图感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解PHP实现单链表翻转操作示例的各种细节，并对php实现单链表翻转操作示例图进行
如果您对PHP实现单链表翻转操作示例和php实现单链表翻转操作示例图感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解PHP实现单链表翻转操作示例的各种细节，并对php实现单链表翻转操作示例图进行深入的分析，此外还有关于C++ 实现单链表的 12 种基本操作、c语言实现单链表算法示例分享、Java单链表翻转实现的实例代码分享、Java实现单链表反转操作的实用技巧。
本文目录一览：
PHP实现单链表翻转操作示例（php实现单链表翻转操作示例图）
本文实例讲述了PHP实现单链表翻转操作。分享给大家供大家参考，具体如下：
当一个序列中只含有指向它的后继结点的链接时，就称该链表为单链表。
这里给出了一个单链表的定义及翻转操作方法：
<?php
/**
* @file reverseLink.php
* @author showersun
* @date 2016/03/01 10:33:25
**/
class Node{
private $value;
private $next;
public function __construct($value=null){
$this->value = $value;
}
public function getValue(){
return $this->value;
}
public function setValue($value){
$this->value = $value;
}
public function getNext(){
return $this->next;
}
public function setNext($next){
$this->next = $next;
}
}
//遍历，将当前节点的下一个节点缓存后更改当前节点指针
function reverse($head){
if($head == null){
return $head;
}
$pre = $head;//注意：对象的赋值
$cur = $head->getNext();
$next = null;
while($cur != null){
$next = $cur->getNext();
$cur->setNext($pre);
$pre = $cur;
$cur = $next;
}
//将原链表的头节点的下一个节点置为null，再将反转后的头节点赋给head
$head->setNext(null);
$head = $pre;
return $head;
}
//递归，在反转当前节点之前先反转后续节点
function reverse2($head){
if (null == $head || null == $head->getNext()) {
return $head;
}
$reversedHead = reverse2($head->getNext());
$head->getNext()->setNext($head);
$head->setNext(null);
return $reversedHead;
}
function test(){
$head = new Node(0);
$tmp = null;
$cur = null;
// 构造一个长度为10的链表，保存头节点对象head
for($i=1;$i<10;$i++){
$tmp = new Node($i);
if($i == 1){
$head->setNext($tmp);
}else{
$cur->setNext($tmp);
}
$cur = $tmp;
}
//print_r($head);exit;
$tmpHead = $head;
while($tmpHead != null){
echo $tmpHead->getValue().'' '';
$tmpHead = $tmpHead->getNext();
}
echo "\n";
//$head = reverse($head);
$head = reverse2($head);
while($head != null){
echo $head->getValue().'' '';
$head = $head->getNext();
}
}
test();
?>
运行结果：
0 1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1 0
更多关于PHP相关内容感兴趣的读者可查看本站专题：《PHP数据结构与算法教程》、《php程序设计算法总结》、《php字符串(string)用法总结》、《PHP数组(Array)操作技巧大全》、《PHP常用遍历算法与技巧总结》及《PHP数学运算技巧总结》
希望本文所述对大家PHP程序设计有所帮助。
您可能感兴趣的文章:
- php数据结构之顺序链表与链式线性表示例
- php线性表顺序存储实现代码(增删查改)
- php线性表的入栈与出栈实例分析
- PHP+MySQL统计该库中每个表的记录数并按递减顺序排列的方法
- php实现单链表的实例代码
- PHP小教程之实现链表
- 浅谈PHP链表数据结构(单链表)
- PHP小教程之实现双向链表
- PHP链表操作简单示例
- PHP环形链表实现方法示例
- php实现的顺序线性表示例
C++ 实现单链表的 12 种基本操作
C++单链表的操作
2017-12-25
1
// 单链表.cpp: 定义控制台应用程序的入口点。
2 //Author:kgvito
3 //Date: 2017.12.25
4
5
6 #include "stdafx.h"
7 #include<iostream>
8 using namespace std;
9
10 typedef int DataType;
11 #define Node ElemType
12 #define ERROR NULL
13
14 //构建一个节点类
15 class Node
16 {
17 public:
18 int data; //数据域
19 Node * next; //指针域
20 };
21
22 //构建一个单链表类
23 class LinkList
24 {
25 public:
26 LinkList(); //构建一个单链表;
27 ~LinkList(); //销毁一个单链表;
28 void CreateLinkList(int n); //创建一个单链表
29 void TravalLinkList(); //遍历线性表
30 int GetLength(); //获取线性表长度
31 bool IsEmpty(); //判断单链表是否为空
32 ElemType * Find(DataType data); //查找节点
33 void InsertElemAtEnd(DataType data); //在尾部插入指定的元素
34 void InsertElemAtIndex(DataType data,int n); //在指定位置插入指定元素
35 void InsertElemAtHead(DataType data); //在头部插入指定元素
36 void DeleteElemAtEnd(); //在尾部删除元素
37 void DeleteAll(); //删除所有数据
38 void DeleteElemAtPoint(DataType data); //删除指定的数据
39 void DeleteElemAtHead(); //在头部删除节点
40 private:
41 ElemType * head; //头结点
42 };
43
44 //初始化单链表
45 LinkList::LinkList()
46 {
47 head = new ElemType;
48 head->data = 0; //将头结点的数据域定义为0
49 head->next = NULL; //头结点的下一个定义为NULL
50 }
51
52 //销毁单链表
53 LinkList::~LinkList()
54 {
55 delete head; //删除头结点
56 }
57
58 //创建一个单链表
59 void LinkList::CreateLinkList(int n)
60 {
61 ElemType *pnew, *ptemp;
62 ptemp = head;
63 if (n < 0) { //当输入的值有误时，处理异常
64 cout << "输入的节点个数有误" << endl;
65 exit(EXIT_FAILURE);
66 }
67 for (int i = 0; i < n;i++) { //将值一个一个插入单链表中
68 pnew = new ElemType;
69 cout << "请输入第" << i + 1 << "个值: " ;
70 cin >> pnew->data;
71 pnew->next = NULL; //新节点的下一个地址为NULL
72 ptemp->next = pnew; //当前结点的下一个地址设为新节点
73 ptemp = pnew; //将当前结点设为新节点
74 }
75 }
76
77 //遍历单链表
78 void LinkList::TravalLinkList()
79 {
80 if (head == NULL || head->next ==NULL) {
81 cout << "链表为空表" << endl;
82 }
83 ElemType *p = head; //另指针指向头结点
84 while (p->next != NULL) //当指针的下一个地址不为空时，循环输出p的数据域
85 {
86 p = p->next; //p指向p的下一个地址
87 cout << p->data << " ";
88 }
89 }
90
91 //获取单链表的长度
92 int LinkList::GetLength()
93 {
94 int count = 0; //定义count计数
95 ElemType *p = head->next; //定义p指向头结点
96 while (p != NULL) //当指针的下一个地址不为空时，count+1
97 {
98 count++;
99 p = p->next; //p指向p的下一个地址
100 }
101 return count; //返回count的数据
102 }
103
104 //判断单链表是否为空
105 bool LinkList::IsEmpty()
106 {
107 if (head->next == NULL) {
108 return true;
109 }
110 return false;
111 }
112
113 //查找节点
114 ElemType * LinkList::Find(DataType data)
115 {
116 ElemType * p = head;
117 if (p == NULL) { //当为空表时，报异常
118 cout << "此链表为空链表" << endl;
119 return ERROR;
120 }
121 else
122 {
123 while (p->next != NULL) //循环每一个节点
124 {
125 if (p->data == data) {
126 return p; //返回指针域
127 }
128 p = p->next;
129 }
130 return NULL; //未查询到结果
131 }
132 }
133
134 //在尾部插入指定的元素
135 void LinkList::InsertElemAtEnd(DataType data)
136 {
137 ElemType * newNode = new ElemType; //定义一个Node结点指针newNode
138 newNode->next = NULL; //定义newNode的数据域和指针域
139 newNode->data = data;
140 ElemType * p = head; //定义指针p指向头结点
141 if (head == NULL) { //当头结点为空时，设置newNode为头结点
142 head = newNode;
143 }
144 else //循环知道最后一个节点，将newNode放置在最后
145 {
146 while (p->next != NULL)
147 {
148 p = p->next;
149 }
150 p->next = newNode;
151 }
152 }
153
154 //在指定位置插入指定元素
155 void LinkList::InsertElemAtIndex(DataType data,int n)
156 {
157 if (n<1 || n>GetLength()) //输入有误报异常
158 cout << "输入的值错误" << endl;
159 else
160 {
161 ElemType * ptemp = new ElemType; //创建一个新的节点
162 ptemp->data = data; //定义数据域
163 ElemType * p = head; //创建一个指针指向头结点
164 int i = 1;
165 while (n > i) //遍历到指定的位置
166 {
167 p = p->next;
168 i++;
169 }
170 ptemp->next = p->next; //将新节点插入到指定位置
171 p->next = ptemp;
172 }
173 }
174
175 //在头部插入指定元素
176 void LinkList::InsertElemAtHead(DataType data)
177 {
178 ElemType * newNode = new ElemType; //定义一个Node结点指针newNode
179 newNode->data = data;
180 ElemType * p = head; //定义指针p指向头结点
181 if (head == NULL) { //当头结点为空时，设置newNode为头结点
182 head = newNode;
183 }
184 newNode->next = p->next; //将新节点插入到指定位置
185 p->next = newNode;
186 }
187
188 //在尾部删除元素
189 void LinkList::DeleteElemAtEnd()
190 {
191 ElemType * p = head; //创建一个指针指向头结点
192 ElemType * ptemp = NULL; //创建一个占位节点
193 if (p->next == NULL) { //判断链表是否为空
194 cout << "单链表空" << endl;
195 }
196 else
197 {
198 while (p->next != NULL) //循环到尾部的前一个
199 {
200 ptemp = p; //将ptemp指向尾部的前一个节点
201 p = p->next; //p指向最后一个节点
202 }
203 delete p; //删除尾部节点
204 p = NULL;
205 ptemp->next = NULL;
206 }
207 }
208
209 //删除所有数据
210 void LinkList::DeleteAll()
211 {
212 ElemType * p = head->next;
213 ElemType * ptemp = new ElemType;
214 while (p != NULL) //在头结点的下一个节点逐个删除节点
215 {
216 ptemp = p;
217 p = p->next;
218 head->next = p;
219 ptemp->next = NULL;
220 delete ptemp;
221 }
222 head->next = NULL; //头结点的下一个节点指向NULL
223 }
224
225 //删除指定的数据
226 void LinkList::DeleteElemAtPoint(DataType data)
227 {
228 ElemType * ptemp = Find(data); //查找到指定数据的节点位置
229 if (ptemp == head->next) { //判断是不是头结点的下一个节点，如果是就从头部删了它
230 DeleteElemAtHead();
231 }
232 else
233 {
234 ElemType * p = head; //p指向头结点
235 while (p->next != ptemp) //p循环到指定位置的前一个节点
236 {
237 p = p->next;
238 }
239 p->next = ptemp->next; //删除指定位置的节点
240 delete ptemp;
241 ptemp = NULL;
242 }
243
244 }
245
246 //在头部删除节点
247 void LinkList::DeleteElemAtHead()
248 {
249 ElemType * p = head;
250 if (p == NULL || p->next == NULL) { //判断是否为空表，报异常
251 cout << "该链表为空表" << endl;
252 }
253 else
254 {
255 ElemType * ptemp = NULL; //创建一个占位节点
256 p = p->next;
257 ptemp = p->next; //将头结点的下下个节点指向占位节点
258 delete p; //删除头结点的下一个节点
259 p = NULL;
260 head->next = ptemp; //头结点的指针更换
261 }
262 }
263
264 //测试函数
265 int main()
266 {
267 LinkList l;
268 int i;
269 cout << "1.创建单链表 2.遍历单链表 3.获取单链表的长度 4.判断单链表是否为空 5.获取节点\n";
270 cout << "6.在尾部插入指定元素 7.在指定位置插入指定元素 8.在头部插入指定元素\n";
271 cout<<"9.在尾部删除元素 10.删除所有元素 11.删除指定元素 12.在头部删除元素 0.退出" << endl;
272 do
273 {
274 cout << "请输入要执行的操作: ";
275 cin >> i;
276 switch (i)
277 {
278 case 1:
279 int n;
280 cout << "请输入单链表的长度: ";
281 cin >> n;
282 l.CreateLinkList(n);
283 break;
284 case 2:
285 l.TravalLinkList();
286 break;
287 case 3:
288 cout << "该单链表的长度为" << l.GetLength() << endl;
289 break;
290 case 4:
291 if (l.IsEmpty() == 1)
292 cout << "该单链表是空表" << endl;
293 else
294 {
295 cout << "该单链表不是空表" << endl;
296 }
297 break;
298 case 5:
299 DataType data;
300 cout << "请输入要获取节点的值: ";
301 cin >> data;
302 cout << "该节点的值为" << l.Find(data)->data << endl;
303 break;
304 case 6:
305 DataType endData;
306 cout << "请输入要在尾部插入的值: ";
307 cin >> endData;
308 l.InsertElemAtEnd(endData);
309 break;
310 case 7:
311 DataType pointData;
312 int index;
313 cout << "请输入要插入的数据: ";
314 cin >> pointData;
315 cout << "请输入要插入数据的位置: ";
316 cin >> index;
317 l.InsertElemAtIndex(pointData, index);
318 break;
319 case 8:
320 DataType headData;
321 cout << "请输入要在头部插入的值: ";
322 cin >> headData;
323 l.InsertElemAtHead(headData);
324 break;
325 case 9:
326 l.DeleteElemAtEnd();
327 break;
328 case 10:
329 l.DeleteAll();
330 break;
331 case 11:
332 DataType pointDeleteData;
333 cout << "请输入要删除的数据: ";
334 cin >> pointDeleteData;
335 l.DeleteElemAtPoint(pointDeleteData);
336 break;
337 case 12:
338 l.DeleteElemAtHead();
339 break;
340 default:
341 break;
342 }
343 }while (i != 0);
344
345 system("pause");
346 return 0;
347 }
c语言实现单链表算法示例分享
#include <stdio.h>
#include <stdlib.h>
typedef char DataType;
typedef struct Node{
DataType data;
struct Node * Next;
}ListNode,* LinkList;
void Judement(LinkList head){ //判断分配内存
if (!head){
printf("Overflow.");
exit(-1);
}
}
LinkList CreatListF(void){ //头插法创建Single Linked List
DataType ch;
LinkList head = (ListNode*)malloc(sizeof(ListNode));
Judement(head);
ListNode* s;
ch = getchar();
while (ch != '\n'){
s = (ListNode*)malloc(sizeof(ListNode));
Judement(s);
s->data = ch;
s->Next = head->Next;
head->Next = s;
ch = getchar();
}
return head;
}
LinkList CreatListS(void){ //尾插法创建Single Linked List
char ch;
ListNode* s;
LinkList head = (ListNode*)malloc(sizeof(ListNode));
Judement(head);
ch = getchar();
while (ch != '\n'){
s = (ListNode*)malloc(sizeof(ListNode));
Judement(s);
s->data = ch;
head->Next = s;
head = s;
ch = getchar();
}
head->Next = NULL;
return head;
}
int GetLength(LinkList head){ //获取长度
int length = 0;
LinkList p = head->Next;
while (p){
length += 1;
p = p->Next;
}
return length;
}
ListNode* GetNodeById(LinkList head,int i){ //依序号查找元素
if (i<1 || i>GetLength(head)){
exit(1);
}
int j=1; //防止极端情况扫描逾界
LinkList p = head->Next;
while (p != NULL && j < i){
j += 1;
p = p->Next;
}
return p;
}
ListNode* GetNodeByValue(LinkList head,DataType e){ //依值查找元素
LinkList p = head->Next;
while (p != NULL&&p->data != e){
p = p->Next;
}
return p;
}
int InsertList(LinkList head,DataType e,int i){ //插入e值在第i节点
if (i<1 || i>GetLength(head) + 1){
exit(1);
}
LinkList s = (ListNode*)malloc(sizeof(ListNode));
s->data = e;
LinkList q,p = head;
int j = 1;
while (j <= i){
q = p;
p = p->Next;
j += 1;
}
s->Next = q->Next;
q->Next = s;
return 0;
}
int DeleteListNodeById(LinkList head,int i){ //依序号删除节点
int j = 1;
ListNode* p,* q;
if (i<1 || i>GetLength(head)){
exit(1);
}
p = head;
while (j < i){
p = p->Next;
j += 1;
}
q = p->Next;
p->Next = q->Next;
free(q);
return 0;
}
int DeleteListRepeatNode(ListNode* head){ //清除冗余数据
ListNode* p,*q,*s;
if (p == NULL){
exit(1);
}
p = head->Next; //首节点无数据
while (p->Next != NULL){
q = p;
while (q->Next != NULL){
if (q->Next->data == p->data){
s = q->Next;
q->Next = q->Next->Next;
free(s);
}
q = q->Next;
}
p = p->Next;
}
return 0;
}
您可能感兴趣的文章:
- C语言之单链表的插入、删除与查找
- C语言实现单链表逆序与逆序输出实例
- C语言单链表常见操作汇总
- C语言单链表实现多项式相加
- C语言单链表的实现
- 数据结构 C语言实现循环单链表的实例
- C语言实现学生信息管理系统（单链表）
- C语言实现单链表实现方法
- C语言单链表版学生信息管理系统
- C语言单链表实现方法详解
Java单链表翻转实现的实例代码分享
java实现单链表反转，递归和非递归两种形式。接下来通过本文给大家分享java实现单链表翻转实例代码，需要的的朋友参考下
Java实现单链表反转，递归和非递归两种形式
/**
* 反转单链表
*/
/** * 定义链表
*
* @author 16026
*
*/
class Node {
int val;
Node next;
public Node(int val) {
this.val = val;
}
}
public class ReverseList {
/**
* 反转链表
*
* @param head
* @return
*/
public static Node reverseList(Node head) {
if (head == null || head.next == null) {
return head;
}
Node reHead = null;// 定义新链表头结点
while (head != null) {
Node cur = head.next;// 记录下一个节点
head.next = reHead;// 将rehead节点连接到head节点上
reHead = head;// 让rehead指向head
head = cur;// 将head指向下一个节点
}
return reHead;
}
/**
* 递归反转链表
*
* @param head
* @return
*/
public static Node reverseList2(Node head) {
if (head == null || head.next == null)
return head;
Node rehead = reverseList2(head.next);
head.next.next = head;// 将头节点置于末端
head.next = null;// 防止链表循环
return rehead;
}
/**
* 打印链表
*
* @param head
*/
public static void printList(Node head) {
if (head == null)
return;
while (head != null) {
System.out.print(head.val + " ");
head = head.next;
}
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
Node n4 = new Node(4);
Node n5 = new Node(5);
n1.next = n2;
n2.next = n3;
n3.next = n4;
n4.next = n5;
// Node rehead = reverseList(n1);
Node rehead = reverseList2(n1);
printList(rehead);
}
}登录后复制
运行结果如下：
以上就是Java单链表翻转实现的实例代码分享的详细内容，更多请关注php中文网其它相关文章！
Java实现单链表反转操作
单链表是一种常见的数据结构，由一个个节点通过指针方式连接而成，每个节点由两部分组成：一是数据域，用于存储节点数据。二是指针域，用于存储下一个节点的地址。在Java中定义如下：
public class Node {
private Object data;//数据域
private Node next;//指针域
public Node(Object data){
this.data = data;
}
public Node(Object data,Node next){
this.data = data;
this.next = next;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
单链表的反转操作是面试java开发中常考的题目，笔者面试时曾被这道题虐过qaq，之后痛定思痛，研究了一番之后，写出来与大家分享。
先说下思路：所谓的单链表反转，就是把每个节点的指针域由原来的指向下一个节点变为指向其前一个节点。但由于单链表没有指向前一个节点的指针域，因此我们需要增加一个指向前一个节点的指针pre，用于存储每一个节点的前一个节点。此外，还需要定义一个保存当前节点的指针cur，以及下一个节点的next。定义好这三个指针后，遍历单链表，将当前节点的指针域指向前一个节点，之后将定义三个指针往后移动，直至遍历到最后一个节点停止。
OK，说完思路，直接上代码。
public static Node reverseListNode(Node head){
//单链表为空或只有一个节点，直接返回原单链表
if (head == null || head.getNext() == null){
return head;
}
//前一个节点指针
Node preNode = null;
//当前节点指针
Node curNode = head;
//下一个节点指针
Node nextNode = null;
while (curNode != null){
nextNode = curNode.getNext();//nextNode 指向下一个节点
curNode.setNext(preNode);//将当前节点next域指向前一个节点
preNode = curNode;//preNode 指针向后移动
curNode = nextNode;//curNode指针向后移动
}
return preNode;
}
---------------------
作者：WeekenLin
来源：CSDN
原文：https://blog.csdn.net/lwkrsa/article/details/82015364
版权声明：本文为博主原创文章，转载请附上博文链接！
关于PHP实现单链表翻转操作示例和php实现单链表翻转操作示例图的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于C++ 实现单链表的 12 种基本操作、c语言实现单链表算法示例分享、Java单链表翻转实现的实例代码分享、Java实现单链表反转操作的相关知识，请在本站寻找。
本文标签：
