精华内容
下载资源
问答
  • 单循环链表

    2017-01-02 15:51:26
    单循环链表
  • JAVA单循环链表和双循环链表简单操作1、删除单循环链表某结点的直接前驱点2、三个循环链表储存一个循环链表的不同类字符3、 1、删除单循环链表某结点的直接前驱点 问题描述:假设在长度大于 1 的单循环链表中,既...

    1、删除单循环链表某结点的直接前驱点

    问题描述:假设在长度大于 1 的单循环链表中,既无头结点也无头指针。s 为指向某 个结点的指针,试编写算法删除结点*s 的直接前驱结点。

    这里考虑的是:既然是删除某个节点的直接前驱,举个例子:假设现在我们有编号为 1 2 3 4 5 的5 个结点,现在我们要删除结点3的直接前驱结点,也就是2,那么只需要让结点 1 的next指向3就可以了,直接越过2,这样就实现了。
    不过这里有一个问题,就是如果说输入 2,那么我们要删除1,也就是让5的next指向2,这时候会出错,我们需要加一个判定为表尾时的特殊情况

    如果当前节点的下一个结点的下一个结点是我们输入的结点,那么就让当前结点的next指向下一个结点的下一个结点(这里要考虑一下当前结点是不是表尾的结点)

    public void Delete(char e ){//删除某结点直接前驱结点的方法
        Node_lp current=this.header;
       // Node_lp p=this.header;
        for (int i = 0; i < size; i++) {//   O(n)    
            if (current.next.next.getData()==e) {//如果当前节点的下一个结点的下一个结点是我们输入的结点
                if(tail.equals(current)){//如果当前结点是尾结点,那么让当前结点的指向下一个结点的下一个结点
                    current.setNext(current.next.next);
                    header=current.next;//然后此时需要修改header为当前结点的下一个结点,否则header仍然是原来的头节点
                    size--;
                    break;
                }
                current.setNext(current.next.next);//非特殊情况,同上
    
                size--;
                break;
            }
            current = current.next;
        }
        System.out.println("删除后的链表:"+this);
    }

    2、三个循环链表储存一个循环链表的不同类字符

    问题描述:已知由单链表表示的线性表中,含有三类字符的数据元素(如:字母、 数字和其它字符),设计算法构造三个以循环链表示的线性表,使每一个表中只 含同一类的字符,且利用原表中的结点空间作为这三个表的空间。(头结点可以 另辟空间)
    (实际上这里我偷懒了,没用原空间)
    (实际上这里我偷懒了,没用原空间)
    (实际上这里我偷懒了,没用原空间)

    public void divi_3(){
        Node current=header;
        Loop_list a1=new Loop_list();
        Loop_list a2=new Loop_list();
        Loop_list a3=new Loop_list();
    
        while(current!=null){//O(n)
            if((current.getData()>='A' && current.getData()<='Z')||(current.getData()>='a' && current.getData()<='z')){
                a1.add(current.data);
            }
           else if(current.getData()>='0' && current.getData()<='9'){
               a2.add(current.data);
            }
            else{
                a3.add(current.data);
            }
            current=current.next;
        }
        System.out.println("字母:"+a1);
        System.out.println("数字:"+a2);
        System.out.println("符号:"+a3);
    }

    3、有一双链表,每个结点中除有 prior、data 和 next 域外,还有一访问频度 域freq,在链表被启用前,其值均初始化为零。每当在链表上进行一次LOCATE(L,x) 运算,元素值为 x 的结点中 freq 域的值增 1,并使此链表中结点保持按 freq 递减 的顺序排列,以便使频繁访问的结点总是靠近表头。设计满足上述要求的LOCATE 算法。(问题描述是c/c++版的,使用JAVA写这段代码的时候是不需要传递LOCATE里面的L的,因为此时L是链表本身,L实际上就是this)

    //这个链表在建立的时候是有头结点的,头节点里什么都没有存
    public void LOCATE(char x){//O(n+m)
       Node current=header.next;//操作的开始先略过空的头结点
       int k;
    while (current!=null&&current.data!=x)//找到这个输入的x之前一直往下走
    {
        current=current.next;
    }
        Node tem=header.next;//让临时结点为第一个保存数据的结点
        current.freq++;//当前结点值域+1
        while(tem.freq>=current.freq){//让临时结点从头开始找,找到值域大于等于当前结点的那个结点
            tem=tem.next;//让它向下走=移动一个
        }
        current.prior.next=current.next;//先将当前结点的前一个结点的next指向当前结点的后一个结点
        current.next.prior=current.prior;//再将当前结点的后一个结点的prior指向当前节点的前一个结点
        				    //此时当前结点只有piror和next连接它的前一个结点和后一个结点了
        				    //但是它的前一个结点和后一个结点都不指向它了,我们可以认为已经把它从链表上“卸”下来了
        				    
        current.prior=tem.prior;//此时再将当前结点的prior指向临时结点的前一个结点
        current.next=tem;//再让当前结点的next指向临时结点
        tem.prior.next=current;//然后让临时结点前一个结点的next指向当前结点,
        tem.prior=current;//再把临时结点的prior指向当前结点,这样就把current又挂到链表上了
    
    }

    我们可以参考下面的图,可以以结点3为例画一下图(图中的结点1是不保存数据的,实际上未参与操作)

    想看完整代码可以私信我(虽然写得很辣鸡)(我的图好像挂了 发不上来 有点可惜)
    在这里插入图片描述

    展开全文
  • 设计单循环链表

    2021-04-13 22:47:08
    设计单循环链表 ** (1)实验目的:掌握线性表的链式存储结构;掌握单循环链表及其基本操作的实现。 (2)主要内容:实现单循环链表的初始化、求数据元素个数、插入、删除、取数据元素等操作;用插入法建立带头结点的...

    **

    设计单循环链表

    **


    (1)实验目的:掌握线性表的链式存储结构;掌握单循环链表及其基本操作的实现。
    (2)主要内容:实现单循环链表的初始化、求数据元素个数、插入、删除、取数据元素等操作;用插入法建立带头结点的单循环链表;设计一个测试主函数验证所设计单循环链表的正确性。

    在这里插入图片描述

    本文为博主原创文章,未经博主允许不得转载。
    版权为陈博超所有,第一次于2021年04月13日发表于BLOG上
    本BLOG上原创文章未经本人许可,不得用于商业用途。转载请经允许后注明出处,否则保留追究法律责任的权利。
    *

    #include<stdio.h>
    #include<malloc.h>
    typedef int DataType;
    
    typedef struct Node
    {
    	DataType Data;
    	struct Node* next;
    }SLNode;
    
    //(1)初始化
    void ListInitiate(SLNode** head)
    {
    	*head = (SLNode*)malloc(sizeof(SLNode));
    	(*head)->next = *head;
    }
    
    //(2)求当前数据元素个数
    int ListLength(SLNode* head)
    {
    	SLNode* p = head;			//p指向头节点
    	int size = 0;
    
    	while (p->next != head)
    	{
    		p = p->next;
    		size++;
    	}
    	return size;
    }
    
    //(3)插入数据元素
    int ListInsert(SLNode* head, int i, DataType x)
    {
    	SLNode* p, * q;
    	int j;
    	p = head;
    	j = -1;
    	while (p->next != head && j < i - 1)
    	{
    		p = p->next;
    		j++;
    	}
    
    	if (j != i - 1)
    	{
    		printf("插入数据元素位置错误!");
    		return 0;
    	}
    
    	q = (SLNode*)malloc(sizeof(SLNode));	//生成新结点
    	q->Data = x;							//新节点数据域赋值
    
    	q->next = p->next;						//步骤一
    	p->next = q;							//步骤二
    	return 1;
    }
    
    //(4)删除数据元素
    int ListDelete(SLNode* head, int i, DataType* x)
    {
    	SLNode* p, * s;
    	int j;
    	j = -1;
    	p = head;
    	while (p->next != head && p->next->next != head && j < i - 1)
    	{
    		p = p->next;
    		j++;
    	}
    	if (j != i - 1)
    	{
    		printf("删除元素参数错误!");
    		return 0;
    	}
    
    	s = p->next;
    	*x = s->Data;
    	p->next = p->next->next;
    	free(s);
    	return 1;
    }
    
    //(5)取数据元素
    int ListGet(SLNode *head, int i, DataType* x)
    {
    	SLNode* p;
    	int j;
    	j = -1;
    	p = head;
    	while (p->next != head && j < i)
    	{
    		p = p->next;
    		j++;
    	}
    
    	if (j != i)
    	{
    		printf("取元素位置错误!");
    		return 0;
    	}
    
    	*x = p->Data;
    	return 1;
    
    }
    //(6)撤销循环单链表
    void Destroy(SLNode** head)
    {
    	SLNode* p, * p1;
    
    	p = *head;
    	while (p != *head)
    	{
    		p1 = p;
    		p = p->next;
    		free(p1);
    	}
    	*head = NULL;
    }
    
    //(7)插入法建立带头结点的循环单链表
    void ListInsert1(SLNode** L, int n)
    {
    	*L = (SLNode*)malloc(sizeof(SLNode));
    	(*L)->next = *L;
    
    	printf("请输入链表元素值:\n");
    	for (int i = n; i > 0; --i)
    	{
    		int x;
    		printf("请输入第%d个元素的值:", i);
    		SLNode* p;
    		p = (SLNode*)malloc(sizeof(SLNode));//生成新结点
    		scanf("%d", &x);
    		p->Data = x;
    		p->next = (*L)->next;
    		(*L)->next = p;
    	}
    }
    
    

    设计主函数如下:

    #include<stdio.h>
    #include<malloc.h>
    typedef int DataType;
    #include"循环单链表.h"
    
    void main()
    {
    	SLNode* head;
    	int i, x;
    
    	ListInitiate(&head);
    	for (i = 0; i < 10; i++) 
    		ListInsert(head, i, i + 1);
    	ListDelete(head, 4, &x);
    	for (i = 0; i < ListLength(head); i++)
    	{
    		ListGet(head, i, &x);
    		printf("%d	", x);
    	}
    	Destroy(&head);					//撤销单链表
    
    	printf("\n");
    	ListInsert1(&head, 5);			//使用插入法建立带头结点的循环单链表
    	for (i = 0; i < ListLength(head); i++)
    	{
    		ListGet(head, i, &x);
    		printf("%d	", x);
    	}
    }
    

    代码运行如下:
    在这里插入图片描述

    码字不易,穷酸学生,各位老板打赏个1分钱支持一下,谢谢老板。
    在这里插入图片描述

    展开全文
  • 合并有序单循环链表,不重新申请存储空间; 创建有序单循环链表,并指向尾结点; 新单循环链表的指针指向尾结点;
  • 描述:用Python实现单链表,双链表,单循环链表,双循环链表 单链表的实现(链表的基本方法): 1 # _*_ coding: utf-8 _*_ 2 # Filename: singlelinklist 3 # Function: create linklist datastructure ...

    描述:用Python实现单链表,双链表,单循环链表,双循环链表

     

    单链表的实现(链表的基本方法):

      1 # _*_ coding: utf-8 _*_
      2 # Filename: singlelinklist
      3 # Function: create linklist datastructure
      4 # Author: Latup
      5 
      6 
      7 class Node():
      8     """define the node of linklist"""
      9 
     10     def __init__(self, data=None, next=None):
     11         self.data = data
     12         self.next = next
     13 
     14 
     15 class LinkList():
     16     """define class of linklist"""
     17 
     18     def __init__(self):
     19         self.head = Node()
     20         self.length = 0
     21 
     22     def init_linklist(self, data):
     23         """initial linklist"""
     24 
     25         p = self.head
     26         for i in data:
     27             node = Node(i)
     28             p.next = node
     29             p = p.next
     30             self.length += 1
     31 
     32     def isEmpty(self):
     33         """Determine if the linklist is empty"""
     34         return self.length == 0
     35 
     36     def insert(self, _index, data):
     37         """Insert an element into the linklist"""
     38 
     39         if _index < 1 or _index > self.length+1:
     40             print('IndexError: out of index, fail to insert')
     41             return
     42         p = self.head
     43         node = Node(data)
     44         count = 0
     45         while count < _index-1:
     46             p = p.next
     47             count += 1
     48         node.next = p.next
     49         p.next = node
     50         self.length += 1
     51 
     52     def delt(self, _index):
     53         """Delete the value of the element corresponding to _index"""
     54 
     55         if _index < 1 or _index > self.length:
     56             print('IndexError: out of index, fail to delt')
     57             return
     58         p = self.head
     59         count = 0
     60         while count < _index-1:
     61             p = p.next
     62             count += 1
     63         p.next = p.next.next
     64         self.length -= 1
     65 
     66     def node_updata(self, _index, data):
     67         """Replace the value of the element corresponding to _index with data"""
     68 
     69         if _index < 1 or _index > self.length:
     70             print('IndexError: out of index, fail to updata')
     71             return
     72         p = self.head.next
     73         count = 1
     74         while count < _index:
     75             p = p.next
     76             count += 1
     77         p.data = data
     78 
     79     def getItem(self, _index):
     80         """Get the value of the element corresponding to _index"""
     81 
     82         if _index < 1 or _index > self.length:
     83             print('IndexError: out of index, fail to getitem')
     84             return
     85         p = self.head.next
     86         count = 1
     87         while count < _index:
     88             p = p.next
     89             count += 1
     90         return p.data
     91 
     92     def getIndex(self, data):
     93         """Get the index of the element data"""
     94 
     95         if self.isEmpty():
     96             print('the linklist is empyt, fail to getindex')
     97             return
     98         p = self.head.next
     99         count = 1
    100         while p and p.data != data:
    101             p = p.next
    102             count += 1
    103         if count == self.length+1:
    104             print('%s not found' % str(data))
    105             return
    106         else:
    107             return count
    108 
    109     def traverse_linklist(self):
    110         """Traversing the linklist"""
    111 
    112         p = self.head.next
    113         if p == None:
    114             print('empty linklist')   
    115         while p:
    116             print(p.data, end=' ')
    117             p = p.next
    118 
    119     def reverse_linklist(self):       # reverse_linklist()是一个生成器函数,而不是普通函数
    120         pre = None
    121         _next = None
    122         p = self.head.next
    123         while p:
    124             _next = p.next
    125             p.next = pre
    126             pre = p
    127             p = _next
    128         self.head.next = pre
    129 
    130         p = self.head.next
    131         while p:
    132             yield p.data
    133             p = p.next

     

    双链表的实现(双链表在结点定义、初始化链表和插入删除上和单链表稍有不同):

     1 class Node:
     2     """define the node of linklist"""
     3 
     4     def __init__(self, data=None, prior=None, next=None):
     5         self.data = data
     6         self.prior_item = prior
     7         self.next_item = next
     8 
     9 
    10 def init_linklist(self, data):
    11     """initial linklist"""
    12     p = self.head
    13     for i in data:
    14         node = Node(i, prior=p)
    15         p.next_item = node
    16         p = p.next_item
    17         self.length += 1
    18 
    19 def insert(self, _index, data):
    20     """Insert an element into the linklist"""
    21     if _index < 1 or _index > self.length+1:
    22         print('IndexError: out of index, fail to insert')
    23         return
    24     p = self.head
    25     node = Node(data)
    26     count = 0
    27     while count < _index-1:
    28         p = p.next_item
    29         count += 1
    30     node.next_item = p.next_item
    31     p.next_item = node
    32     node.prior_item = p
    33     if node.next_item != None:
    34         node.next_item.prior_item = node
    35     self.length += 1
    36 
    37 def delt(self, _index):
    38     """Delete the value of the element corresponding to _index"""
    39     if _index < 1 or _index > self.length:
    40         print('IndexError: out of index, fail to delete')
    41         return
    42     p = self.head
    43     count = 0
    44     while count < _index-1:
    45         p = p.next_item
    46         count += 1
    47     p.next_item = p.next_item.next_item
    48     p.next_item.prior_item = p
    49     self.length -= 1

     

    单循环链表的实现(需要修改初始化和插入方法):

     1 def init_linklist(self, data):
     2     """initial linklist"""
     3     p = self.head
     4     for i in data:
     5         node = Node(i, next=self.head)
     6         p.next_item = node
     7         p = p.next_item
     8         self.length += 1
     9 
    10 def insert(self, _index, data):
    11     """Insert an element into the linklist"""
    12     if _index < 1 or _index > self.length+1:
    13         print('IndexError: out of index, fail to insert')
    14         return
    15     p = self.head
    16     node = Node(data)
    17     count = 0
    18     while count < _index-1:
    19         p = p.next_item
    20         count += 1
    21     node.next_item = p.next_item
    22     # If the inserted position is the end of the linklist
    23     if node.next_item == None:
    24         node.next_item = self.head
    25     p.next_item = node
    26     self.length += 1

     

    双循环链表的实现(修改初始化和插入方法):

     1 def init_linklist(self, data):
     2     """initial linklist"""
     3     p = self.head
     4     for i in data:
     5         node = Node(i, prior=p, next=self.head)
     6         p.next_item = node
     7         p = p.next_item
     8         self.head.prior_item = node
     9         self.length += 1
    10 
    11 def insert(self, _index, data):
    12     """Insert an element into the linklist"""
    13     if _index < 1 or _index > self.length+1:
    14         print('IndexError: out of index, fail to insert')
    15         return
    16     p = self.head
    17     node = Node(data)
    18     count = 0
    19     while count < _index-1:
    20         p = p.next_item
    21         count += 1
    22     node.next_item = p.next_item
    23     p.next_item = node
    24     node.prior_item = p
    25     # If the inserted position is the end of the linklist
    26     if node.next_item == None:
    27         node.next_item = self.head
    28         self.head.prior_item = node
    29     self.length += 1

     

    转载于:https://www.cnblogs.com/latup/p/9823179.html

    展开全文
  • 定义:单循环链表——在单链表中,将终端结点的指针域NULL改为指向表头结点或开始结点即可。带头结点判断空链表的条件是head == head.next;带尾节点用尾节点rear表示的单循环链表对开始结点a1和终端结点an查找时间都...

    定义:

    单循环链表——在单链表中,将终端结点的指针域NULL改为指向表头结点或开始结点即可。

    带头结点

    判断空链表的条件是head == head.next;

    带尾节点

    用尾节点rear表示的单循环链表对开始结点a1和终端结点an查找时间都是O(1)。而表的操作常常是在表的首尾位置上进行,因此,实用中多采用尾指针表示单循环链表。带尾指针的单循环链表可见下图。

    8bf30f45c85c7368f93bcc457480d5ff.png

    注意:判断空链表的条件为rear==rear.next;

    循环链表的运算与单链表的运算基本一致。所不同的有以下几点:

    1、在建立一个循环链表时,必须使其最后一个结点的指针指向表头结点,而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。

    2、在判断是否到表尾时,是判断该结点链域的值是否是表头结点,当链域值等于表头指针时,说明已到表尾。而非象单链表那样判断链域值是否为NULL。

    单循环链表的实现:package com.ds.link;

    public class CircularLinkedList{

    private Node head;

    private int length; //the length of the list

    private class Node {

    private Node next;

    private T data;

    public Node(T data) {

    this.data = data;

    next = null;

    }

    public Node(T data, Node nextNode) {

    this.data = data;

    next = nextNode;

    }

    public void setData(T data) {

    this.data = data;

    }

    public void setNext(Node next) {

    this.next = next;

    }

    public T getData() {

    return data;

    }

    public Node getNext() {

    return next;

    }

    }

    public CircularLinkedList() {

    head = new Node(null, head);

    length = 0;

    }

    public void insertAtPrior(T item) {//在头节点之后加一个节点

    Node node = new Node(item, null); //encpsule the item to an node

    node.setNext(head.getNext()); //node.next = head.next

    head.setNext(node); //head.next = node

    length ++;

    }

    public void add(T item) {//在最后节点上添加一个节点

    Node tmp = head;

    if (isEmpty()) { // if the list is null

    Node node = new Node(item, head); // .. if next == null ?

    head.setNext(node);

    } else {

    Node node = new Node(item, head);

    // find the end node of the list

    while (head != tmp.getNext()) {

    tmp = tmp.getNext();

    }

    tmp.setNext(node);

    }

    length++;

    }

    public T get(int index) { //获取索引处的节点的数据

    // 先判断索引正确性

    if (index >length || index < 0) {

    throw new RuntimeException("索引值有错:" + index);

    }else if(isEmpty()){

    return null;

    }else{

    Node tmp =head;

    int i= 1;

    while (head != tmp.getNext() && i <= index) {

    tmp = tmp.getNext();

    i++;

    }

    T e = tmp.getData();

    return e;

    }

    }

    public void insert(int index, T item) {//在索引处后添加节点

    Node node = new Node(item, null);

    Node tmp = head;

    int i = 1;

    if (index > length || index < 0) {

    System.out.println("the index is out of bounds");

    } else if (0 == length && 1 == index) {

    node.setNext(head);

    head.setNext(node);

    length++;

    } else {

    //find the node index

    while (head != tmp.getNext() && i <= index) {

    tmp = tmp.getNext();

    i++;

    }

    node.setNext(tmp.getNext());

    tmp.setNext(node);

    length++;

    }

    }

    public void removeFromFront() {//删除头节点之后的第一个节点

    Node tmp = head;

    if (length < 1) {

    System.out.println("The list is null and you can not delete any node!");

    } else if (1 == length) {

    head.setNext(head);

    length--;

    } else {

    head.setNext(tmp.getNext().getNext());

    length--;

    }

    }

    public void remove(int index) {//删除索引处的节点

    if (length < 1 || index > length) {

    System.out.println("index is out of bounds");

    } else if (1 == length && 1 == index) {

    head.setNext(head);

    length--;

    } else {

    Node tmp = head;

    int i = 1;

    //get the node before index

    while (head != tmp.getNext() && i < index) {

    tmp = tmp.getNext();

    i++;

    }

    tmp.setNext(tmp.getNext().getNext());

    length--;

    }

    }

    public void removeFromLast() {//删除最后一个节点

    if (length < 1) { // if the list is null

    System.out.println("The list is null and you can not delete");

    } else if (1 == length) {

    head.setNext(head);

    length--;

    } else {

    Node tmp1 = head;

    Node tmp2 = head.getNext(); //set tmp2 -tmp1 = 1

    while (head != tmp2.getNext()) {

    tmp2 = tmp2.getNext();

    tmp1 = tmp1.getNext();

    }

    tmp1.setNext(head);

    length--;

    }

    }

    public int getLength() {

    return length;

    }

    public boolean isEmpty() {

    return length==0;

    }

    public void display() {

    if (length < 1) {

    System.out.println("The list is null");

    } else {

    Node tmp = head;

    while (head != tmp.getNext()) {

    tmp = tmp.getNext();

    System.out.print(tmp.getData() + " ");

    }

    }

    }

    //test the list

    public static void main(String[] args) {

    CircularLinkedList< Integer> l = new CircularLinkedList< Integer>();

    System.out.println(l.isEmpty());

    l.add(1);

    l.add(2);

    l.insertAtPrior(3);

    l.insert(2, 4);

    l.add(5);

    System.out.println("the list is : ");

    l.display();

    System.out.println();

    System.out.println("the length is :" + l.getLength());

    l.removeFromFront();

    l.removeFromLast();

    l.display();

    // System.out.println(l.get(3));

    }

    }

    结果输出:true

    the list is :

    3 1 4 2 5

    the length is :5

    1 4 2

    如果存在问题,我们随时交流!

    展开全文
  • 单循环链表练习

    2021-04-13 21:24:38
    单循环链表学习,包含以下内容: 1、创建循环链表 2、 插入 结点 3、 删除 结点 4、显示链表元素 5、返回元素位置 6、清空链表元素 CircleList.h 文件 #pragma once #include <iostream> using namespace std...
  • 7.4 单循环链表

    2020-10-24 17:56:03
    7.4 单循环链表 循环链表基本操作 创建 判断非空 添加节点 删除节点 遍历 代码 /************************************* * 名称描述:单向循环链表 * 实现功能:单向循环链表基本操作: 添加、删除、遍历 * 作 者...
  • 单循环链表的实现

    2019-11-25 11:03:25
    单循环链表存储结构 单循环链表结点的存储结构和单链表的存储结构一样,所不同的是:最后一个结点的 next 域指向头结点,而不是“空”。这样,由表尾很容易找到表头。但若链表较长,则由表头找到表尾较费时,因而,...
  • 单循环链表变成双循环链表

    千次阅读 2013-06-01 00:08:13
    以下程序实现把单循环链表变成双循环链表: #include #include #include #include #include #include #define ElemType char #define ARRAYSIZE 20 typedef struct LNode { ElemType data[20]; struct LNode *next...
  • 1 单循环链表的定义 在单链表中,将终端结点的指针域NULL改为指向表头结点或开始结点,整个链表形成一个环。 2 单循环链表与单链表的差异 空链表的判断条件 非空链表的循环条件 3 单循环链表操作的实现 初始化 ...
  • 的基础上,由单链表修改为单循环链表,修改点不多,执行结果如下: 代码如下,对应的修改点也标注出来了,详细如下: // 单链表实现方式 // 利用快慢指针,查找单链表的中间节点 #include <stdio.h> #...
  • 本文对单链表/单循环链表_C语言进行实现。 实现如下6个操作: 初始化init 插入insert(指定插入位置和插入元素) 替换replace(用指定的元素替换某个位置的元素) del删除指定节点 find根据值查找某个节点,...
  • 拆分单循环链表

    千次阅读 2017-12-21 17:14:54
    单循环链表L1,对其遍历的结果是x1,x2,……xn。将该循环链表拆分成两个单循环链表L1和L2,使得L1中含有原L1表中序号为奇数的节点,L2中含有原L1表中序号为偶数的节点; #include #include using namespace std; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,121
精华内容 848
关键字:

单循环链表