数据结构：链表 >> 链表按结点中第j个数据属性排序(冒泡排序法)

创建结点类，链表类，测试类

 import java.lang.Object;
 //结点node=数据date+指针pointer
 public class Node {
     Object iprop;
     public Object getIprop(int i){
     switch(i){
     case 1:iprop=num;break;
     case 2:iprop=name;break;
     case 3:iprop=score;break;
     }
     return iprop;
     }
    //数据data
     Object num,name,score;
     //指针pointer
     Node next;
     public Node(Object obj1,Object obj2,Object obj3){
         num=obj1;
         name=obj2;
         score=obj3;
     }
     public Node(){

     }
 }

 //链表List=头结点head+尾结点tail+链表名Lname
 public class List {

     // 头结点head
     Node head;
     // 尾结点tail
     Node tail;
     // 链表名Lname
     String Lname;
     int length=0;

     // 初始化链表时，里面没有结点，为空链表
     public List(String str) {
         head = tail = null;
         Lname = str;
     }

     public List() {
         head = tail = null;
         Lname = "List";
     }

     // 头插法
     public List appendToFront(Node n) {

         if(this.head==null){
            head=tail=n;
            length++;
            //n.next=null;
         }else{

             n.next=head;
             head=n;
             length++;
         }
         return this;

     }

     // 尾插法
     public List appendToTail(Node n) {
         //
         if(head!=null){
            tail.next=n;
            tail=n;
         }else{
             head=tail=n;
             //n.next=null;
         }
         return this;

     }

     // 插入结点到第i个结点之后
     public void insert(Node n, int i) {

     }

     // 插入结点到第j个data为obj的结点之后
     public void insert(Node n, Object obj, int i) {

     }

     // 遍历链表
     public void visitAll() {
        //创建pointer p
        Node p=new Node();
        //拿到头结点的引用
        p=head;
        //顺序拿到结点做展示
        for(;p!=null;){
            System.out.println("num:"+p.num+"name:"+p.name+"score:"+p.score);
            p=p.next;
        }
     }

     // 拿到第i个结点
     public Node getNode(int i) {
         //定义浏览指针p
         Node p=new Node();

         //定义循环参数j
         int j=1;

         //循环结点
         p=this.head;
         if(p!=null)
         for(;j<i;j++){

             p=p.next;
             if(p==null){System.out.println("p==null遍历结束，无此结点");break;}

         }
         return p;
     }

     // 拿到第j个data为obj的结点
     public Node getNode(Object obj, int j) {
         //拿到头结点的引用
         Node p=head;
         //循环数据并比较data
             for(;p!=null;){

                 for(int i=0;i<j;i++){
                 Object prop=p.getIprop(j);
                 if(prop!=null&&prop.equals(obj)) {return p;}
                 }
                 p=p.next;
             }
         return p;
     }

     // 删除第i个结点
     public void delete(int i) {
         //找到i结点

     }

     // 删除第j个data为obj的结点
     public void delete(Object obj, int j) {

     }

     // 删除全部
     public void deleteAll() {

     }
     // 链表的排序:list中的node按第j个data的值进行排序
     // >>直接插入法
     public List listSort(int j){

         //循环当前链表的结点对象，找到第j个data值
         Node p=head;//想象head 下标为0,head.next依次类推
         int[] datas=new int[this.length];
         for(int i=0;p!=null;i++){
             Object prop=p.getIprop(j);//
             if(prop!=null){
                 System.out.println("循环到下标为"+i+"的结点");
                 datas[i]=Integer.parseInt(prop.toString());

             }
             p=p.next;
         }
         //冒泡排序
         Node pre=null;

         for(int i=0;i<datas.length-1;i++){
             pre=null;
             p=head;

             for(int k=0;k<datas.length-i-1;k++){

                 if(datas[k]>datas[k+1]){

                     int temp=datas[k];
                     datas[k]=datas[k+1];
                     datas[k+1]=temp;

                     Node tempNode=p.next.next;

                     pre.next=p.next;
                     p.next.next=p;
                     p.next=tempNode;

                     pre=pre.next;

                 }else{
                 //拿到前驱结点
                 pre=p;
                 p=p.next;
                 }
             }
         }

         return this;
     }
     public static void main(String[] arg){
         int[] datas={4,2,5,6,7,3,1,0,9,8};
         //冒泡排序法
         for(int i=0;i<datas.length-1;i++){
             for(int j=0;j<datas.length-(i+1);j++){
                 if(datas[j]>datas[j+1]){
                     int temp=datas[j];
                     datas[j]=datas[j+1];
                     datas[j+1]=temp;
                 }
             }
         }
         for(int i=0;i<datas.length;i++){
         System.out.println(datas[i]);}
     }

 }

 public class TestList {
     public static void main(String[] arg){
         Node n0=new Node(125,"n0","91");
         Node n1=new Node(123,"n1","98");
         Node n2=new Node(121,"n2","99");
         Node n3=new Node(125,"n3","96");
         Node n4=new Node(125,"n4","95");
         Node n5=new Node(125,"n5","97");
         Node n6=new Node(125,"n6","93");
         Node n7=new Node(125,"n7","94");
         Node n8=new Node(125,"n8","92");
         Node n9=new Node(125,"n9","90");

         List f1=new List("f1List");
         //头插法
         f1.appendToFront(n0).appendToFront(n1).appendToFront(n2).appendToFront(n3)
         .appendToFront(n4).appendToFront(n5).appendToFront(n6).appendToFront(n7)
         .appendToFront(n8).appendToFront(n9);

         //拿到排好序的链表f2;
         f1.listSort(3).visitAll();

     }

 }

冒泡排序用处真大

心得：

>>对于指针（引用）的运用需要注意如下：

Node p=f1List.head;

p=p.next;//让指针直接指向（即直接p=）新引用对象（p.next），不会引起原被引用对象（head）的任何变化

Node p=f1List.head;
        p.next=p;//调用原被引用对象的属性后，将会引起原被引用对象（head）的属性相应的变化