循环链表的尾节点指向

带头节点的循环链表

千次阅读 2018-02-02 20:49:50

带头节点的循环链表，循环链表的尾节点指向头节点头文件clist.h #pragma once //带头节点的循环链表 //循环链表的尾节点指向头节点 typedef struct CNode { int data;//数据域 struct CNode *next;//指向下...

带头节点的循环链表，循环链表的尾节点指向头节点

头文件clist.h
#pragma once
//带头节点的循环链表
//循环链表的尾节点指向头节点

typedef struct CNode
{
	int data;//数据域
	struct CNode *next;//指向下一个节点的地址
}CNode,*CList;


void InitList(CList plist);

//头插
bool Insert_head(CList plist,int val);

//尾插
bool Insert_tail(CList plist,int val);

bool IsEmpty(CList plist);

bool Delete(CList plist,int key);

CNode * Search(CList plist,int key);//CList

void Show(CList plist);

void Destroy(CList plist);

void Clear(CList plist);

//获取有效数据的个数
int GetLength(CList plist);

//链表逆置
void Reverse(CList plist);
实现功能 clist.cpp 文件
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "clist.h"

//头节点的next指向自己
void InitList(CList plist)
{
	assert(plist != NULL);
	if(plist == NULL)
	{
		return;
	}

	plist->next = plist;
}

//头插
bool Insert_head(CList plist,int val)
{
	CNode *p = (CNode *)malloc(sizeof(CNode));
	p->data = val;

	p->next = plist->next;
	plist->next = p;

	return true;
}

//尾插
bool Insert_tail(CList plist,int val)
{
	CNode *p;
	for(p=plist;p->next!=plist;p=p->next) ;

	CNode *q = (CNode *)malloc(sizeof(CNode));
	q->data = val;

	//将q插入在p的后面
	q->next = p->next;//q->next = plist;
	p->next = q;

	return true;
}

bool IsEmpty(CList plist)
{
	return plist->next == plist;
}

static CNode *SearchPri(CList plist,int key)
{
	for(CNode *p=plist;p->next!=plist;p=p->next)
	{
		if(p->next->data == key)
		{
			return p;
		}
	}
	return NULL;
}

bool Delete(CList plist,int key)
{
	CNode *p = SearchPri(plist,key);
	if(p == NULL)
	{
		return false;
	}

	CNode *q = p->next;
	p->next = q->next;	
	free(q);

	return true;
}

CNode * Search(CList plist,int key)//CList
{
	for(CNode *p=plist->next;p!=plist;p=p->next)
	{
		if(p->data == key)
		{
			return p;
		}
	}

	return NULL;
}

void Show(CList plist)
{
	for(CNode *p=plist->next;p!=plist;p=p->next)
	{
		printf("%d ",p->data);
	}
	printf("\n");
}

void Destroy(CList plist)
{
	CNode *p;
	while(plist->next != plist)
	{
		p = plist->next;
		plist->next = p->next;
		free(p);
	}
}

void Clear(CList plist)
{
	Destroy(plist);
}

//获取有效数据的个数
int GetLength(CList plist)
{
	int count = 0;

	for(CNode *p=plist->next;p!=plist;p=p->next)
	{
		count++;
	}

	return count;
}

//链表逆置
void Reverse(CList plist)
{
	CNode *p = plist->next;
	CNode *q ;
	plist->next = plist;//****

	while(p != plist)
	{
		q = p->next;
		//将p利用头插的方法插入到链表中
		p->next = plist->next;
		plist->next = p;
		p = q;
	}
}


测试test.cpp文件
int main()
{
	CNode n;
	InitList(&n);
	for(int i=0;i<=10;i++)
	{
		Insert_head(&n,i);
	}
	Show(&n);
	
	Delete(&n,10);
	Show(&n);
	Reverse(&n);
	Show(&n);
}


最终运行结果：

收起

展开全文

数据结构 c 语言

C/C++实现单向循环链表(尾指针，带头尾节点)

2019-02-25 10:48:00

　单向循环链表和单向链表的区别：（1）单向链表为头指针，循环链表为尾指针，头指针指向头结点，尾指针指向终端结点；（2）为统一方便操作，单向链表设置头结点，单向循环链表设置头结点和尾结点；（3）设置尾结点...

　　C语言实现单向循环链表，主要功能为空链表创建，链表初始化（头插法，尾插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。
　　单向循环链表和单向链表的区别：（1）单向链表为头指针，循环链表为尾指针，头指针指向头结点，尾指针指向终端结点；（2）为统一方便操作，单向链表设置头结点，单向循环链表设置头结点和尾结点；（3）设置尾结点后，尾指针指向尾结点，插入，删除等操作不用移动尾指针。
　　关键思路：创建头结点和尾结点。

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 typedef struct Node{
  5     int data;
  6     struct Node *next;
  7 }Node;
  8 
  9 //空循环链表创建
 10 //创建头结点和尾结点
 11 //链表尾指针指向尾结点，尾结点指向头结点，头结点指向尾结点
 12 void iniCList(Node **CListTail){
 13     *CListTail = (Node *)malloc(sizeof(Node));
 14     Node *CListHead = (Node *)malloc(sizeof(Node));
 15     if (NULL == *CListTail || NULL == CListHead){
 16         exit(0);
 17     }
 18 
 19     (*CListTail)->next = CListHead;
 20     CListHead->next = *CListTail;
 21 }
 22 
 23 //循环链表初始化(头插法)
 24 void iniCListHead(Node **CListTail, int n){
 25     //创建头尾结点
 26     *CListTail = (Node *)malloc(sizeof(Node));
 27     Node *CListHead = (Node *)malloc(sizeof(Node));
 28     if (NULL == *CListTail || NULL == CListHead){
 29         exit(0);
 30     }
 31 
 32     (*CListTail)->next = CListHead;
 33     CListHead->next = *CListTail;
 34 
 35     int i = 0;
 36     while (i < n){
 37 
 38         Node *tmpNode = (Node *)malloc(sizeof(Node));
 39         if (NULL == tmpNode){
 40             exit(0);
 41         }
 42         tmpNode->data = i;
 43         tmpNode->next = CListHead->next;
 44         CListHead->next = tmpNode;
 45         ++i;
 46     }
 47 }
 48 
 49 //循环链表初始化(尾插法)
 50 void iniCListTail(Node **CListTail, int n){
 51     //创建头尾结点
 52     *CListTail = (Node *)malloc(sizeof(Node));
 53     Node *CListHead = (Node *)malloc(sizeof(Node));
 54     if (NULL == *CListTail || NULL == CListHead){
 55         exit(0);
 56     }
 57 
 58     (*CListTail)->next = CListHead;
 59     CListHead->next = *CListTail;
 60 
 61     Node *pCurrent = CListHead;
 62 
 63     int i = 0; 
 64     while (i < n){
 65         Node *tmpNode = (Node *)malloc(sizeof(Node));
 66         if (NULL == tmpNode){
 67             exit(0);
 68         }
 69         tmpNode->data = i;
 70         tmpNode->next = *CListTail;
 71         pCurrent->next = tmpNode;
 72         pCurrent = tmpNode;
 73 
 74         ++i;
 75     }
 76 }
 77 
 78 //循环链表按位置插入
 79 void insertCListPos(Node *CList, int pos, int val){
 80 
 81     Node *pCurrent = CList->next; //指向头结点
 82     int i = 1;
 83     while (pCurrent != CList && i < pos){
 84         pCurrent = pCurrent->next;
 85         ++i;
 86     }
 87 
 88     Node *tmpNode = (Node *)malloc(sizeof(Node));
 89     if (NULL == tmpNode){
 90         exit(0);
 91     }
 92     tmpNode->data = val;
 93     tmpNode->next = pCurrent->next;
 94     pCurrent->next = tmpNode;
 95 
 96 }
 97 
 98 //有序循环链表，按值插入
 99 void insertCListValue(Node *CList, int val){
100     Node *pCur = CList->next->next;
101     Node *pPer = CList->next;
102 
103     while (pCur != CList && pCur->data < val){
104         pPer = pCur;
105         pCur = pCur->next;
106     }
107 
108     Node *tmpNode = (Node *)malloc(sizeof(Node));
109     if (NULL == tmpNode){
110         exit(0);
111     }
112     tmpNode->data = val;
113     tmpNode->next = pPer->next;
114     pPer->next = tmpNode;
115 }
116 
117 //循环链表，按位置删除
118 void deleteCListPos(Node *CList, int pos){
119     Node *pCur = CList->next;
120     
121     int i = 1;
122     while (pCur != CList && i < pos){
123         pCur = pCur->next;
124         ++i;
125     }
126 
127     Node *tmpNode = pCur->next;
128     pCur->next = tmpNode->next;
129     free(tmpNode);
130 }
131 
132 //循环链表，按值删除
133 //删除空链表为出问题
134 void deleteCListValue(Node *CList, int val){
135     Node *pCur = CList->next->next;
136     Node *pPer = CList->next;
137 
138     while (pCur != CList && pCur->data != val){
139         pPer = pCur;
140         pCur = pCur->next;
141     }
142     if (pCur == CList)
143         return;
144     else{
145         pPer->next = pCur->next;
146         free(pCur);
147     }
148 }
149 
150 //循环链表，清空链表
151 void claerCList(Node *CList){
152     Node *p = CList->next->next;
153     Node *q = NULL;
154 
155     while (p != CList){ //到达表尾
156         q = p->next;
157         free(p);
158         p = q;
159     }
160 
161     CList->next = CList; //将头结点指向尾结点
162 }
163 
164 //循环链表，销毁链表
165 void destoryCList(Node **CList){
166     Node *p = (*CList)->next;
167     Node *q = NULL;
168 
169     while (p != (*CList)->next){ //到达表头
170         q = p->next;
171         free(p);
172         p = q;
173     }
174 
175     *CList = NULL;
176 }
177 
178 //获取元素
179 void getCList(Node *CList, int pos, int *val){
180     Node *pCur = CList->next->next;
181     int i = 1;
182     while (pCur != CList && i < pos){
183         pCur = pCur->next;
184         ++i;
185     }
186 
187     *val = pCur->data;
188 }
189 //遍历输出元素
190 void printCList(Node *CList){
191     Node * tmpNode = CList->next->next;
192     while (tmpNode != CList){ //到达表尾
193         printf("%d\n", tmpNode->data);
194         tmpNode = tmpNode->next;
195     }
196 }
197 
198 
199 int main(){
200     Node *CList = NULL;
201     //iniCListHead(&CList, 8);
202     //iniCList(&CList);
203     iniCListTail(&CList, 8);
204 
205     //insertCListPos(CList, 1, 2);
206     //insertCListPos(CList, 2, 4);
207     //insertCListPos(CList, 3, 6);
208     //
209     //insertCListValue(CList, 1);
210     //
211     //deleteCListPos(CList, 3);
212     //
213     //deleteCListValue(CList, 6);
214 
215     //claerCList(CList);
216 
217     int a = 0;
218     getCList(CList, 2, &a);
219     printf("%d\n", a);
220 
221     printCList(CList);
222 
223     printf("%d\n", CList);
224     destoryCList(&CList);
225     printf("%d\n", CList);
226 
227     system("pause");
228     return 0;
229 }

C语言完整代码
　　通过C++实现C语言的链表，主要区别：（1）struct可以不通过typedef，直接使用Node；（2）将malloc和free更换为new和delete

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 struct Node{
  5     int data;
  6     struct Node *next;
  7 };
  8 
  9 //空循环链表创建
 10 //创建头结点和尾结点
 11 //链表尾指针指向尾结点，尾结点指向头结点，头结点指向尾结点
 12 void iniCList(Node **CListTail){
 13     *CListTail = new Node;
 14     Node *CListHead = new Node;
 15 
 16     (*CListTail)->next = CListHead;
 17     CListHead->next = *CListTail;
 18 }
 19 
 20 //循环链表初始化(头插法)
 21 void iniCListHead(Node **CListTail, int n){
 22     //创建头尾结点
 23     *CListTail = new Node;
 24     Node *CListHead = new Node;
 25 
 26     (*CListTail)->next = CListHead;
 27     CListHead->next = *CListTail;
 28 
 29     int i = 0;
 30     while (i < n){
 31         Node *tmpNode = new Node;
 32 
 33         tmpNode->data = i;
 34         tmpNode->next = CListHead->next;
 35         CListHead->next = tmpNode;
 36         ++i;
 37     }
 38 }
 39 
 40 //循环链表初始化(尾插法)
 41 void iniCListTail(Node **CListTail, int n){
 42     //创建头尾结点
 43     *CListTail = new Node;
 44     Node *CListHead = new Node;
 45 
 46     (*CListTail)->next = CListHead;
 47     CListHead->next = *CListTail;
 48 
 49     Node *pCurrent = CListHead;
 50 
 51     int i = 0;
 52     while (i < n){
 53         Node *tmpNode = new Node;
 54 
 55         tmpNode->data = i;
 56         tmpNode->next = *CListTail;
 57         pCurrent->next = tmpNode;
 58         pCurrent = tmpNode;
 59 
 60         ++i;
 61     }
 62 }
 63 
 64 //循环链表按位置插入
 65 void insertCListPos(Node *CList, int pos, int val){
 66 
 67     Node *pCurrent = CList->next; //指向头结点
 68     int i = 1;
 69     while (pCurrent != CList && i < pos){
 70         pCurrent = pCurrent->next;
 71         ++i;
 72     }
 73 
 74     Node *tmpNode = new Node;
 75 
 76     tmpNode->data = val;
 77     tmpNode->next = pCurrent->next;
 78     pCurrent->next = tmpNode;
 79 
 80 }
 81 
 82 //有序循环链表，按值插入
 83 void insertCListValue(Node *CList, int val){
 84     Node *pCur = CList->next->next;
 85     Node *pPer = CList->next;
 86 
 87     while (pCur != CList && pCur->data < val){
 88         pPer = pCur;
 89         pCur = pCur->next;
 90     }
 91 
 92     Node *tmpNode = new Node;
 93 
 94     tmpNode->data = val;
 95     tmpNode->next = pPer->next;
 96     pPer->next = tmpNode;
 97 }
 98 
 99 //循环链表，按位置删除
100 void deleteCListPos(Node *CList, int pos){
101     Node *pCur = CList->next;
102 
103     int i = 1;
104     while (pCur != CList && i < pos){
105         pCur = pCur->next;
106         ++i;
107     }
108 
109     Node *tmpNode = pCur->next;
110     pCur->next = tmpNode->next;
111     delete tmpNode;
112 }
113 
114 //循环链表，按值删除
115 //删除空链表为出问题
116 void deleteCListValue(Node *CList, int val){
117     Node *pCur = CList->next->next;
118     Node *pPer = CList->next;
119 
120     while (pCur != CList && pCur->data != val){
121         pPer = pCur;
122         pCur = pCur->next;
123     }
124     if (pCur == CList)
125         return;
126     else{
127         pPer->next = pCur->next;
128         delete pCur;
129     }
130 }
131 
132 //循环链表，清空链表
133 void claerCList(Node *CList){
134     Node *p = CList->next->next;
135     Node *q = NULL;
136 
137     while (p != CList){ //到达表尾
138         q = p->next;
139         delete p;
140         p = q;
141     }
142 
143     CList->next = CList; //将头结点指向尾结点
144 }
145 
146 //循环链表，销毁链表
147 void destoryCList(Node **CList){
148     Node *p = (*CList)->next;
149     Node *q = NULL;
150 
151     while (p != (*CList)->next){ //到达表头
152         q = p->next;
153         delete p;
154         p = q;
155     }
156 
157     *CList = NULL;
158 }
159 
160 //获取元素
161 void getCList(Node *CList, int pos, int *val){
162     Node *pCur = CList->next->next;
163     int i = 1;
164     while (pCur != CList && i < pos){
165         pCur = pCur->next;
166         ++i;
167     }
168 
169     *val = pCur->data;
170 }
171 //遍历输出元素
172 void printCList(Node *CList){
173     Node * tmpNode = CList->next->next;
174     while (tmpNode != CList){ //到达表尾
175         printf("%d\n", tmpNode->data);
176         tmpNode = tmpNode->next;
177     }
178 }
179 
180 
181 int main(){
182     Node *CList = NULL;
183     //iniCListHead(&CList, 8);
184     //iniCList(&CList);
185     iniCListTail(&CList, 8);
186 
187     //insertCListPos(CList, 1, 2);
188     //insertCListPos(CList, 2, 4);
189     //insertCListPos(CList, 3, 6);
190     //
191     //insertCListValue(CList, 1);
192     //
193     //deleteCListPos(CList, 3);
194     //
195     //deleteCListValue(CList, 6);
196 
197     //claerCList(CList);
198 
199     int a = 0;
200     getCList(CList, 2, &a);
201     printf("%d\n", a);
202 
203     printCList(CList);
204 
205     printf("%d\n", CList);
206     destoryCList(&CList);
207     printf("%d\n", CList);
208 
209     system("pause");
210     return 0;
211 }

C++完整代码
单向循环链表

 　　注意：（1）单向循环链表销毁时，需要将头结点和尾结点删除；（2）单向循环链表插入，删除，遍历，清空链表时，条件从头结点或第一节点始，判断指针是否达到尾结点；（3）清空链表时，最后将头结点指向尾结点；（4）销毁链表时，条件从头结点始，判断条件为指针是否到达头结点，最后将指针置空。
转载于:https://www.cnblogs.com/qinguoyi/p/10429632.html

收起

展开全文

单向循环链表和双向循环链表的结构分析

2020-10-23 15:50:18

如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。单向循环链表 –多个节点和只有一个节点的结构分析双向循环链表：双向...

一、单向循环链表

单向循环链表：

如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。

单向循环链表 –多个节点

单向循环链表 – 只有1个节点


对于和我们之前学的单向链表相比，单向循环链表的区别在于其尾节点指向链表的首节点，我们在单链表（Linked List）的clear、add、remove、indexOf以及toString方法的底层封装的博客上面可以改动的也无非就是添加和删除的操作。
（一）单向循环链表 — add(int index, E element)
@Override
public void add(int index, E element) {
	rangeCheckForAdd(index);
	
	if (index == 0) {
		//先不要修改first，因为要是修改了；再找最后一个节点的时候会发生变化
		Node<E> newFirst = new Node<>(element, first);
		// 拿到最后一个节点
		Node<E> last = (size == 0) ? newFirst : node(size - 1);
		last.next = newFirst;
		first = newFirst;
	} else {
		Node<E> prev = node(index - 1);
		prev.next = new Node<>(element, prev.next);
	}
	size++;
}

（二）单向循环链表 — remove(int index)
@Override
public E remove(int index) {
	rangeCheck(index);
	
	Node<E> node = first;
	if (index == 0) {
		if (size == 1) {
			first = null;
		} else {
			//先拿到最后一个节点
			Node<E> last = node(size - 1);
			//再改变first节点
			first = first.next;
			last.next = first;
		}
	} else {
		Node<E> prev = node(index - 1);
		node = prev.next;
		prev.next = node.next;
	}
	size--;
	return node.element;
}

（三）单向循环链表 — node中的toString方法
private static class Node<E> {
	E element;
	Node<E> next;
	public Node(E element, Node<E> next) {
		this.element = element;
		this.next = next;
	}
	
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(element).append("_").append(next.element);
		return sb.toString();
	}
}

（四）测试
import com.mj.circle.SingleCircleLinkedList;
public class Main {
	static void testList(List<Integer> list) {
		list.add(11);
		list.add(22);
		list.add(33);
		list.add(44);

		list.add(0, 55); // [55, 11, 22, 33, 44]
		list.add(2, 66); // [55, 11, 66, 22, 33, 44]
		list.add(list.size(), 77); // [55, 11, 66, 22, 33, 44, 77]

		list.remove(0); // [11, 66, 22, 33, 44, 77]
		list.remove(2); // [11, 66, 33, 44, 77]
		list.remove(list.size() - 1); // [11, 66, 33, 44]		
		System.out.println(list);
	}
	public static void main(String[] args) {
		 testList(new SingleCircleLinkedList<>());	
	}
}
运行结果：
size=4, [11_66, 66_33, 33_44, 44_11]

二、双向循环链表
双向循环链表 –多个节点

双向循环链表 – 只有1个节点


双向循环链表：双（向）链表中有两条方向不同的链，即每个结点中除next域存放后继结点地址外，还增加一个指向其直接前趋的指针域prior。

（一）单向循环链表 — add(int index, E element)
@Override
public void add(int index, E element) {
	rangeCheckForAdd(index);

	// size == 0
	// index == 0
	if (index == size) { // 往最后面添加元素
		Node<E> oldLast = last;
		last = new Node<>(oldLast, element, first);
		if (oldLast == null) { // 这是链表添加的第一个元素
			first = last;
			first.next = first;
			first.prev = first;
		} else {
			oldLast.next = last;
			first.prev = last;
		}
	} else {
		Node<E> next = node(index); 
		Node<E> prev = next.prev; 
		Node<E> node = new Node<>(prev, element, next);
		next.prev = node;
		prev.next = node;
		
		if (next == first) { // index == 0
			first = node;
		}
	}
	
	size++;
}

（二）单向循环链表 — remove(int index)
@Override
public E remove(int index) {
	rangeCheck(index);
	return remove(node(index));
}

private E remove(Node<E> node) {
	if (size == 1) {
		first = null;
		last = null;
	} else {
		Node<E> prev = node.prev;
		Node<E> next = node.next;
		prev.next = next;
		next.prev = prev;
		
		if (node == first) { // index == 0
			first = next;
		}
		
		if (node == last) { // index == size - 1
			last = prev;
		}
	}
	
	size--;
	return node.element;
}

（三）单向循环链表 — node中的toString方法
private static class Node<E> {
E element;
	Node<E> prev;
	Node<E> next;
	public Node(Node<E> prev, E element, Node<E> next) {
		this.prev = prev;
		this.element = element;
		this.next = next;
	}
	
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		
		if (prev != null) {
			sb.append(prev.element);
		} else {
			sb.append("null");
		}
		
		sb.append("_").append(element).append("_");

		if (next != null) {
			sb.append(next.element);
		} else {
			sb.append("null");
		}
		
		return sb.toString();
	}
}

（四）测试
import com.mj.circle.CircleLinkedList;
public class Main {
	static void testList(List<Integer> list) {
		list.add(11);
		list.add(22);
		list.add(33);
		list.add(44);

		list.add(0, 55); // [55, 11, 22, 33, 44]
		list.add(2, 66); // [55, 11, 66, 22, 33, 44]
		list.add(list.size(), 77); // [55, 11, 66, 22, 33, 44, 77]

		list.remove(0); // [11, 66, 22, 33, 44, 77]
		list.remove(2); // [11, 66, 33, 44, 77]
		list.remove(list.size() - 1); // [11, 66, 33, 44]
		
		System.out.println(list);
	}

	public static void main(String[] args) {
		 testList(new CircleLinkedList<>());
	}
}
运行结果：
size=4, [44_11_66, 11_66_33, 66_33_44, 33_44_11]

收起

展开全文

链表数据结构

出现重复循环打印前两个节点的现象，找了很多的原因，最后发现将原链表的节点放到反向链表中的时候，...

2020-07-03 16:35:33

将单向链表进行的反转的过程中，出现重复循环打印前两个节点的现象，找了很多的原因... 链表的每个节点不是独立的个体，要注意链表的尾节点的指向，否则就会形成局部环状链表。将最后的一个节点指向空，代码为 tem...

将单向链表进行的反转的过程中，出现重复循环打印前两个节点的现象，找了很多的原因，最后发现将原链表的节点放到反向链表中的时候，在最后一个节点中忘记将next指向空，导致方向链表中的最后一个节点与倒数第二个节点直接相互为next的指向节点，出现了循环调用的情况。 链表的每个节点不是独立的个体，要注意链表的尾节点的指向，否则就会形成局部环状链表。         
 将最后的一个节点指向空，
代码为 temp1.next=null;//加上这一句，代码就可以将最后一个节点的next指针指向null，这样就可以避免出现相互为下一个节点的现象，从而防止最后两个节点被重复的打印。
package linked_list;
public class Reserve
{
public static HeroNodereserveHeroNode=new HeroNode(0,null,null);//定义一个新的链表的头结点
    public static HeroNodereserve(HeroNode headNode)//提供需要反转的链表的头结点
    {
int num=0;
        int i=0;
        HeroNode temp=headNode;//定义原链表的临时指针变量
        HeroNode temp1=reserveHeroNode;//定义新链表的新指针变量
        if(headNode.next==null)//检测给定的链表是否为空
        {
System.out.println("链表是空的");
return null;
        }
while(true)
{
if(temp.next==null)//遍历给定的链表，给出节点的个数，以便于后面的程序将节点找出来。
            {
break;
            }
num++;
            temp=temp.next;
        }
temp=headNode;//将temp指针复位到链表的头部。
        while(true)
{
if(num==0)//将反转的链表打印出来
            {
                temp1.next=null;
                temp1=reserveHeroNode;
                System.out.println("链表已经反转完成");
                while(true)
{
if(temp1.next==null)
{
return reserveHeroNode;
                    }
temp1=temp1.next;
                   System.out.println(temp1);
                }
}
if(i==num)//将链表进行翻转
            {
//                if(num==0)
//                {
//                    System.out.println(temp1.next.next);
//                    temp1.next.next=null;
//
//                }
                temp1.next=temp;
                temp1=temp1.next;//将链表的节点进行重新排序。
                System.out.println(temp1);
                num--;
                i=0;
                temp=headNode;
            }
temp=temp.next;
            i++;
        }
}
}

收起

展开全文

指针 java 数据结构算法

数据结构学习之带有头节点的循环链表
2019-05-10 23:30:35
#pragma once ...//循环链表尾节点的next指向头节点 //Clist为一条链表，CNode *一个节点的地址 typedef struct CNode { int data; //数据 struct CNode *next; //下一个节点的地址 }CNode,*CList; //CL...
收起
链表的头结点和尾节点的用处
万次阅读 2016-07-13 21:15:48
尾指针是指向终端结点的指针，用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便，设一带头结点的单循环链表，其尾指针为rear，则开始结点和终端结点的位置分别是rear->next->next 和 rear, 查找...
收起
单循环链表
2014-07-02 18:40:23
单循环链表是尾节点指针指向头结点的
收起
数据结构单链表
循环链表的操作详解
千次阅读 2017-09-13 12:10:48
一、概述 循环链表：循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。从上图看出循环链表有两个成员...//循环链表,尾节点的next指向头 typedef struct C
收起
链表（三）单向循环链表与双向循环链表
2021-02-18 21:48:07
观察单向链表和单向循环链表的区别：显然，循环链表和普通链表的区别在于，尾节点的next指针指向了头节点。而对于这条指向的维护也只在于add和remove方法，因此循环链表仅仅在这个方法上有所不同。（普通链表的...
收起
java 数据结构
双向链表和循环链表的区别
2020-11-14 11:01:03
双向链表： 1、为了方便编程，以及节点的插入删除...1、循环链表没有尾指针，必须将最后的一个节点的后指针指向头节点 2、循环链表在访问元素时，可以从任何一个结点开始，但是只能顺序向后访问节点元素 3、循环链表在
收起
数据结构指针
循环链表
2017-09-18 22:20:19
循环链表：循环链表的尾结点指向的是头节点的地址，如图：那么我们需要注意的是：与单链表的不同，单链表的结点最后一个节点指向的是NULL；基本的插入，删除，毁坏，清除函数只是在遍历的时候不一样。如果只是...
收起
单链表遍历
用OC实现双向链表：构造链表、插入节点、删除节点、遍历节点
2019-09-28 00:16:23
双向链表：每一个节点前后指针域都和它的上一个节点互相指向，尾节点的next指向空，首节点的pre指向空。二、使用注：跟单链表差不多，简单写常用的。循环链表无法形象化打印，后面也暂不实现了，但是要注意循环...
收起
单向循环链表
2019-09-20 12:32:38
我们之前定义了链表，所谓的循环链表就是在原先链表的基础上加以改动，让他进行循环执行，这样就成了循环链表，之前链表的尾指针（rear）的下一个指向的是null，而循环链表最后的尾指针的下一个指向头。注意我们...
收起
双向循环链表的实现
2020-12-17 21:44:36
将双向链表的尾节点的后继指针指向链表的头结点，头结点的前驱指针指向尾节点，就构成了双向循环链表。 C语言实现定义数据类型、节点和链表结构体 #include <stdio.h> #include <stdlib.h> typedef
收起
无头节点，删除已知节点的前驱（循环链表）
2012-10-13 22:01:28
此代码是在不通过头接点的情况下删除已知节点的前驱，就需要用到循环链表，而循环链表就需要用尾指针指向头节点，即当指向NULL时改为指向head 图：代码： #include #include #include typedef struct ...
收起
list struct delete null
链表找头节点并判断链表环状，以及节点不在链表内等异常情况
2020-11-11 08:00:29
寻找链表的头节点，每个节点，有 id 和 nextId 两个属性，nextId 表示指向节点 id。现在请实现一个办法寻找该链表的头节点。 PS. 考虑一下链表环状，以及节点不在链表内等异常情况，出现异常时，打印异常消息即可。 ...
收起
算法
循环链表遍历的猫腻
千次阅读 2019-03-08 16:44:27
循环链表的结构和单链表结构一样，只是单链表的尾结点的next指针指向null，循环链表的尾结点的next指针指向头节点，仅此而已。图示：循环链表的其它操作同单链表，但对于遍历循环链表就有一些小技巧了。循环...
收起
循环链表的Go语言实现
2017-11-10 23:23:08
循环链表的节点形成一个圈。把单链表的尾巴指向开头形成单循环链表。把双向链表的尾巴与开头链接起来就形成双向循环链表。使用循环链表可以不断的绕圈寻找所需要的数据，而不需要像单链表那样每次都从开头开始寻找，...
收起
线性表——循环链表
2018-09-22 13:23:59
循环链表的简介循环链表本质上和单链表并没有什么不同，准确的说循环链表就是特殊的单链表。单链表：除了头结点和尾...从图中我们可以看到循环链表的尾节点直接指向了头结点，所以创建循环链表遵循此规律即可...
收起
数据结构7-双向循环链表
2019-06-05 09:54:04
之前已经实现了单向循环链表，双向循环链表的...同样，为了防止循环引用，尾节点指向头节点要用弱引用。双向循环链表的节点 #import <Foundation/Foundation.h> NS_ASSUME_NONNULL_BEGIN @interface JKRL...
收起
两个单循环链表的连接
千次阅读 2017-09-25 09:01:06
小甲鱼视屏线性表14将链表A的尾指针指向链表B的第一个节点（不是头结点哦），再将链表B的尾节点指向链表A的头结点，最后释放B的头结点，因为一个链表只需要一个头结点就好了。 typedef struct node{ /**结构体定义...
收起
第三节 循环链表的Go语言实现
2018-09-22 21:21:00
循环链表的节点形成一个圈。把单链表的尾巴指向开头形成单循环链表。把双向链表的尾巴与开头链接起来就形成双向循环链表。使用循环链表可以不断的绕圈寻找所需要的数据，而不需要像单链表那样每次都从开头开始寻找，...
收起
带头节点循环链表实现队列
2020-04-15 00:19:41
队列的特征就是“先入先出”，入队时在链表的尾部插入数据，出队时删除掉头节点后面的节点，需要一个尾指针，始终指向链表的尾部（新加进来的节点）。具体请看原理图：代码实现 #include <stdio.h> #include...
收起
18-循环链表
2018-06-09 19:52:05
在循环链表中，表中最后一个节点的指针域不再为空，而是指向链表头节点，整个链表形成一个环。带头节点的循环单链表和循环双链表：图1-循环链表 循环单链表：尾节点的next指针域不再为空，而是...
收起
5循环链表仿真链表以及循环链表应用
2019-04-09 22:52:17
而是指向整个链表的第一个结点，从而使单链表形成一个环。和单链表相比，循环单链表的长处是从链尾到链头比较方便。当要处理的数据元素序列具有环型结构特点时，适合于采用循环单链表和单链表相同，循环...
收起
单向循环链表,双向循环链表,仿真链表
2020-06-27 17:26:44
单向循环聊表是单链表的另一种形式，其结构特点是链表中最后一个结点的指针不再是结束标记，而是指向整个链表的第一个结点，从而使单链表形成一个环。和单链表相比，循环单链表的长处使从链尾到链头比较方便。当要...
收起

带头节点的循环链表

C/C++实现单向循环链表(尾指针，带头尾节点)

单向循环链表和双向循环链表的结构分析

一、单向循环链表

单向循环链表 –多个节点

单向循环链表 – 只有1个节点

（一）单向循环链表 — add(int index, E element)

（二）单向循环链表 — remove(int index)

（三）单向循环链表 — node中的toString方法

（四）测试

二、双向循环链表

双向循环链表 –多个节点

双向循环链表 – 只有1个节点

（一）单向循环链表 — add(int index, E element)

（二）单向循环链表 — remove(int index)

（三）单向循环链表 — node中的toString方法

（四）测试

出现重复循环打印前两个节点的现象，找了很多的原因，最后发现将原链表的节点放到反向链表中的时候，...

数据结构学习之 带有头节点的循环链表

链表的头结点和尾节点的用处

单循环链表

循环链表的操作详解

链表（三）单向循环链表与双向循环链表

双向链表和循环链表的区别

循环链表

用OC实现双向链表：构造链表、插入节点、删除节点、遍历节点

单向循环链表

双向循环链表的实现

无头节点，删除已知节点的前驱（循环链表）

链表找头节点并判断链表环状，以及节点不在链表内等异常情况

循环链表遍历的猫腻

循环链表的Go语言实现

线性表——循环链表

数据结构7-双向循环链表

两个单循环链表的连接

第三节 循环链表的Go语言实现

带头节点循环链表实现队列

18-循环链表

5循环链表仿真链表以及循环链表应用

单向循环链表,双向循环链表,仿真链表

循环链表的尾节点指向

数据结构学习之带有头节点的循环链表

第三节循环链表的Go语言实现