精华内容
下载资源
问答
  • 链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出链表的创建和输出
  • 主要介绍了C语言实现输出链表中倒数第k个节点,主要涉及链表的遍历操作,是数据结构中链表的常见操作。需要的朋友可以参考下
  • 主要介绍了Java输出链表倒数第k个节点的相关内容,涉及三种设计思路及代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 数据结构里面的线性表,建立链表 连接链表 输出链表 比较好用
  • 逆向输出链表

    千次阅读 2015-10-16 20:34:16
    在不改变链表结构的前提下,使用一个后进先...我们也可以根据递归来逆向输出链表。#include #include using namespace std; //链表的节点类型 struct Node { int data; Node *next; }; //在链表末尾插入一个元素 v
    在不改变链表结构的前提下,使用一个后进先出的数据结构(栈)存储正向遍历链表的结果,根据后进先出的特点:最后一个进入的数据最先被弹出,可以逆向打印出链表。我们也可以根据递归来逆向输出链表。
    #include<iostream>
    #include<stack>
    using namespace std;
    
    //链表的节点类型
    struct Node
    {
    	int data;
    	Node *next;
    };
    
    //在链表末尾插入一个元素
    void addTailNode(Node *&head,int val)
    {
    	Node *p = new Node;//创建一个节点
    	p->data = val;
    	p->next = NULL;
    
    	if(head == NULL)//判断链表是否为空
    	{
    		head = p;
    	}
    	else
    	{
    		Node *tmp = head;//tmp指向链表的末尾
    		while(tmp->next != NULL)
    		{
    			tmp = tmp->next;
    		}
    		tmp->next = p;
    	}
    }
    
    //正向输出链表
    void show(Node *head)
    {
    	while(head != NULL)
    	{
    		cout<<head->data<<endl;
    		head = head->next;
    	}
    }
    
    //使用递归的方法逆向输出链表
    void reverseShow01(Node *head)
    {
    	if(head != NULL)
    	{
    		reverseShow01(head->next);
    		cout<<head->data<<" ";
    	}
    }
    
    //使用栈作为数据结构逆向输出链表
    void reverseShow02(Node *head)
    {
    	stack<int> s;//创建s,栈中存储的是节点中值类型
    	while(head != NULL)//链表不为空入栈
    	{
    		s.push(head->data);
    		head = head->next;
    	}
    
    	while(!s.empty())//栈不为空,输出栈顶元素,并输出
    	{
    		cout<<s.top()<<" ";
    		s.pop();
    	}
    	cout<<endl;
    }
    
    int main(void)
    {
    	Node *head = NULL;//创建一个空的链表
    	for(int i = 0; i < 10; ++i)//在链表中插入10个数
    	{
    		addTailNode(head,i);
    	}
    	reverseShow01(head);//逆向输出链表
    	cout<<endl;
    	reverseShow02(head);//逆向输出链表
    	system("pause");
    	return 0;
    }
    输出结果:
    9 8 7 6 5 4 3 2 1 0
    9 8 7 6 5 4 3 2 1 0
    展开全文
  • 输入一个链表,反转链表后,输出链表的所有元素。
    /*
    
    public class ListNode {
        int val;
        ListNode next = null;


        ListNode(int val) {
            this.val = val;
        }
    }*/
    import java.util.ArrayList;
    public class Solution {
        ListNode first;
        ListNode node;
        ListNode first_node;
        ArrayList<Integer> list=new ArrayList<Integer>();
        public ListNode ReverseList(ListNode head) {
                if(head==null){
                    return head;
                }
            while(head != null){
                list.add(head.val);
                head=head.next;
            }
            first =new ListNode(list.get(list.size()-1));
            first_node=first;
            for(int i=list.size()-2;i>=0;i--){
               node=new ListNode(list.get(i));
               first.next=node;
               first=first.next;
            }
            return first_node;
        }
    }
    展开全文
  • 逆序输出链表的元素

    千次阅读 2013-11-16 11:15:43
    逆序输出链表的元素:一般输出元素都是不改变数据结构的啦,所以要逆序输出链表的元素,先去掉将每个结点指向下一个结点改成指向上一个结点的念想先,所以,最先可以想到的就是用递归实现咯,但是递归实现有个问题,...

    逆序输出链表的元素:一般输出元素都是不改变数据结构的啦,所以要逆序输出链表的元素,先去掉将每个结点指向下一个结点改成指向上一个结点的念想先,所以,最先可以想到的就是用递归实现咯,但是递归实现有个问题,就是当元素太多的时候,会导致栈溢出,所以,我们也可以自己实现栈来存储结点的嘛,下面就用了两种方法实现.

    #include <iostream>
    #include <stack>
    
    typedef struct Node
    {
    	int m_data;
    	Node* m_next;
    }Node, *List;
    
    // 逆序输出链表-递归实现
    void printListInverse1(List list)
    {
    	if (list)
    	{
    		printListInverse1(list->m_next);
    		std::cout<<list->m_data<<std::endl;
    	}
    }
    
    // 逆序输出链表-利用栈实现
    void printListInverse2(List list)
    {
    	std::stack<Node*> stack_noed;
    	while(!stack_noed.empty())
    	{
    		stack_noed.pop();
    	}
    	// 将所有元素先push到栈中先
    	while(list)
    	{
    		stack_noed.push(list);
    		list = list->m_next;
    	}
    	// 一个个出栈,然后输出
    	while(!stack_noed.empty())
    	{
    		std::cout<<stack_noed.top()->m_data<<std::endl;
    		stack_noed.pop();
    	}
    }
    
    // 插入元素
    void insertList(List& list, int data)
    {
    	if (list)
    	{
    		insertList(list->m_next, data);
    	}
    	else
    	{
    		Node* node = new Node;
    		node->m_data = data;
    		node->m_next = 0;
    		list = node;
    	}
    }
    
    int main()
    {
    	Node* list = new Node;
    	list->m_next = 0;
    	insertList(list, 1);
    	insertList(list, 2);
    	insertList(list, 3);
    	insertList(list, 4);
    	insertList(list, 5);
    	insertList(list, 6);
    	// 递归方法
    	printListInverse1(list->m_next);
    	// 非递归方法
    	printListInverse2(list->m_next);
    	return 0;
    }


     

    展开全文
  • C++使用递归来顺序和逆序输出链表的全部元素
  • 输入一个链表,反转链表后,输出链表的所有元素。 思路在代码里: public class ListNodeReverse { public ListNode ReverseList(ListNode head) { if (head == null) return null; ListNode newHead = ...

    题目描述

    输入一个链表,反转链表后,输出链表的所有元素。

    思路:第一步,假设三个节点,pPrev,pNode,pNext,pNode代表当前节点,其他看名字就知道了。要让pPrev ->pNode,变成pNode <-pNode

    第二步:先保存当前的pNext,以免丢失数据,下面会用到。

    第三步:让pNode -> pPrev,这里如果上面不保存pNext的话,pNext会丢失。

    第四步:为下次反转指向做准备,要有两个,pPrev = pNode,把当前节点给pPrev,因为下次循环,这次的当前节点pNode就变成了pPrev

                    pNode = pNext,上面保存的pNext的值有用了,下次的pNode变成这次的pNext.

    循环的截止,到链表的结尾。

    代码:

    public class ListNodeReverse {
    	public ListNode ReverseList(ListNode head) {
    		if (head == null)
    			return null;
    		ListNode newHead = null;
    		ListNode pNode = head;// 当前节点
    		ListNode pPrev = null;// 当前节点的前面一个节点
    		while (pNode != null) {
    			ListNode pNext = pNode.next;// 保存当前节点的下一节点
    			if (pNext == null)
    				newHead = pNode;
    			pNode.next = pPrev;// 反转指向,让当前节点指向当前节点的前一节点
    			// 下面的两行是为下一次反转指向做准备的
    			pPrev = pNode;// 让前置节点变成当前节点,以便下一节点即pNext反转指向时,指向的是现在的当前节点pNode
    			pNode = pNext;// 移动当前节点为下一节点
    		}
    		return newHead;
    	}
    }




    展开全文
  • 逆序输出链表(递归)---C++实现

    千次阅读 2019-05-21 10:44:25
    **顺序输出链表** void printList(node* head) { if (!head) return; cout << head->data << " "; printList(head->next); } **逆序输出链表** void printListByReverseOrder(node* head) {...
  • 倒序输出链表

    千次阅读 2019-05-03 19:26:25
    1 思路:先遍历链表,用一个数组存储链表的值。然后反转该数组,返回该数组即可。 2 核心模块 ①遍历链表 我的误区:head是虚拟头结点,不存放有意义的链表数据。 按照题目意思:head中存放链表的第一个数据。 ...
  • 输出链表倒数第K个结点

    千次阅读 2012-08-17 15:26:43
    方法1:要输出链表中的倒数第K个结点,最自然的想法是先求出链表的长度N,然后从头遍历链表输出链表的第N-K+1个结点即可。注意本题数字从1计数,也就是说倒数第1个节点是链表最后一个结点。例如链表长度为4,需要...
  • /***依次输出链表中的各个结点***/ #include using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; typedef char ElemType; typedef struct LNode { ElemType data; //...
  • 输入一个链表,反转链表后,输出链表的所有元素。 public class Solution { public ListNode ReverseList(ListNode head) { if(head==null){ return null; } ListNode hea=new ListNode(0); hea.next=he
  • python 打印输出链表

    千次阅读 2020-09-17 16:05:58
    '''创建生成链表节点的类''' def __init__(self, val, next = None): self.val = val self.next = next def print_linked_list(head): if not head or not head.next: return [] result = [] while head: ...
  • Q:输入一个链表,反转链表后,输出链表的所有元素。A:1、先在原链表的头节点前再添加一个头结点; 2、使用头插法逆置新加入头结点后的所有节点。/* struct ListNode { int val; struct ListNode *next; ...
  • 1.数据结构是递归的 某些数据结构本身具有递归的特性,则它们的操作可递归地描述 例如,对于链表,其结点 LNode的定义由数据域data和指针域next组成,而...2.遍历输出链表中各个结点的递归算法 算法步骤 ①如果...
  • 编写一个输出链表的函数print。解:程序:#include#include#define LEN sizeof(struct Student)struct Student{ long num; float score; struct Student *next;};int n;struct Student *creat()//建立链表的函数{ ...
  • 四种方式实现--从尾到头输出链表  方法一:借用栈倒序输出链表  方法二:先翻转链表,再顺序输出  方法三:递归实现,一个字妙,两个字很妙,三个字太妙了  方法四:用数组实现  方法一:借用栈倒序输出...
  • 输入一个链表,反转链表后,输出链表的所有元素。就地逆转,头插法 思路:就地逆转,头插法
  • /*****************************...**************新增加功能:输出链表中值的最大节点*************** *********************************************************/ /****求链表中的值最大的节点****/ void SListNo
  • Java实现反向输出链表

    千次阅读 2018-04-20 23:57:29
     题目解析:一般从尾到头打印链表结点的值的话,可以想到将链表结点的指针反转过来,改变链表方向,这样相当于从头到尾输出了,但是这样就改变了链表的结构。打印通常只是一个只读操作,并不希望改变链表的数据结构...
  • 三种方式实现--从尾到头输出链表

    千次阅读 2011-08-01 19:35:42
    三种方式实现--从尾到头输出链表  方法一:借用栈倒序输出链表  方法二:先翻转链表,再顺序输出  方法三:递归实现,一个妙,两个字妙啊  方法一:借用栈倒序输出链表  因为栈是先进后出,把链表中的...
  • 算法学习十四----逆序输出链表

    千次阅读 2014-04-18 15:22:26
    逆序输出链表,可以采用借用额外空间,使用栈的数据结构,然后遍历一次链表,且每遇到一个节点就将其放入到栈中,直到最后一个节点,最后将栈输出,这样就实现了逆序输出链表。 还有一种方法就是递归实现,每次...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 261,433
精华内容 104,573
关键字:

怎么输出链表