精华内容
下载资源
问答
  • java链表排序

    千次阅读 2011-11-14 14:24:58
    package struct;...import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.TreeSet; public class Comp implements Comparator{ private int x;
     
    package struct;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.TreeSet;
    
    public class Comp implements Comparator<Comp>{
    
     private int x;
     private int y;
    
     @Override
     public int compare(Comp o1, Comp o2) {
      return o1.x-o2.x;
     }
    
     Comp(){}
     
     Comp(int x,int y)
     {
      this.x=x;
      this.y=y;
     }
     
     @Override
     public String toString() {
      // TODO Auto-generated method stub
      return x+" "+y;
     }
     public static void main(String []args)
     {
      Comp c1 = new Comp(3,3);
      Comp c2 = new Comp(1,1);
      Comp c3 = new Comp(5,3);
      Comp c4 = new Comp(4,3);
      ArrayList<Comp> list = new ArrayList<Comp>();
      list.add(c1);
      list.add(c2);
      list.add(c3);
      list.add(c4);
      for (Comp comp : list) {
       System.out.println(comp);
      }
      System.out.println();
      Collections.sort(list,new Comp());
      for (Comp comp : list) {
       System.out.println(comp);
      }
      
     }
    
    }
    
    


     

    展开全文
  • java链表排序和反转

    2019-08-22 09:43:36
    链表排序 概念什么的都不说了。 链表排序的原理:和普通的数据排序每什么不同,就是两个节点的数据比较一下大小,需要的话就把两个节点存储的数据对调一个,链表指针没有变,变了节点的数据。 链表节点类: public ...

    链表排序
    概念什么的都不说了。
    链表排序的原理:和普通的数据排序每什么不同,就是两个节点的数据比较一下大小,需要的话就把两个节点存储的数据对调一个,链表指针没有变,变了节点的数据。
    链表节点类:

    public class ListNode{
    		int data;
    		ListNode next = null;
    		//构造函数
    		public ListNode(int val) {
    			this.data = val;
    		}
    	}
    
    在这里插入代码片
    public ListNode bubbleSort(ListNode head) {
    		if(head == null || head.next == null) {
    			return head;
    		}
    		
    		ListNode cur = head;//当前节点设置为第一个节点
    		ListNode tail = null;//最后一个节点
    		
    		while(cur.next != tail) {
    			
    			while(cur.next != tail) {
    				if(cur.data > cur.next.data) {
    					int tmp = cur.data;
    					cur.data = cur.next.data;
    					cur.next.data = tmp;
    				}
    				cur = cur.next;
    			}
    			
    			tail = cur;//下一次遍历的尾结点是当前结点
    			cur = head;//遍历起始结点重置为头结点 
    		}
    		
    		return head;
    	}
    

    输入的是链表头,输出的也是链表头,头没有变。
    排序方法为冒泡排序法。也可以用其它排序方法。

    链表反转:方法不唯一。
    1.可以链表的数据都存储在一个数组中,再排序,重新组成链表。
    2.改变指针的指向。
    3.递归。
    第一种方法简单,但占用内存多,效率低。
    第二中方法最好。简单,容易理解。
    算法流程:
    准备3个节点变量,分别存储相邻的3个节点,没有第三个节点的话就是null.
    想象一些翻转后的链表是什么样子的,链表的相对位置都没有变,变的只有节点的指针指向。旧链表的头即新链表的尾,所有将链表头的指针指向null。然后将第二个节点的指向改为第一个节点。3个指针变量都下后移一位,再改变指针指向,直到第二个节点为空。新链表的头节点就是此时的第一个节点。

    在这里插入代码片
    public ListNode reverseList(ListNode head) {
    		if(head == null || head.next == null) {//只有一个节点不需要反转
    			return head;
    		}
    		
    		ListNode cur = head;//当前节点
    		ListNode next = head.next;//下一个节点
    		ListNode nextnext = null;//下下个节点
    		
    		//反转后,原头节点变为新链表的尾节点,因此指针为空
    		head.next = null;
    		
    		while(next != null) {
    			nextnext = next.next;
    			
    			//新链表的下一个节点的指针不在指向下下个节点,而是指向它的前一个节点
    			next.next = cur;
    			
    			//移动指针位置,为下一次循环准备。当前cur节点为下一个节点,
    			//下一个节点为下下个节点,直到下下个节点为空.
    			cur = next;
    			next = nextnext;
    		}
    		head = cur;//新的头节点就是旧链表的尾节点,即下一个节点为空的节点。
    		return head;//头指针
    	}
    

    链表遍历:

    在这里插入代码片
    public void printList(ListNode head) {
    		ListNode curNode = head;//当前链表头节点
    		while(curNode != null) {
    			System.out.print(curNode.data + " ");
    			curNode = curNode.next;
    		}
    	}
    

    创建链表:
    public ListNode insertNode(int data,ListNode head) {
    ListNode node = new ListNode(data);//数据转化成节点

    	//链表头是否为空,为空,将此节点作为链表头
    	if(head == null) {
    		head = node;
    		return node;
    	}
    	
    	ListNode curNode = head;//当前链表节点
    	while(curNode.next != null) {//找到最后一个节点
    		curNode = curNode.next;
    	}
    	curNode.next = node;//将新建的节点添加到链表尾部
    	return head;//链表头不变
    }
    
    展开全文
  • JAVA 链表排序(1)

    2018-05-23 13:10:00
    需要排序的类: public class ExperimentContent{ private Long conetentId;//内容id 非空唯一 自增 private Long preContentId; //上级节点id private Long nextContentId;//下级节点 } 具体实现: ...

    需要排序的类:

    public class ExperimentContent{
    	private Long conetentId;//内容id 非空唯一 自增
    	
    	private Long preContentId; //上级节点id
    	
    	private Long nextContentId;//下级节点
    	
    }

    具体实现:

    public List<ExperimentContent> getByExId(Long experimentId) {
    		//从数据库中获取需要排序的的所有对应实体类
    		List<ExperimentContent> ecs = experimetContentMapper.selectByExId(experimentId);
    		//如果是一个直接返回,如果不是再往下走
    		if(ecs.isEmpty() || ecs.size()==1){
    			return ecs;
    		}
    		//定义一个排序的结果集
    		List<ExperimentContent> result = new ArrayList<>();
    		//再从获取列表的首项
    		ExperimentContent begin =  experimetContentMapper.selectHeadContentByExId(experimentId);
    		//将首项从集合中删除
    		ecs.remove(begin);
    		//将首相放入结果集中
    		result.add(begin);
    		//循环
    		while(begin.getNextContentId()!=null){//判断当前的元素的下一个节点是否存在 存在继续循环
    			
    			for (ExperimentContent experimentContent : ecs) {
    				//如果是当前元素
    				if(experimentContent.getConetentId() == begin.getNextContentId()){
    					//将元素从集合中取出作为新的节点,放入结果集,
    					begin = experimentContent;
    					result.add(begin);
    					//并将该元素从遍历的结合中删除
    					ecs.remove(begin);
    					//结束当前循环
    					break ;
    				}
    			}
    		}
    		return result; 
    }

    实际代码讲的有点模糊,举一个简单的例子,main方法共大家学习下:

    public static void main(String[] args) {
    		//定义一个无序集合,初始化一些数据  模拟链表
    		List<Integer> intList = new ArrayList<Integer>();
    		intList.add(1);intList.add(3);intList.add(2);intList.add(5);intList.add(4);
    		//链表集合大小
    		int sum = intList.size();
    		//定义一个空集,用于存放排序后的结果集
    		List<Integer> result = new ArrayList<Integer>(sum);
    		//我们假定首项是 1
    		Integer begin = 1;
    		//将首项放入结果集中
    		result.add(begin);
    		//并从链表中删除
    		intList.remove(begin);
    		//位移到首项的下一项 也就是第二项
    		begin = begin+1;
    		//循环
    		while(begin<=sum){ //判断,总项目不能超过集合总数
    			//遍历链表
    			for (Integer temp : intList) {
    				//如果匹配,将元素从链表中截取出来,放入结果集中,并中断本次循环
    				if(temp == begin){
    					result.add(temp);
    					begin = temp+1;
    					intList.remove(temp);
    					break;
    				}
    			}
    		}
    		//遍历排序后的结果集
    		for (Integer temp : result) {
    			System.out.println(temp);
    		}
    	}
    //结果如下:
    1
    2
    3
    4
    5
    

     

    转载于:https://my.oschina.net/linwl/blog/1817224

    展开全文
  • 冒泡排序算法 import java.util.LinkedList; public class maoPaoSuanFa { public static void main(String[] args) { LinkedList<Integer> list = new LinkedList<Integer>(); for(int i = 0; ...

    冒泡排序算法

    import java.util.LinkedList;
    
    public class maoPaoSuanFa {
    	public static void main(String[] args) {
    		LinkedList<Integer> list = new LinkedList<Integer>();
    		for(int i = 0; i < 10; i ++) {
    			int j = (int) (Math.random() * 100 + 1);
    			list.add(j);
    		}
    		System.out.println("原链表");
    		System.out.println(list);
    		for(int i = 0; i < list.size()-1; i++) {
    			for(int j = 0;j < list.size() - 1 - i;j++) {
    				if(list.get(j) > list.get(j+1)) {
    					int tmp = list.get(j + 1);
    					list.set(j+1, list.get(j));
    					list.set(j, tmp);
    				}
    			}
    		}
    		System.out.println("冒泡排序后的队列");
    		System.out.println(list);
    	}
    }
    

    运行结果

    原链表
    [100, 56, 71, 63, 5, 72, 64, 58, 68, 7]
    冒泡排序后的队列
    [5, 7, 56, 58, 63, 64, 68, 71, 72, 100]

    选择排序算法

    import java.util.LinkedList;
    public class xuanZePaiXu {
    
    	public static void main(String[] args) {
    		LinkedList<Integer> list = new LinkedList<Integer>();
    		for(int i = 0; i < 10; i ++) {
    			int j = (int) (Math.random() * 100 + 1);
    			list.add(j);
    		}
    		System.out.println("原链表");
    		System.out.println(list);
    		for(int i = 0; i < list.size()-1;i ++) {
    			 int minindex = i;
    			for(int j = i + 1; j < list.size(); j ++) {
    				if((list.get(j)) < (list.get(minindex))) {
    					minindex = j;
    				}
    			}
    			int tmp = list.get(i);
    			list.set(i,list.get(minindex));
    			list.set(minindex,tmp);
    		}
    		System.out.println("选择排序后的单链表");
    		System.out.println(list);
    	}
    }
    

    运行结果

    原链表
    [34, 72, 57, 5, 33, 44, 54, 5, 25, 93]
    选择排序后的单链表
    [5, 5, 25, 33, 34, 44, 54, 57, 72, 93]

    插入排序算法

    import java.util.LinkedList;
    
    public class chaRuPaiXu {
    	public static void main(String[] args) {
    		LinkedList<Integer> list = new LinkedList<Integer>();
    		for(int i = 0; i < 10; i ++) {
    			int j = (int) (Math.random() * 100 + 1);
    			list.add(j);
    		}
    		System.out.println("原链表");
    		System.out.println(list);
    		for(int i = 1; i < list.size(); i ++) {
    			int preindex = i - 1;
    			int tmp = list.get(i);
    			while(preindex > -1 && list.get(preindex) > tmp) {
    				list.set(preindex + 1, list.get(preindex));
    				preindex--;
    			}
    			list.set(preindex + 1, tmp);
    		}
    		System.out.println("插入排序后的链表");
    		System.out.println(list);
    	}
    }
    

    运行结果

    原链表
    [39, 66, 79, 71, 40, 67, 88, 91, 10, 73]
    插入排序后的链表
    [10, 39, 40, 66, 67, 71, 73, 79, 88, 91]

    希尔排序算法

    import java.util.LinkedList;
    
    public class XiErPaiXu {
    public static void main(String[] args) {
    	LinkedList<Integer> list = new LinkedList<Integer>();
    	for(int i = 0; i < 10; i ++) {
    		int j = (int) (Math.random() * 100 + 1);
    		list.add(j);
    	}
    	System.out.println("原链表");
    	System.out.println(list);
    	for(int jiange = (int) Math.floor((list.size()) / 2); jiange > 0; jiange = (int) Math.floor(jiange / 2)){
    		for(int i = jiange ;i < list.size();i ++) {
    			int j = i;
    			int current = list.get(i);
    		while(j - jiange >= 0 && current < list.get(j - jiange)) {
    			list.set(j, list.get(j - jiange));
    			j = j - jiange;
    		}
    		list.set(j, current);
    		}
    	}
    	System.out.println("希尔排序后的链表");
    	System.out.println(list);
    }
    }
    

    运行结果

    原链表
    [35, 40, 88, 86, 30, 37, 88, 32, 99, 9]
    希尔排序后的链表
    [9, 30, 32, 35, 37, 40, 86, 88, 88, 99]
    

     

    展开全文
  • java排序链表冒泡排序Java Sorting is one of the many aspects of java interview questions. In this post, we will see java bubble sort example and write a program for bubble sort. Java排序Java面试问题...
  • java单链表排序

    千次阅读 2019-05-31 11:56:10
    在线手写 java单链表排序 单链表每个节点为: public class Node { int val; Node next; public Node(int val) { this.val = val; } } 如果一个单链表为2->1->3->5->4,经过排序链表结构为1...
  • java:链表排序

    千次阅读 2017-04-18 23:18:34
    题目描述:Sort a linked list using insertion sort....使用插入排序链表进行排序 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { *
  • 链表排序相对数组的排序更为复杂些,也是考察求职者是否真正理解了排序算法(而不是“死记硬背”) 链表的插入排序 public class LinkedInsertSort { static class ListNode { int val; ListNode next; ...
  • Java单链表归并排序

    千次阅读 2017-02-24 08:53:59
    该算法是采用分治法(Divide and Conquer)的一个非常典型的应用,归并排序将两个已排序合并成一个。归并排序基本原理通过对若干个有序结点序列的归并来实现排序。 所谓归并是指将若干个已排好序的部分合并成...
  • Java单链表排序方法

    2016-03-13 22:13:19
    import java.util.... * JAVA链表实现的冒泡排序 * @author mengfeiyang * */ public class ListSort { public static void main(String[] args) { ListClass list = new ListClass(); Scanner scan = ne
  • java链表反转及排序

    2018-09-01 12:04:19
    本资料实例讲解java单项链表的实现以及拓展进行排序,每行代码都附有注释
  • 链表进行插入排序,是最简单的一种链表排序算法,用于插入排序是迭代的,所以每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。        每次迭代中,插入排序只从输入数据中移...
  • java单链表冒泡排序

    千次阅读 2014-04-18 13:21:23
    去面试的一家公司出的面试题,让我...java"] //节点类 class Node{ public Node(int value){ this.value = value; } public Node(){ } int value; Node next; } [/code] 获得随机的链表 ...
  • Java链表排序

    千次阅读 2011-11-14 14:17:00
    import java.util.ArrayList; import java.util.Collections; import java.util.TreeSet; public class Comp implements Comparable{ private int x; private int y; @Override public int c
  • import java.util.List; class ListNode{ int val; ListNode next; ListNode(int val,ListNode next){ this.val=val; this.next=next; } } public class SortList { public st...
  • Java-链表选择排序

    2020-10-01 22:40:40
    给定一个无序单链表,实现单链表的选择排序(按升序排序)。 示例1 输入 [1,3,2,4,5] 输出 {1,2,3,4,5} import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * } ...
  • java实现无序链表排序

    2020-08-11 18:49:28
    import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; class Node { int val; Node next; public Node(int val) { this.val = val; } } class MyComparator{ public ...
  • 链表插入排序java实现

    2020-03-15 14:17:44
    插入排序的思想是:依次读取链表当前值,将其插入之前已排序好的部分中的正确位置,不断的向向已排序的新链表中添加新的节点,并且保证添加节点后的列表仍然有序,直至原链表遍历完毕。 /** * Definition for ...
  • 上篇博客中讲解了九大内部排序算法,部分算法还提供了代码实现,但是那些代码实现都是基于数组进行排序的,本篇博客就以链表排序实现几种常见的排序算法,以飨读者。 快速排序链表实现 算法思想:对于一个链表...
  • 链表排序(Java)

    2019-07-21 18:36:34
    这是自己的第一篇博客,话说学习是50%的学习,另外50%是解释,以后会分享自己遇到的一些问题,欢迎各位大佬指教。 第一篇 对象数组排序的问题处理。 ..
  • 1. 对链表进行插入排序(力扣:147) 2. 排序链表(力扣:148) Java实现
  • 关于链表的定义和创建,节点的插入,节点删除,节点查找,判断是否为空,判断是否为尾节点,链表元素的排序,两个有序链表的合并,链表的反转,获取最后四个链表元素,获取链表的中间节点元素,交换链表节点,链
  • Java实现-链表排序

    2017-06-08 22:37:34
    /** * Definition for ListNode. * public class ListNode { * int val; * ListNode next; * ListNode(int val) { * this.val = val; * this.next = null; * } * } */ p

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,612
精华内容 45,444
关键字:

java链表排序

java 订阅