单链表的简单实现

#include<stdlib.h>

#include<stdio.h>

//定义数组的大小为100

//头结点：有时，在链表的第一个结点以前会额外增设一个结点，

//结点的数据域通常不存放数据（有些状况下也能够存放链表的长

//度等信息），此结点被称为头结点。

//若头结点的指针域为空（NULL），代表链表是空表。头结点对于链表来讲

//，不是必须的，在处理某些问题时，给链表添加头结点会使问题变得简单。

//头指针：永远指向链表中第一个结点的位置（

//若是链表有头结点，头指针指向头结点；不然，头指针指向首元结点）。

typedef int elementType;

typedef struct Lnode{

//存储的数据

elementType data;

//存储下一个指针

struct Lnode *next;

}LinkList;

LinkList* init(LinkList *head){

head = (LinkList *)malloc(sizeof(LinkList));

if(head==NULL)

 {
 	printf("内存没啦");
	
 	return NULL; 
 }
 
 head->next=NULL;
 
 printf("初始化成功\n");
 
 return head;

}

void insert(LinkList *head,elementType x,int i){

if(i<0){

	printf("插入的位置不能为负数\n");
	
	return;
}

int j=-1;

LinkList *p,*s;
p=head;

while(p->next!=NULL&&j<i-1){

	p=p->next;
	
	j++;
}

if(j!=i-1)
{
	printf("插入位置有误\n");
	
	return ;
}

 s = (LinkList *)malloc(sizeof(LinkList)); 
 
 if(s==NULL){
 
 	printf("内存没了");
	
 	return;
 } 
 s->data=x;
 
 s->next = p->next;
 
 p->next=s;
 
 
 printf("插入成功\n");

}

//根据索引取值 ,咱们没有判断索引的位置是否有问题

int getItem(LinkList *head,int i){

LinkList *p=head;

int j=-1;

while(p->next!=NULL&&j<i){

	j++;
	
	p=p->next; 
	
}
//这个地方返回-1是一个bug 

if(j!=i)

return -1;

return p->data;

}

void delete1(LinkList *head,int i){

int j=-1;

LinkList *p,*s;

p=head;

while(p->next!=NULL&&j<i-1){

	p=p->next;
	
	j++;
  } 
  
  if(j!=i-1){
  
  		printf("删除位置有误\n");
		
  	return;

  }
  #此处判断删除的索引位置超过索引的最大值 
  
  if(p->next==NULL)
  {
  	printf("位置不存在\n");
	
  	return;
  }

s=p->next;

p->next=s->next;

free(s);

return;

}

int main(){

//建立一个空表

LinkList *head;

head = init(head);

for (int i=0;i<10;i++)

insert(head,i+1,i);

int x;

delete1(head,11);

for( int i=0;i<10;i++){

x= getItem(head,i);

printf("%d\n",x);

} }

java

public class Node {

//指针域

public Node next;

//数据域

public int data;


public Node(int data){


    this.data=data;
}

}

public class Link_list {

private Node head;

private Node current;

//给size的目的是，当判断边界的时候，不须要去求长度

private int size=0;

//初始化头结点

public Link_list(){

    this.head=null;
}
//向链表中添加数据，都是经过尾部插入的

public void addHead(Link_list head,int data){

   //主要考虑两种状况，1 一个节点都没有，2 有节点的状况

   //建立一个新的节点
   
    Node temp = new Node(data);
	
    //新节点的next指向head.head
	
    temp.next = head.head;
	
    //head.head指向新建立的节点
	
    head.head=temp;
	
     size++;
	 
    System.out.println(temp.data);
	
}

public void add_index(Link_list head,int i,int x){

    if(i==0) {
	
        addHead(head,x);
		
        return;
    }
	
    //判断插入索引的位置是否符合条件
	
    if(i<0||i>size)
    {
        System.out.println("插入的索引位置有误");
		
        return;
    }
	
    //若是程插入进行到此步时,说明该链表有很多于一个点，因此j=1
	
    int j=1;
	
    Node p=head.head;
	
    ///找到索引i的位置
    while(p.next!=null&&j<i){
	
        j++;
		
        p=p.next;
    }

    Node s =new Node(x);
	
    s.next=p.next;
	
    p.next=s;
	
    size++;
	
    System.out.println(s.data);
	
}
//经过索引获取值

public int getElement(Link_list head,int i)throws Exception{

    int j=0;
	
    //我所给的索引位置是从0开始，而我记录的size也是从0开始的
	
    if(i<0||i>size)
	
      throw new IndexOutOfBoundsException("查找的索引位置出错");

    Node p =head.head;
	
    while (p!=null&&j<i){
	
        p=p.next;
		
        j++;
    }
	
    if(j>i)
	
        throw new Exception("查找的索引位置出错");
		
    return  p.data;

}

//经过索引删除值

public void delete_list(Link_list head,int i) throws Exception{

    if(i<0||i>=size)
	
        throw new Exception("删除索引位置出错");
		
    int j=0;
	
    Node p = head.head;
	
    if(i==0) {
	
        head.head = p.next;
		
        return;
    }
	
    //找出删除索引的前一个
	
    while (p.next!=null&&j<i-1){
	
        p=p.next;
		
        j++;
    }

    p.next=p.next.next;
}
public static void main(String[] args) throws Exception {

   Link_list list = new Link_list();
   
   list.add_index(list,0,110);
   
    list.add_index(list,0,111);
	
    list.add_index(list,2,123);
	
  list.delete_list(list,2  );
  
    System.out.println(list.getElement(list,0));
	
    System.out.println(list.getElement(list,1));
	
}

}