精华内容
下载资源
问答
  • 链表的遍历

    2020-10-10 17:16:12
    有n个记录存储在带头结点双向链表中,利用双向冒泡排序法对其按上升序进行排序,请写出这种排序算法。(注:双向冒泡排序即相邻两趟排序向相反方向冒泡)。看这里 主体思想 从头结点下一个结点开始往后遍历,在...

    题目

    有n个记录存储在带头结点的双向链表中,利用双向冒泡排序法对其按上升序进行排序,请写出这种排序的算法。(注:双向冒泡排序即相邻两趟排序向相反方向冒泡)。看这里

    结构体的定义

    typedef struct DNode {
        int data;
        struct DNode *prior, *next;
    } DNode, *DLinklist;
    

    主体思想

    从头结点的下一个结点开始往后遍历,在第一轮选出最大的结点(过程中遇到“较大”的数也进行交换),同时确定尾结点。

    在回溯的时候,就是上诉的逆过程。这样每次一个来回,就可以确定“头尾”两个最终结果。当然,如果某一轮遍历的时候没有发生数据交换,则说明遍历已经结束。

    主题代码

    链表的交换排序可以交换结点交换值,此处选择的是交换值的方式

    void BubbleSort(DLinklist &L) {
        DNode *p, *head, *tail;
        head = L;//指向头结点
        tail = NULL;
        int ex = 1;
        int temp;
        while (ex) {
            ex = 0;
            p = head->next;//指向此次遍历的第一个结点
            while (p->next != tail) {
                if (p->data > p->next->data) {
                    ex = 1;
                    temp = p->data;
                    p->data = p->next->data;
                    p->next->data = temp;
                }
                p = p->next;
            }
    
            tail = p;//将当前停止位置作为尾结点,每次往前进步一个
            while (ex && p->prior != head) {
                if (p->data < p->prior->data) {
                    ex = 1;
                    temp = p->data;
                    p->data = p->prior->data;
                    p->prior->data = temp;
                }
                p = p->prior;
            }
            head = p;//将当前停止位置作为“首部”结点,每次往后退步一个
            /*//循环中打印
            ErgodicDLinklist(L);
            cout << endl;*/
        }
    }
    

    结尾

    总的来说,双向链表相当于两个单链表…

    展开全文
  • 邻接链表的遍历

    2020-03-08 10:51:36
    在知道数组的遍历和链表的遍历之后,邻接链表的遍历自然也会了。 构建邻接链表结构并遍历 /** * 链表所需节点 */ public class Node { public int val; public Node next; public Node(int val){ ...
    • 我们都知道邻接链表内部结构其实就是数组+链表构成的。
      大致如下图:
      在这里插入图片描述
      在知道数组的遍历和链表的遍历之后,邻接链表的遍历自然也会了。
    • 构建邻接链表结构并遍历

    /**
     * 链表所需节点
     */
    public class Node {
            public int val;
            public Node next;
            public Node(int val){
                this.val = val;
            }
    }
    
    /**
     * 遍历邻接链表
     */
    public class Main2 {
        public static void main(String[] args) {
            Node[] nodes = new Node[3];//构建邻接链表
            Node a1 = new Node(1);
            Node a2 = new Node(2);
            Node a3 = new Node(3);
            a1.next = a2;
            a2.next = a3;
            Node b1 = new Node(4);
            Node b2 = new Node(5);
            Node b3 = new Node(6);
            b1.next = b2;
            b2.next = b3;
            Node c1 = new Node(7);
            Node c2 = new Node(8);
            Node c3 = new Node(9);
            c1.next = c2;
            c2.next = c3;
            nodes[0] = a1;
            nodes[1] = b1;
            nodes[2] = c1;
    
            for(int i = 0; i < nodes.length; i++){//遍历
                Node head = nodes[i];
                while (head != null){
                    System.out.println(head.val);
                    head = head.next;
                }
            }
        }
    }
    
    
    展开全文
  • 单向链表的遍历

    2019-03-19 20:46:12
    /链表的遍历和数组类似,就是跑链表/ //输出单向链表尾结点的值 #include<stdio.h> #include<stdlib.h> #define N 5 typedef struct node{ int data; struct node *next; }ElemSN; ElemSN *Creatlink...

    /链表的遍历和数组类似,就是跑链表/

    //输出单向链表尾结点的值

    #include<stdio.h>
    #include<stdlib.h>
    #define N 5
    typedef struct node{
    	int data;
    	struct node *next;
    }ElemSN;
    ElemSN *Creatlink(int a[])
    {
    	ElemSN *h,*tail;
    	//创建头结点 
    	h=tail=(ElemSN *)malloc(sizeof(ElemSN));
    	 h->data=a[0];
    	 h->next=NULL;
    	 for(int i=1;i<N;i++){
    	 	tail=tail->next=(ElemSN *)malloc(sizeof(ElemSN));
    	 	tail->data=a[i];
    		tail->next=NULL;
    	 }
    	 return h;
    }
    ElemSN * Printlink(ElemSN *h)
    {
    	ElemSN *p;//p从头指针开始不断向后移动,到最后一个元素停下
    	for(p=h;p->next ;p=p->next);//{
    	//	printf("%4d",p->data);
    	//}
    	return p;
    } 
    int main()
    {
    	int a[N]={10,20,30,40,50};
    	ElemSN *head=NULL,*x;
    	//正向创建单向链表
    	head=Creatlink(a);
    	//输出单向链表
    	x=Printlink(head);
    	printf("%d",x->data);
    	return 0; 
    }
    

    //输出单向链表的结点个数

    #include<stdio.h>
    #include<stdlib.h>
    #define N 6
    typedef struct node{
    	int data;
    	struct node *next;
    }ElemSN;
    ElemSN *Creatlink(int a[])
    {
    	ElemSN *h,*tail;
    	//创建头结点 
    	h=tail=(ElemSN *)malloc(sizeof(ElemSN));
    	 h->data=a[0];
    	 h->next=NULL;
    	 for(int i=1;i<N;i++){
    	 	tail=tail->next=(ElemSN *)malloc(sizeof(ElemSN));
    	 	tail->data=a[i];
    		tail->next=NULL;
    	 }
    	 return h;
    }
    int Printlink(ElemSN *h)
    {
    	ElemSN *p;
    	int cnt;
    	for(p=h;p!=NULL;p=p->next,cnt++);
    	return cnt;
    } 
    int main()
    {
    	int a[N]={10,20,30,40,50,0},x;
    	ElemSN *head=NULL;
    	//正向创建单向链表
    	head=Creatlink(a);
    	//输出单向链表
    	x=Printlink(head);
    	printf("%d",x);
    	return 0; 
    } 
    

    //输出单向链表的奇数结点个数

     #include<stdio.h>
    #include<stdlib.h>
    #define N 6
    typedef struct node{
    	int data;
    	struct node *next;
    }ElemSN;
    ElemSN *Creatlink(int a[])
    {
    	ElemSN *h,*tail;
    	//创建头结点 
    	h=tail=(ElemSN *)malloc(sizeof(ElemSN));
    	 h->data=a[0];
    	 h->next=NULL;
    	 for(int i=1;i<N;i++){
    	 	tail=tail->next=(ElemSN *)malloc(sizeof(ElemSN));
    	 	tail->data=a[i];
    		tail->next=NULL;
    	 }
    	 return h;
    }
    int Printlink(ElemSN *h)
    {
    	ElemSN *p;
    	int cnt=0;
    	for(p=h;p!=NULL;p=p->next){
    		cnt+=p->data%2; //计数
    	}
    	return cnt;
    } 
    int main()
    {
    	int a[N]={10,21,30,44,50,21},x;
    	ElemSN *head=NULL;
    	//正向创建单向链表
    	head=Creatlink(a);
    	//输出单向链表
    	x=Printlink(head);
    	printf("%d",x);
    	return 0; 
    }
    

    //输出单向链表的最大值(假设数据不重复)

    #include<stdio.h>
    #include<stdlib.h>
    #define N 6
    typedef struct node{
    	int data;
    	struct node *next;
    }ElemSN;
    ElemSN *Creatlink(int a[])
    {
    	ElemSN *h,*tail;
    	//创建头结点 
    	h=tail=(ElemSN *)malloc(sizeof(ElemSN));
    	 h->data=a[0];
    	 h->next=NULL;
    	 for(int i=1;i<N;i++){
    	 	tail=tail->next=(ElemSN *)malloc(sizeof(ElemSN));
    	 	tail->data=a[i];
    		tail->next=NULL;
    	 }
    	 return h;
    }
    ElemSN *Printlink(ElemSN *h)
    {
    	ElemSN *pmax,*p;
    	pmax=h;
    	for(p=h->next;p;p=p->next){
    		if(pmax->data<p->data){//判断
    			pmax=p;
    		}
    	}
    	return pmax;
    } 
    int main()
    {
    	int a[N]={10,20,66,40,50,21};
    	ElemSN *head=NULL,*x;
    	//正向创建单向链表
    	head=Creatlink(a);
    	//输出单向链表
    	x=Printlink(head);
    	printf("%d",x->data);
    	return 0; 
    }
    

    //逆向输出单向链表数据域的值

     #include<stdio.h>
    #include<stdlib.h>
    #define N 6
    typedef struct node{
    	int data;
    	struct node *next;
    }ElemSN;
    ElemSN *Creatlink(int a[])
    {
    	ElemSN *h,*tail;
    	//创建头结点 
    	h=tail=(ElemSN *)malloc(sizeof(ElemSN));
    	 h->data=a[0];
    	 h->next=NULL;
    	 for(int i=1;i<N;i++){
    	 	tail=tail->next=(ElemSN *)malloc(sizeof(ElemSN));
    	 	tail->data=a[i];
    		tail->next=NULL;
    	 }
    	 return h;
    }
    void Printlink(ElemSN *h)
    {
    	ElemSN *pend=NULL,*p;
    	while(pend!=h){
    	for(p=h;p->next!=pend;p=p->next);//每次跑到pend前面 
    	printf("%5d",p->data);
    	pend=p;
    	}
    } 
    int main()
    {
    	int a[N]={10,20,66,40,50,21};
    	ElemSN *head=NULL;
    	//正向创建单向链表
    	head=Creatlink(a);
    	//输出单向链表
    	Printlink(head);
    	return 0; 
    }
    
    展开全文
  • 数据结构-链表的遍历和链接链表的遍历-改进学生录入程序单向链表实现链表的链接 链表的遍历-改进学生录入程序 改进单向链表学生成绩录入,添加一个查找函数,再输入结束后通过查找函数来查找用户输入的特定成绩。...

    链表的遍历-改进学生录入程序

    改进单向链表学生成绩录入,添加一个查找函数,再输入结束后通过查找函数来查找用户输入的特定成绩。找到就返回该成绩所在的结点序号,找不到就输出·提示。

    单向链表实现

    #include "stdafx.h"
    
    struct Student
    {
    	int grade;
    	struct Student *next;
    };
    typedef struct Student Node;
    typedef Node* Ptr;
    
    int main()
    {
    	Ptr head;
    	Ptr Creatlink();
    	void Sreach(Ptr head);
    
    	head = Creatlink();
    	Sreach(head);
        return 0;
    }
    
    Ptr Creatlink()
    {
    	Ptr head, previous, last;
    	int num;
    
    	head = (Ptr)malloc(sizeof(Node));
    	if (head == NULL)
    	{
    		printf_s("wrong!");
    		return NULL;
    	}
    	last = head;
    	scanf_s("%d", &num);
    
    	while (num != 0)
    	{
    		previous = last;
    		previous->grade = num;
    		last = (Ptr)malloc(sizeof(Node));
    		if (last == NULL)
    		{
    			printf_s("wrong!");
    			return NULL;
    		}
    		previous->next = last;
    		scanf_s("%d", &num);
    	}
    	previous->next = NULL;
    	free(last);
    	return head;
    }
    
    
    void Sreach(Ptr head)
    {
    	int i, num, flag;
    	Ptr previous;
    	i = 1;																			//变量结点的序号
    	flag = 0;																		//标志位 用来判断是否找到
    	printf_s("请输入要查询的成绩");
    	scanf_s("%d", &num);
    	while (head != NULL)												//遍历链表
    	{
    		if (head->grade == num)									//判断链表数据域的数据和需求查找是否相等
    		{
    			printf_s("找到该结点位于第%d个结点\n",i);
    			flag++;																//找到标志位+1
    		}
    		previous = head;													//必须全部循环一次,这就是为啥不直接输出要使用判断条件的原因。释放所有结点
    		head = head->next;
    		i++;
    		free(previous);
    	}
    	if (flag == 0)																//找不到,标志位为0,输出。
    	{
    		printf_s("未找到该成绩");
    	}
    }
    
    

    链表的链接

    前置链表的尾结点的next指针指向后置链表的第一个结点,第一个结点的back指针指向后置链表的尾结点,后置链表第一个结点如果有back指针指向前置链表的尾结点,尾结点的next指针指向前置链表的第一个结点。
    (四个指针,两个结点,头结点/尾结点next/back指针)在这里插入图片描述

    展开全文
  • 链表的遍历(1)

    千次阅读 2019-06-29 14:23:28
    链表的遍历 /*------------------------------------*/#include"stdio.h"#include"stdlib.h"struct llist{ int num; char name[10]; struct llist *next;};typedef struct llist node;typedef node *llink; /...
  • PAT甲级-1032-Sharing(链表的遍历

    千次阅读 2020-02-05 14:37:13
    链表的遍历和图的遍历一样,需要设计一个标记变量,标记每个结点node是否被访问过。 什么是相同的结点?其实地址相同的结点就是相同结点。什么是公共结点?即遍历完两条单词链,访问过两次的结点。 ...
  • 链表的遍历、创建、插入、删除 首先创建一个结构体类型: struct Student{ int num; char name[128]; struct Student *next; }; 在主函数main中定义顶一个head作为链表的头指针,用来做遍历、创建、插入、删除 int ...
  • package oj.test; import java.util.*; public class Demo4 { ... * @LinkedList链表的遍历  */  public static void main(String[] args) {  LinkedList link = new LinkedList();  for(int k=1;k  lin
  • 单向链表的遍历、查找

    千次阅读 2018-02-17 21:23:48
    在本篇文章中,主要通过举例的方式来帮大家理解单向链表的基本遍历。本篇文章中创建节点用以下表示typdef struct node{  int date;//定义数据域  struct node * next;//定义指针域 } ElemSN; 例一:输出单向...
  • c# collections linkedlist 链表的遍历

    千次阅读 2016-11-15 21:40:11
    其实,一般来讲,遍历链表,就是要遍历链表的所有的节点,同时打印节点的值。但是,用foreach方法遍历链表的时候,遍历的直接是节点的值,而不是节点。这其实是c#里面做的不顺人思路的一面。语言毕竟是人开发的,...
  • 一.定义一个节点 创建一个节点类,类中定义两个属性,一个属性用来存放数据,一个属性用来存放下一... //链表存储数据 Node next = null; //下一个节点 public Node (String data) { this.data = data; } ...
  • Java---链表的遍历

    2021-03-04 16:03:00
    创建一个链表 //创建一个链表 public static Node createList(){ //创建四个Node实例,再定义四个引用来分别指向这四个实例 //随着方法结束,a,b,c,d也随之销毁 Node a=new Node(1); Node b=new Node(2); ...
  • 结构体数组中循环,i++即可; 链表循环,得靠p1和p2轮换交接,p1=head,p2=p1-&gt;next; 之后循环:{...(操作)... } p2=p1,p1=p1-&gt;next; 
  • 二叉链表的遍历

    千次阅读 2012-11-08 21:47:56
    晚上闲着没事请干,敲敲书上二叉树,用递归方法实现最简单前序,中序,后序遍历 Tree.h //BiTree #include #include //define #define OK 1 #define ERROR 0 #define OVERFLOW -1 //typedef typedef ...
  • 二叉链表的遍历实现

    2015-06-28 12:10:15
    数据结构二叉链表
  • //动态二叉树先根遍历,中根遍历、后根遍历和转换成静态二叉链表 代码: #include #include #define N 20 typedef struct node //节点创建 {  char data;  struct node *lchild,*rchild;  int index;
  • 链表的遍历-结点个数

    2018-08-02 02:16:48
    //正向创建链表 h=tail=p; else tail=tail->next=p; } return h;  }  int Coundnode (ElemSN *h) {  ElemSN * p;  int cut=0;  for(p=h;p; cut++,p=p->next);  //for循环遍历cnt++  return ...
  • 为什么80%码农都做不了架构师?>>> ...
  • #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define N 10 typedef struct node{ ...//创建一个单向链表 ElemSN* CreatLink(int a[],int n) { ElemSN *head,*tail,*p; he...
  • 1、输入一组整型元素序列,...  2、要求:  (1)实现链表的遍历、查找、插入、删除;  (2)将链表中的元素分解成两个带头结点的单链表,其中一个全部存放奇数,另一个全部存放偶数。用C语言实现,急,谢谢 ...
  • 链表的逆序遍历(带头节点)一、不改变节点的位置二、反转链表,改变节点的位置 一、不改变节点的位置 利用栈存储数据的特性——先进后出,将链表的节点压入栈中,再将节点出栈,实现链表的逆序遍历 // 逆序打印...
  • 数据结构二叉链表中序遍历// Tree.cpp : Defines the entry point for the console application. //---二叉链表存储表示--- #include "stdafx.h" #include #include #include using namespace std; #define ...
  • 三叉链表后序遍历

    2019-10-05 14:44:03
    【题目】假设在三叉链表的结点中增设一个标志域 (mark取值0,1或2)以区分在遍历过程中到达该结点 时应继续向左或向右或访问该结点。试以此存储结 构编写不用栈辅助的二叉树非递归后序遍历算法。 带标志域的三叉链表...
  • 三叉链表中序遍历

    2019-10-05 14:44:33
    【题目】二叉树采用三叉链表的存储结构,试编写 不借助栈的非递归中序遍历算法。 三叉链表类型定义: typedef struct TriTNode { TElemType data; struct TriTNode *parent, *lchild, *rchild; } TriTNode, *...
  • 建立一个升序链表遍历输出 输入描述: 输入每个案例中第一行包括1个整数:n(1&lt;=n&lt;=1000),接下来一行包括n个整数。 输出描述: 可能有多组测试数据,对于每组数据, 将n个整数建立升序链表,之后...
  • 文章:http://blog.csdn.net/lionpku/article/details/44278803 的链表版本。 代码如下: #include using namespace std; //敌舰结构体 struct EnemySpaceShip { int x_coordinate; int y_coordinate; int ...
  • 遍历链表元素,反向输出,可以考虑使用栈“先进后出”性质,先将链表元素全部压栈,然后再出栈。 元素全部压栈,然后再出栈。 package com.point.offer; import java.util.ArrayList; import java.util.Stack; ...
  • 重新认识链表(单向链表遍历)

    千次阅读 2015-08-31 19:56:53
    C语言实训时候 接触到链表 当时并没有 很好理解他 只是死记了他结构模式和语法 。 今天十几分钟复习 突然感受到了 他逻辑思想 还是很高兴 下面是一个简单 循环单链表 。希望能够尽

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,441
精华内容 11,376
关键字:

链表的遍历