单链表

/ c++ 实现///////////

//单列表遇到的坑因为传的是指针plink=plink->next 后原来plink的头结点变了因此要在开始保存原来的头结点同时返回头结点

//单列表遇到的坑因为传的是指针plink=plink->next 后原来plink的头结点变了因此要在开始保存原来的头结点同时返回头结点
#include<iostream>
using namespace std;
typedef struct node{
    int Num;
    struct node* next;
}  link;
typedef struct node* plink;
//创建结点
plink Create_link(int num)
{
    plink lp;
    lp=(plink)malloc(sizeof(link));
    lp->Num=num;
    lp->next=NULL;
    return lp;
}
//创建环
plink Create_link_list(int Lsum)
{
    plink pHead;//头结点
    plink temp;//临时变量
    plink pnow;//当前结点
    pHead=Create_link(0);//先创建一个头结点
    pnow=pHead;//当前结点等于头结点
    for (int i = 1; i<Lsum; i++) {//由于头结点创建了因此从第二个开始
        temp = Create_link(i);//创建临时结点
        pnow->next=temp;//创建的结点给当前结点(头结点)的next指针
        pnow = temp;//当前结点变为新创建的结点
    }
    pnow->next=NULL;//当前结点为最后一个
//    pnow->next=pHead;//当前结点为最后一个  表示环
    return pHead;
}
//求列表的长度
int Length_link_list(plink pl)
{
    plink pHead;
    pHead=pl;//先保存头结点
    int n=1;
    while (pl->next) {
        ++n;
        pl=pl->next;
    }
    pl=pHead;//还原头结
    return n;
}
//指定数据删除某个结点
plink Delete_link_list(plink pl, int num)
{
    plink pHead, p , q;//q 是哨兵
    pHead=pl;//这里必须要保存头结点，因为是指针循环之后不是头结点了
    p=pl;
    //思路如果没到相等那个一直循环把当前结点给哨兵同时 p++ （如果相等也就是p是要删除的那个，不进入循环，由于哨兵一直是 p 的前一个，因此用哨兵的next指向p->next->next)
    //不能是第一个与最后一个
    while (p->Num!=num) {
        q=p;
        p=p->next;
    }
    q->next=p->next;
    free(p);
    return pHead;
}
//打印
plink Prinf_link_list(plink pl)
{
    plink pHead,p;//pHead保存头结点
    pHead=pl;
    p=pl;
    while (p->next) {
        cout<<p->Num<<endl;
         p=p->next;
    }
    if(p->next==NULL) cout<<p->Num<<endl;
    return pHead;
}
int main()
{
    plink pl = Create_link_list(10);
    Prinf_link_list(pl);
    cout<<Length_link_list(pl)<<endl;
    cout<<"///"<<endl;
    plink plnum = Delete_link_list( pl, 4);
    Prinf_link_list(plnum);
    cout<<Length_link_list(pl)<<endl;
    return 0;
}

/ java 实现/

遇到的坑在 java 中不像 c++ java 是完全面向对象因此所有对象都要 new 出来不然报空指针 NullPointerException

package javaapplication2;

/**
 *
 * @author allenboy
 */
public class Node {
       public int Num;//数据域
       Node next;//指针域
}

package javaapplication2;
/**
 *
 * @author allenboy
 */
public class testjava {
    public Node first; // 定义一个头结点
    //构造函数初始化first 在 java 中所有对象都要 new 出来
    public testjava() {
        //不写这句报NullPointerException错误
        this.first = new Node();
    }
    //创建单个结点
    public Node Create_link(int n){
        Node newnode =new Node();
        //赋值
        newnode.Num=n;
        newnode.next=null;
        return newnode;
    }
    //创建列表
    public Node Create_link_list(testjava test,int Lsum)
    {
        Node q = first;//先把头结点保存
        for(int i = 1;i<Lsum;i++){
            Node temp = test.Create_link(i);
            first.next=temp;
            first = temp;
        }
        return q;
    }
    //打印
    public void Prinf_link_list(Node pl){
         Node p;//pHead保存头结点
         p=pl;
         while(p.next!=null)
         {
         System.out.println(p.Num); 
         p=p.next;
         }
         if(p.next==null) System.out.println(p.Num); 
    }

    public static void main(String[] args)
	{
            testjava testjava =new testjava();
            Node pl = testjava.Create_link_list(testjava,22);
           testjava.Prinf_link_list(pl);
        }
}

/ python 实现/

# -- coding: utf-8 --

#python 中遇到的坑与 java 一样 用类做为列表时 第一个头结点必须初始化（self.head=node(0)）
#声明一个结点类
class node(object):
    def __init__(self,num):
      self.Num=num
      self.Nnext = None
#列表类
class LinkList(object):
#初始化头结点
    def __init__(self):
        self.head=node(0)
#创建列表
    def Create_link(self, num):
       myhead = self.head
       for i in range(1,num):
           newnode = node(i)
           myhead.Nnext =newnode
           myhead = myhead.Nnext
#打印结点
    def Prinf_link_list(self,num):
        myhead = self.head
        for i in range(0, num):
            print (myhead.Num)
            myhead= myhead.Nnext

if __name__=='__main__':
    link = LinkList()
    link.Create_link(100)
    link.Prinf_link_list(100)