精华内容
下载资源
问答
  • 主要介绍了C语言实现输出链表中倒数第k个节点,主要涉及链表的遍历操作,是数据结构中链表的常见操作。需要的朋友可以参考下
  • 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: ...
    class ListNode(object):
        '''创建生成链表节点的类'''
        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:
            result.insert(0, head.val)
            head = head.next
        return result
    
    if __name__ == "__main__":
        list_nodess = None
        # print(range(3, 0, -1))
        for i in range(3, 0, -1):   # 定义数据项为[1,2,3]的链表
            # print(i)
            list_nodess = ListNode(i, list_nodess)
        print(print_linked_list(list_nodess)) # 从尾到头打印链
        

     

    展开全文
  • 倒序输出链表

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

    1 思路:先遍历链表,用一个数组存储链表的值。然后反转该数组,返回该数组即可。
    2 核心模块
    ①遍历链表
    我的误区:head是虚拟头结点,不存放有意义的链表数据。
    按照题目意思:head中存放链表的第一个数据。
    遍历链表:定义指向ListNode类型的指针p,使其指向头结点。仅当p不为空的时候,将p的数据域存入数组,并且将p指向下一个节点。最后返回数组。对应代码:

    ListNode * p=head;
     while(p!=NULL) 
            {
                Ldata.push_back(p->val);
                p=p->next;
                
            }
    

    极端情况说明:如果传入的链表为空,则不进行任何操作,直接返回数组。因为数组仅声明,所以输出为空。

    ②反转数组
    反转数组有三种实现方式:
    方式一:自定义实现反转,注意千万不要在数组本身上反转,会覆盖会出错,再定义一个新的数组,将反转后的结果存入新数组。

    for(int i=0;i<Ldata.size();i++)
       res.push_back(Ldata[Ldata.size()-1-i]);
      return res;
    

    方式二:使用algorithm中的reverse()函数,注意reverse函数传入的参数

    reverse(Ldata.begin(),Ldata.end());
     return Ldata;
    

    方式三:使用vector中的反转迭代器

    vector <int> ::reverse_iterator rit=Ldata.rbegin();
     for(;rit!=Ldata.rend();rit++)
           res.push_back(*rit);
     return res;
    

    3 完整代码

    /**
    *  struct ListNode {
    *        int val;
    *        struct ListNode *next;
    *        ListNode(int x) :
    *              val(x), next(NULL) {
    *        }
    *  };
    */
    class Solution {
    public:
        vector<int> printListFromTailToHead(ListNode* head) {
            vector <int> Ldata,res;
            
            ListNode * p=head;
           
            while(p!=NULL) //对于头指针的理解有问题,头指针也可以存放链表的有效数据
            {
                Ldata.push_back(p->val);
                p=p->next;
                
            }
            
            //法一:自定义自己实现反转的时候千万不要在数组本身上反转,会覆盖会出错
            //for(int i=0;i<Ldata.size();i++)
              // res.push_back(Ldata[Ldata.size()-1-i]);
            // return res;
            //法二:使用algorithm中的reverse()函数
           //reverse(Ldata.begin(),Ldata.end());
             // return Ldata;
             //法三:使用vector中的反转迭代器
            vector <int> ::reverse_iterator rit=Ldata.rbegin();
            for(;rit!=Ldata.rend();rit++)
                res.push_back(*rit);
             return res;
        }
    };
    

    4 收获:
    在线编程题如果只有一部分通过率,不一定是没考虑到边界情况,还有可能是逻辑上存在错误。

    5 新思路:
    vector的成员函数push_back和insert插入方式的差异:push_back()在数组尾部插入元素 & insert()在某个位置前插入某个或者某区间元素。push_back对应尾插法,最后得到的是相同顺序序列,insert选择每次在首元素前面插入新元素,对应头插法,最后得到的相反顺序的序列。所以本题可以用insert每次在首元素前面插入元素直接得到相反顺序的序列。

    class Solution {
    public:
        vector<int> printListFromTailToHead(ListNode* head) {
            vector <int> Ldata,res;
            
            ListNode * p=head;
            while(p!=NULL) 
            {
                Ldata.insert(Ldata.begin(),p->val);
                p=p->next;
            }
            return Ldata;
        }
    };
    

    6 收获
    ①声明类和结构体 后面不需要加(),但是末尾需要加;
    ②对于<剑指Offer>这种有函数定义的题目,你只要完成函数,返回相关的值就可以,不需要处理任何输入输出,不要在函数里输出任何东西。用好传给你的参数,返回指定类型的返回值就好,不要有多余的输入输出。这也体现了“封装”的思想。
    ③vector不能直接用cout输出,需要迭代器或者循环。
    vector只声明,没有添加任何元素,迭代器输出的结果为空。

    展开全文
  • #include #include #define LEN sizeof(struct Stuent) struct Student { long num; float score; struct student * next;...2、结构体和指针在链表中使用的很广泛...3、链表和图一样,有单链表、双链表、环形链表
    #include<stdio.h>
    #include<stdlib.h>
    #define LEN sizeof(struct Stuent)
    struct Student
    {
        long num;
        float score;
        struct student * next;
    };
    int n;
    void print(struct Student * head)
    {
        struct Student * p;
        printf("\nNow,These %d records are: \n", n);
        p = head;
        if(head != NULL)
            do
        {
            printf("%ld %5.lf\n", p->num,p->score);
            p=p->next;
        }while(p != NULL);
    }
    
    

    1、这个函数可以编译,但是不能运行;
    2、结构体和指针在链表中使用的很广泛;
    3、链表和图一样,有单链表、双链表、环形链表。

    展开全文
  • Java实现反向输出链表

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

            题目:输入一个链表的头结点,从尾到头反过来打印出每个结点的值。

            题目解析:一般从尾到头打印链表结点的值的话,可以想到将链表结点的指针反转过来,改变链表方向,这样相当于从头到尾输出了,但是这样就改变了链表的结构。打印通常只是一个只读操作,并不希望改变链表的数据结构,显然这样的方法是不可行的。

      (1)解决这个问题肯定要遍历链表的,遍历的顺序是从头到尾,而输出结果却是从尾到头,,典型的后进先出,这个特点
    正是栈的特点。每经过一个结点的时候,我们可以将结点放进栈中,遍历完整个链表后,我们再从栈顶依次输出结点的值。
    这样结点的值就能反转输出了。
        示例代码:
    
    public class StackPrintLinkedList {
        public static void main(String args[]){
            ListNode node1 = new ListNode();
            ListNode node2 = new ListNode();
            ListNode node3 = new ListNode();
            node1.data = 1;
            node2.data = 2;
            node3.data = 3;
            node1.next = node2;
            node2.next = node3;
            printListReverse(node1);
        }
        public static void printListReverse(ListNode headNode){
            Stack<ListNode> stack = new Stack<ListNode>();
            while (headNode != null){
                stack.push(headNode);
                headNode = headNode.next;
            }
            while (!stack.isEmpty()){
                System.out.println(stack.pop().data);
            }
        }
    }
    public class ListNode {
        public ListNode next;
        public int data;
    }
    

        (2)递归的本身就是一个栈结构,所以这个问题也可以用递归来实现。每当访问到一个结点的时候,我们先递归输出它后
    面的结点,直到递归到最后一个结点时,再返回来输出结点自身。
        示例代码:
        
    public class PrintLinkedList {
        public static void main(String args[]) {
            ListNode node1 = new ListNode();
            ListNode node2 = new ListNode();
            ListNode node3 = new ListNode();
            node1.data = 1;
            node2.data = 2;
            node3.data = 3;
            node1.next = node2;
            node2.next = node3;
            printListReverse(node1);
        }
    
        public static void printListReverse(ListNode headNode) {
            if (headNode != null) {
                if (headNode.next != null) {
                    printListReverse(headNode.next);
                }
            }
    
            System.out.println(headNode.data);
    
        }
    }
    public class ListNode {
        public ListNode next;
        public int data;
    }

        用递归来实现虽然简单,但是当链表非常长的时候,会导致递归函数的层数非常深,有可能导致栈溢出。因此用栈基于
    循环实现的鲁棒性好一些。





    展开全文
  • c语言逆向输出链表中的值

    千次阅读 2019-04-19 18:00:02
    1 通过将其按照头插法插入另一个链表中,然后顺序输出链表值就行。这个也是我们的常规思路啦 //先倒序存到一个新的链表中,然后输出 //采用头插法即可 void reverse_output(Node* head) { Node* reverse_first ...
  • 采用尾插法建立单链表并输出链表

    千次阅读 2020-10-01 18:36:24
    代码如下`` #include<stdio.h> #include<stdlib.h> typedef int DataType; struct Node { DataType data; struct Node* next; }; typedef struct Node *PNode; ... LinkList head =
  • 主要介绍了Java输出链表倒数第k个节点的相关内容,涉及三种设计思路及代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 输入一个链表,反转链表后,输出链表的所有元素。
  •  4:一般的处理新建一些节点,链表都能实现这个功能;但是为了节省空间复杂度,一般尽量利用单一变量在原链表上做出修改。除非有些情况无法处理,新建数组或者链表存储数据。  5:所以对于新建链表,一般仍然...
  • Q:输入一个链表,反转链表后,输出链表的所有元素。A:1、先在原链表的头节点前再添加一个头结点; 2、使用头插法逆置新加入头结点后的所有节点。/* struct ListNode { int val; struct ListNode *next; ...
  • 1.数据结构是递归的 某些数据结构本身具有递归的特性,则它们的操作可递归地描述 例如,对于链表,其结点 LNode的定义由数据域data和指针域next组成,而...2.遍历输出链表中各个结点的递归算法 算法步骤 ①如果...
  • 反向输出链表的两种方法

    千次阅读 2018-10-02 10:13:29
    ①不改变链表的结构(利用递归的本质是利用栈) void Reve_list(listnode* phead) { if(phead!=NULL) { if(phead-&gt;next!=NULL) { Reve_list(phead-&gt;next); } printf("%d\t",...
  • 尾插法建立单链表,并输出链表

    千次阅读 2020-03-05 16:47:39
     printf("打印输出链表: \n");  while(p)  {  printf("%d\t",p->data);  p=p->next;  } } int main() {  printf("Hello world!\n");  insert();  print();  return 0; }  
  • 逆序输出链表(递归)---C++实现

    千次阅读 2019-05-21 10:44:25
    **顺序输出链表** void printList(node* head) { if (!head) return; cout << head->data << " "; printList(head->next); } **逆序输出链表** void printListByReverseOrder(node* head) {...
  • 输出链表中的每个元素 void del_an_unit( package *package ); // 删除列表中的某个元素 int main(){ package package = {NULL} ; linked_list(& package ); print_linkedlist(& package ); ...
  • 写一个函数建立一个有3名学生数据的单向动态链表//建立静态链表 #include #include #include #include #define LEN sizeof(struct Student)struct Student { long num; float score; struct
  • /*综合本章例9.9(建立链表的函数creat)、例9.10(输出链表的函数print)和本章习题 第7题(删除链表中结点的函数del)、第8题(插入结点的函数insert),再编写一个主函数, 先后调用这些函数。用以上五个函数组成...
  • // 新链表的头结点就是原链表的尾结点   return  pPre;  }      void  printList(ListNode last) {  while  (last !=  null ) {  System.out.print(last.val +  "," );  last = last.next;  ...
  • 编写一个输出链表的函数print。解:程序:#include#include#define LEN sizeof(struct Student)struct Student{ long num; float score; struct Student *next;};int n;struct Student *creat()//建立链表的函数{ ...
  • 使用 LinkedList 类的 linkedlistname.getFirst() 和 linkedlistname.getLast() 来获取链表的第一个和最后一个元素 完整代码 import java.util.LinkedList; public class Main { public static void main(String...
  • #include <iostream> using namespace std; typedef int elemtype; typedef struct lnode { elemtype data; lnode *next; }lnode,*linklist; void traverselist(linklist p) { if (p == NULL) ... e...
  • 输入一个链表,反转链表后,输出链表的所有元素。 思路在代码里: public class ListNodeReverse { public ListNode ReverseList(ListNode head) { if (head == null) return null; ListNode newHead = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 263,709
精华内容 105,483
关键字:

输出链表