C :

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct List{
	int elem;
	struct List *next;
}List;

void get(List *l,int n)
{
	List *p;
	int flag = 0;
	p = l;
	while(p->next != NULL)
	{
		n --;
		if(n == 0)
		{
			flag = 1;
			break;
		}
		p = p->next;
	}
	if(flag == 1)
	{
		printf("%d\n",p->next->elem);
	}
	else
	{
		printf("get fail\n");
	}
}

void insert(List *l,int n,int e)
{
	int flag = 0;
	List *p,*q;
	q = (List *)malloc(sizeof(List));
	q->elem = e;
	q -> next = NULL;
	p = l;
	do
	{
		n --;
		if(n == 0)
		{
			flag = 1;
			break;
		}
		p = p ->next;
	}while(p != NULL);
	if(flag)
	{
		q->next = p->next;
		p->next = q;
		printf("insert OK\n");
	}
	else
	{
		printf("insert fail\n");
	}
}

void dele(List *l,int n)
{
	List *p,*q;
	int flag = 0;
	p = l;
	while(p->next != NULL)
	{
		n --;
		if(n == 0)
		{
			flag = 1;
			break;
		}
		p = p->next;
	}
	if(flag == 1)
	{
		q = p->next;
		p->next = p->next->next;
		free(q);
		printf("delete OK\n");
	}
	else
	{
		printf("delete fail\n");
	}
}

void show(List *l)
{
	List *p;
	p = l;
	if(l->next == NULL)
	{
		printf("Link list is empty\n");
		return;
	}
	while(p->next != NULL)
	{
		if(p->next->next != NULL)
			printf("%d ",p->next->elem);
		else
			printf("%d\n",p->next->elem);
		p = p->next;
	}
}

int main()
{
	int n,m;
	int x,y;
	int i;
	List *l,*p;
	char order[10];
	l = (List *)malloc(sizeof(List));
	l->next = NULL;
	scanf("%d",&n);
	for(i = 0;i < n;i ++)
	{
		p = (List*)malloc(sizeof(List));
		p->next = NULL;
		scanf("%d",&p->elem);
		p->next = l->next;
		l->next = p;
	}	
	scanf("%d",&m);
	getchar();
	while(m != 0)
	{
		m --;
		scanf("%s",order);
		//printf("%s\n",order);
		if(strcmp(order,"get") == 0)
		{
			scanf("%d",&x);
			getchar();
			get(l,x);
		}
		else if(strcmp(order,"insert") == 0)
		{
			scanf("%d%d",&x,&y);
			getchar();
			insert(l,x,y);
		}
		else if(strcmp(order,"delete") == 0)
		{
			scanf("%d",&x);
			getchar();
			dele(l,x);
		}
		else if(strcmp(order,"show") == 0)
		{
			show(l); 
		}
	}
	return 0;
}

C++ :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;	// 定义元素的类型为整型
typedef int Status;		// 定义状态类型
#define ERROR 0
#define OK 1

typedef struct LNode{
	ElemType data;		// 定义数据元素
	struct LNode *next;	// 定义下一节点的链接（指针）
}LNode, *LinkList;		// 定义节点类型以及链表类型（链表类型实际上是一个节点指针类型）

Status GetElem_L(LinkList &L, int i, ElemType &e) { // 算法2.8
	// L为带头结点的单链表的头指针。
	// 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
	LinkList p;
	p = L->next;
	int j = 1; // 初始化，p指向第一个结点，j为计数器
	while (p && j < i) { // 顺指针向后查找，直到p指向第i个元素或p为空
		p = p->next;
		++j;
	}
	if (!p || j > i)
		return ERROR; // 第i个元素不存在
	e = p->data; // 取第i个元素
	return OK;
} // GetElem_L

Status ListInsert_L(LinkList &L, int i, ElemType e) { // 算法2.9
	// 在带头结点的单链线性表L的第i个元素之前插入元素e
	LinkList p, s;
	p = L;
	int j = 0;
	while (p && j < i - 1) { // 寻找第i-1个结点
		p = p->next;
		++j;
	}
	if (!p || j > i - 1)
		return ERROR; // i小于1或者大于表长
	s = (LinkList) malloc(sizeof(LNode)); // 生成新结点
	s->data = e;
	s->next = p->next; // 插入L中
	p->next = s;
	return OK;
} // LinstInsert_L

Status ListDelete_L(LinkList &L, int i, ElemType &e) { // 算法2.10
	// 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	LinkList p, q;
	p = L;
	int j = 0;
	while (p->next && j < i - 1) { // 寻找第i个结点，并令p指向其前趋
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i - 1)
		return ERROR; // 删除位置不合理
	q = p->next;
	p->next = q->next; // 删除并释放结点
	e = q->data;
	free(q);
	return OK;
} // ListDelete_L

void CreateList_L(LinkList &L, int n) { // 算法2.11
	// 逆位序输入n个元素的值，建立带表头结点的单链线性表L
	LinkList p;
	int i;
	L = (LinkList) malloc(sizeof(LNode));
	L->next = NULL; // 先建立一个带头结点的单链表
	for (i = n; i > 0; --i) {
		p = (LinkList) malloc(sizeof(LNode)); // 生成新结点
		scanf("%d", &p->data); // 读入元素值
		p->next = L->next;
		L->next = p; // 插入到表头
	}
} // CreateList_L

int ShowList_L(LinkList L){
	// 显示链表中的元素，返回值为链表元素的数目
	int numOfList = 0;		// 记录链表中元素的数目
	LinkList p = L->next;	// 用来遍历链表元素的指针
	while(p){				// 如果该结点不为空
		if(numOfList){		// 如果该元素不是列表中的第一个元素（先判断值是否为0，然后加1）
			putchar(' ');
		}
		numOfList++;		// 元素的数目加1
		printf("%d",p->data);	// 输出元素
		p = p->next;		// 指针向后移动
	}
	if(numOfList == 0){		// 如果链表中的元素数目为0，说明是空链表
		return 0;
	}else{
		putchar('\n');		// 注意换行
		return numOfList;	// 返回链表中元素的数目
	}
}

int main(){

	int n;					// 初始时元素的数目
	int m;					// 指令的数目
	char strInst[30];		// 存储指令:instruction
	int a;					// 存储位置数据
	LinkList L;				// 链表
	int e;					// 定义节点，用来存储获取的节点或者删除的节点
	scanf("%d", &n);		// 读入元素的数目
	CreateList_L(L, n);		// 创建链表
	scanf("%d", &m);		// 读取指令的数目
	while(m--){				// 做 m 次循环
		scanf("%s", strInst);					// 读取指令
		if(strcmp(strInst, "get") == 0){		// 如果是需要获取某个元素
			scanf("%d", &a);					// 读取元素的位置
			if(GetElem_L(L, a, e) == OK){		// 如果获取元素成功
				printf("%d\n", e);				// 输出元素的值
			}else{								// 如果获取元素失败
				puts("get fail");				// 输出获取元素的出错信息
			}
		}else if(strcmp(strInst, "insert") == 0){// 如果是插入某个元素
			scanf("%d%d", &a, &e);				// 获取待插入的位置以及待插入的值
			if(ListInsert_L(L, a, e) == OK){	// 如果插入元素成功
				puts("insert OK");				// 输出插入成功的信息
			}else{
				puts("insert fail");			// 否则输出插入失败的信息
			}
		}else if(strcmp(strInst, "delete") == 0){// 如果是删除某个元素
			scanf("%d",&a);						// 获得待删除元素的位置
			if(ListDelete_L(L, a, e) == OK){	// 如果删除成功
				puts("delete OK");				// 输出删除成功的信息
			}else{
				puts("delete fail");			// 否则输出删除失败的信息
			}
		}else if(strcmp(strInst, "show") == 0){	// 如果是显示链表
			if(ShowList_L(L) == 0){				// 如果链表为空
				puts("Link list is empty");		//显示量表为空的信息
			}
		}
	}

	return 0;
}

Pascal :

program acm1326;
type
 node=^rec;
 rec=record
  data:longint;
  link:node;
 end;
var
 slow,p,q:node; n,i,key:longint; st:string;

procedure insert(st:string);
var
 t,x,t2,i:longint; u,head,ko:node; st2:string;
begin
 u:=q; head:=q; t:=pos(' ',st);
 delete(st,1,t); t:=pos(' ',st); st2:=copy(st,t+1,length(st)-t);
 delete(st,t,length(st)-t+1);
 val(st,t); val(st2,t2);
 if (u=nil)and(t>1) then begin write('insert fail'); exit;end;
 for i:=1 to t-1 do
  begin
   u:=u^.link;
   if u=nil then begin write('insert fail'); exit; end;
  end;
 for i:=1 to t-2 do
  head:=head^.link;
 if t=1 then begin new(ko); ko^.data:=t2; ko^.link:=u; q:=ko; end  else begin
 new(ko); ko^.data:=t2; ko^.link:=u; head^.link:=ko;end; write('insert OK');
end;

procedure show;
var
 u:node;
begin
 u:=q; if u=nil then begin write('Link list is empty'); exit; end;
 write(u^.data); u:=u^.link;
 while u<>nil do
  begin
   write(' ',u^.data);
   u:=u^.link;
  end;
end;

procedure delete2(st:string);
var
 t,i:longint;  u,head:node;
begin
 t:=pos(' ',st); delete(st,1,t); val(st,t);
 u:=q;  head:=q;
 if u=nil then begin write('delete fail'); exit; end;
 for i:=1 to t-1 do
  begin
   u:=u^.link;
   if u=nil then begin write('delete fail'); exit; end;
  end;
 for i:=1 to t-2 do
  head:=head^.link;
 if t=1 then q:=q^.link else begin
 head^.link:=u^.link; end; write('delete OK');
end;

procedure get(st:string);
var
 t,i:longint;  u:node; f:boolean;
begin
 u:=q;  f:=false;
 t:=pos(' ',st); delete(st,1,t); val(st,t);
  i:=0;
 while u<>nil do
  begin
   inc(i);
   if i=t then begin write(u^.data); f:=true; exit; end;
   u:=u^.link;
  end;
 if not f then write('get fail');
end;

begin
 read(n); p:=nil;
 for i:=1 to n do
  begin
   read(key); new(q);
   q^.data:=key; q^.link:=p;
   p:=q;
  end;
 readln(n);
 for i:=1 to n do
  begin
   readln(st);
   if st[1]='g' then begin get(st); end;
   if st[1]='s' then begin show; end;
   if st[1]='i' then begin insert(st);end;
   if st[1]='d' then begin delete2(st);end;
   writeln;
  end;
end.

Java :

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class Main{
   private static Scanner s = new Scanner(System.in) ;
   public static void main(String[] args) {
	  int n = s.nextInt() ;
	  
	  List<Integer> list = new LinkedList<Integer>() ;
	  int a[] = new int[n] ;
	  for (int i = 0; i < n; i++) {
		  int temp = s.nextInt() ;
		  a[i] = temp ;
		  
	  }
	  
	  for (int i = a.length-1;i>=0 ; i--) {
		list.add(a[i]) ;
	}
	  int m = s.nextInt() ;
	  s.nextLine() ;
	  for (int i = 0; i < m; i++) {
		 String str = s.nextLine() ;
		 f(list, str);
	  }
   }
   static void f(List<Integer>list , String str){
	   String strs[] = str.split("\\s+") ;
	   if(strs[0].equals("show")){
		   show(list);
	   }else if(strs[0].equals("delete")){
		   delete(list, Integer.parseInt(strs[1])-1);
	   }else if(strs[0].equals("insert")){
		   insert(list, Integer.parseInt(strs[1])-1, Integer.parseInt(strs[2]));
	   }else if(strs[0].equals("get")){
		   get(list, Integer.parseInt(strs[1])-1);
	   }
   }
   static void show(List<Integer> list){
	   if(list.size()==0){
		   System.out.println("Link list is empty");
	   }else {
	   for (int i = 0; i < list.size(); i++) {
		  if (i==list.size()-1) {
			System.out.println(list.get(i)) ;
		  }
		  else {
			  System.out.print(list.get(i)+" ");
		  }
	   }
	   }
   }
   
   static void delete(List<Integer> list,int i){
	   try{
	      list.remove(i) ;
	      System.out.println("delete OK");
	   }catch(Exception e){
		   System.out.println("delete fail");
	   }
   }
   
   static void insert(List<Integer> list,int i , int j){
	   try{
	     list.add(i, j);
	     System.out.println("insert OK");
	   }catch(Exception e){
		   System.out.println("insert fail") ;
	   }
   }
   
   static void get(List<Integer> list,int i){
	   try {
		System.out.println(list.get(i)) ;
		
	} catch (Exception e) {
		// TODO: handle exception
		System.out.println("get fail");
	}
   }
}